Python网络编程(socket)

Python实用教程_spiritx的博客-CSDN博客 

网络编程指的是：在程序中实现两台计算机之间的通信。Python提供了大量网络编程的工具和库，本文重点学习socket和select模块。

网络编程涉及许多关于TCPIP的基础知识，本文默认对这些知识已经了解了，不再对TCPIP相关的知识进行学习。

socket模块

这个模块提供了访问 BSD 套接字 的接口。在所有现代 Unix 系统、Windows、macOS 和其他一些平台上可用。

socket又称“套接字”，应用程序通常通过“套接字”向网络发出请求或应答网络请求，使主机间或一台计算机上的进程间可以通信。socket模块提供了标准的网络接口，可以访问底层操作系统socket接口的全部方法。

创建套接字socket

class socket.socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)

使用给定的地址族、套接字类型和协议号创建一个新的套接字。

• family：地址族应为 AF_INET (默认值), AF_INET6, AF_UNIX, AF_CAN, AF_PACKET 或 AF_RDS 之一。
• type：套接字类型应为 SOCK_STREAM (默认值), SOCK_DGRAM, SOCK_RAW 或其他可能的 SOCK_ 常量之一。
• proto：协议号通常为零并且可以省略，或在协议族为 AF_CAN 的情况下，协议应为 CAN_RAW, CAN_BCM, CAN_ISOTP 或 CAN_J1939 之一。
• 如果指定了 fileno，那么将从这一指定的文件描述符中自动检测 family、type 和 proto 的值。如果调用本函数时显式指定了 family、type 或 proto 参数，可以覆盖自动检测的值。这只会影响 Python 表示诸如 socket.getpeername() 一类函数的返回值的方式，而不影响实际的操作系统资源。与 socket.fromfd() 不同，fileno 将返回原先的套接字，而不是复制出新的套接字。这有助于在分离的套接字上调用 socket.close() 来关闭它。

socket.socketpair([family[, type[, proto]]])

构建一对已连接的套接字对象，使用给定的地址簇、套接字类型和协议号。地址簇、套接字类型和协议号与上述 socket() 函数相同。默认地址簇为 AF_UNIX （需要当前平台支持，不支持则默认为 AF_INET ）。

可以理解为 创建了两个socket, 比喻为一个server的 socket，一个client的socket，这两个socket是已经connected连接状态

是全双工模式，也就是每个socket都能收发，比喻为server.send--->client.recv,和 client.send--->server.recv

import socket
import time
import os
from multiprocessing import Process
 
 
def servlet(sock :socket.socket):
    while True:
        msg = sock.recv(1024)
        print(f'servlet{os.getpid()},recv:{msg=}')
        if msg.decode() == 'quit':
            break
        sock.send(msg.upper())
 
 
def client(sock :socket.socket):
    sock.send(f'client{os.getpid()}, hello world!'.encode())
    msg = sock.recv(1024)
    print(msg)
 
    sock.send('I love you forever!'.encode())
    msg = sock.recv(1024)
    print(msg)
 
    sock.send('quit'.encode())
    time.sleep(1)
 
 
if __name__ == '__main__':
    s, c = socket.socketpair()
 
    p1 = Process(target=servlet, args=(s,))
    p2 = Process(target=client, args=(c,))
    p1.start()
    p2.start()
    p2.join()
    p2.join()
 
    s.close()
    c.close()
 
‘’'
servlet34196,recv:msg=b'client34197, hello world!'
b'CLIENT34197, HELLO WORLD!'
servlet34196,recv:msg=b'I love you forever!'
b'I LOVE YOU FOREVER!'
servlet34196,recv:msg=b'quit'
‘''

socket.create_connection(address, timeout=GLOBAL_DEFAULT, source_address=None, *, all_errors=False)

• 连接到一个在互联网 address (以 (host, port) 2 元组表示) 上侦听的 TCP 服务，并返回套接字对象。 这是一个相比 socket.connect() 层级更高的函数：如果 host 是非数字的主机名，它将尝试将其解析为 AF_INET 和 AF_INET6，然后依次尝试连接到所有可能的地址直到连接成功。 这使编写兼容 IPv4 和 IPv6 的客户端变得很容易。
• 传入可选参数 timeout 可以在套接字实例上设置超时（在尝试连接前）。如果未提供 timeout，则使用由 getdefaulttimeout() 返回的全局默认超时设置。
• 如果提供了 source_address，它必须为二元组 (host, port)，以便套接字在连接之前绑定为其源地址。如果 host 或 port 分别为 '' 或 0，则使用操作系统默认行为。
• 当无法创建连接时，将会引发一个异常。 在默认情况下，它将是来自列表中最后一个地址的异常。 如果 all_errors 为 True，它将是一个包含所有尝试错误的 ExceptionGroup。

socket.create_server(address, *, family=AF_INET, backlog=None, reuse_port=False, dualstack_ipv6=False)

创建socket监听服务。

family 应当为 AF_INET 或 AF_INET6。 backlog 是传递给 socket.listen() 的队列大小；当未指定时，将选择一个合理的默认值。 reuse_port 指定是否要设置 SO_REUSEPORT 套接字选项。
如果 dualstack_ipv6 为 true 且平台支持，则套接字能接受 IPv4 和 IPv6 连接，否则将抛出 ValueError 异常。大多数 POSIX 平台和 Windows 应该支持此功能。启用此功能后，socket.getpeername() 在进行 IPv4 连接时返回的地址将是一个（映射到 IPv4 的）IPv6 地址。

socket.fromfd(fd, family, type, proto=0)

复制文件描述符 fd （一个由文件对象的 fileno() 方法返回的整数），然后从结果中构建一个套接字对象。地址簇、套接字类型和协议号与上述 socket() 函数相同。文件描述符应指向一个套接字，但不会专门去检查——如果文件描述符是无效的，则对该对象的后续操作可能会失败。本函数很少用到，但是在将套接字作为标准输入或输出传递给程序（如 Unix inet 守护程序启动的服务器）时，可以使用本函数获取或设置套接字选项。套接字将处于阻塞模式。

套接字对象

创建套接字后，就可以使用套接字对象。

套接字对象的主要方法和属性有：

构建服务

构建服务需要以下几个步骤：

1. 创建socket对象；
2. 使用bind()绑定服务器地址和端口；
3. 使用listen()启动监听队列，监听客户端的连接请求；
4. 使用accept获取客户端的连接，这个方法会阻塞住，等到客户端有连接时才会返回；
5. 获得客户端连接的socket后，使用客户端的连接进行数据交互（recv()、send()）

# 导入 socket、sys 模块
import socket
import time
import sys
# 创建 socket 对象
serversocket = socket.socket(
            socket.AF_INET, socket.SOCK_STREAM)
# 获取本地主机名
host = socket.gethostname()
print(f'{host=}')
port = 9999
# 绑定端口
serversocket.bind(('127.0.0.1', port))
# 设置最大连接数，超过后排队
serversocket.listen(5)
 
while True:
    # 建立客户端连接
    clientsocket,addr = serversocket.accept()
    print("连接地址: %s" % str(addr))
    while True:
        msg = clientsocket.recv(1024)
        print(f'recv:{msg=}')
        if msg.decode() == 'quit':
            break
        clientsocket.send(msg.upper())
serversocket.close()
time.sleep(1)

构建客户端

相比服务端，客户端比较简单：

1. 创建socket对象；
2. 通过connect()去连接服务端的端口；
3. 使用客户端的socket进行数据交互（recv()、send()）。

# 导入 socket、sys 模块
import socket
import sys
import time
 
# 创建 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口
port = 9999
# 连接服务，指定主机和端口
s.connect(('127.0.0.1', port))
# 接收小于 1024 字节的数据
s.send('hello world!'.encode())
msg = s.recv(1024)
print(msg)
 
print('-----')
s.send('I love you forever!'.encode())
msg = s.recv(1024)
print(msg)
time.sleep(1)
 
s.send('quit'.encode())
time.sleep(1)
s.close()

其他函数

socket 模块还提供多种网络相关的函数

selectors模块

简单的网络编程可以通过建立socket，然后bind()、listen，最后通过accept接收客户端的请求，但是在实际中，网络的请求是大量的、并发的，这种同步模式的处理，很难支持大并发的网络请求。

selectors模块允许高层级且高效率的 I/O 复用，它建立在 select 模块原型的基础之上。 推荐用户改用此模块，除非他们希望对所使用的 OS 层级原型进行精确控制。
它定义了一个 BaseSelector 抽象基类，以及多个实际的实现 (KqueueSelector, EpollSelector...)，它们可被用于在多个文件对象上等待 I/O 就绪通知。 在下文中，"文件对象" 是指任何具有 fileno() 方法的对象，或是一个原始文件描述符。

DefaultSelector 是一个指向当前平台上可用的最高效实现的别名：这应为大多数用户的默认选择。

类的层次结构：

BaseSelector
+-- SelectSelector
+-- PollSelector
+-- EpollSelector
+-- DevpollSelector
+-- KqueueSelector

上面的子类是对各个不同的平台的支持，如EpollSelector仅支持 Linux 2.5.44 或更高版本，KqueueSelector仅支持 BSD系统等，建议使用DefaultSelector，它会自动选择合适平台的最高效实现。

主要方法和对象

register()

BaseSelector.register(fileobj, events, data=None)

注册一个用于选择的文件对象，在其上监视 I/O 事件。

fileobj 是要监视的文件对象。 它可以是整数形式的文件描述符或者具有 fileno() 方法的对象。 events 是要监视的事件的位掩码。 data 是一个不透明对象。
这将返回一个新的 SelectorKey 实例，或在出现无效事件掩码或文件描述符时引发 ValueError，或在文件对象已被注册时引发 KeyError。

events 一个位掩码，指明哪些 I/O 事件要在给定的文件对象上执行等待。 它可以是以下模块级常量的组合:

SelectorKey对象

SelectorKey 是一个 namedtuple，用来将文件对象关联到其下层的文件描述符、选定事件掩码和附加数据等。

namedtuple：可以通过字段名来获取属性值，同样也可以通过索引和迭代获取值的元组。

属性有：

fileobj：已注册的文件对象。

fd：下层的文件描述符/socket。

events:必须在此文件对象上被等待的事件。

data:可选的关联到此文件对象的不透明数据：例如，这可被用来存储各个客户端的会话 ID。

unregister()

BaseSelector.unregister(fileobj)

注销对一个文件对象的选择，移除对它的监视。 在文件对象被关闭之前应当先将其注销。
fileobj 必须是之前已注册的文件对象。
这将返回已关联的 SelectorKey 实例，或者如果 fileobj 未注册则会引发 KeyError。 It will raise ValueError 如果 fileobj 无效（例如它没有 fileno() 方法或其 fileno() 方法返回无效值）。

modify()

BaseSelector.modify(fileobj, events, data=None)

更改已注册文件对象所监视的事件或所附带的数据。
这等价于 BaseSelector.unregister(fileobj) 加 BaseSelector.register(fileobj, events, data)，区别在于它可以被更高效地实现。
这将返回一个新的 SelectorKey 实例，或在出现无效事件掩码或文件描述符时引发 ValueError，或在文件对象未被注册时引发 KeyError。

select()

BaseSelector.select(timeout=None)

核心函数。

等待直到有已注册的文件对象就绪，或是超过时限。
如果 timeout > 0，这指定以秒数表示的最大等待时间。 如果 timeout <= 0，调用将不会阻塞，并将报告当前就绪的文件对象。 如果 timeout 为 None，调用将阻塞直到某个被监视的文件对象就绪。
这将返回由 (key, events) 元组构成的列表，每项各表示一个就绪的文件对象。
key 是对应于就绪文件对象的 SelectorKey 实例。 events 是在此文件对象上等待的事件位掩码。

close()

关闭选择器。
必须调用这个方法以确保下层资源会被释放。 选择器被关闭后将不可再使用。

get_key()

BaseSelector.get_key(fileobj)

返回关联到某个已注册文件对象的键。
此方法将返回关联到文件对象的 SelectorKey 实例，或在文件对象未注册时引发 KeyError。

get_map()

返回从文件对象到选择器键的映射。
这将返回一个将已注册文件对象映射到与其相关联的 SelectorKey 实例的 Mapping 实例。

构建服务器

import selectors
import socket
 
sel = selectors.DefaultSelector()
 
def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)
 
def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data.upper())  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()
 
sock = socket.socket()
sock.bind(('127.0.0.1', 9999))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)
 
while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)

一个测试的客户端：

# 导入 socket、sys 模块
import socket
import sys
import time
 
# 创建 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口
port = 9999
# 连接服务，指定主机和端口
s.connect(('127.0.0.1', port))
# 接收小于 1024 字节的数据
s.send('hello world!'.encode())
msg = s.recv(1024)
print(msg)
 
print('-----')
s.send('I love you forever!'.encode())
msg = s.recv(1024)
print(msg)
time.sleep(1)
 
s.send(''.encode())
time.sleep(1)
s.close()