Python socket模块

Python 提供了两个基本的 socket 模块。

  • 第一个是 Socket，它提供了标准的 BSD Sockets API。
  • 第二个是 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

下面讲的是Socket模块功能

1、Socket 类型

套接字格式：

socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字。

socket类型描述
socket.AF_UNIX只能够用于单一的Unix系统进程间通信
socket.AF_INET服务器之间网络通信
socket.AF_INET6IPv6
socket.SOCK_STREAM流式socket , for TCP
socket.SOCK_DGRAM数据报式socket , for UDP
socket.SOCK_RAW原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
socket.SOCK_SEQPACKET可靠的连续数据包服务
创建TCP Sockets=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
创建UDP Sockets=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

2、Socket 函数

注意点：

  • TCP发送数据时，已建立好TCP连接，所以不需要指定地址。UDP是面向无连接的， 每次发送要指定是发给谁。
  • 服务端与客户端不能直接发送列表，元组，字典。需要字符串化repr(data)。

服务端socket函数：

socket函数描述
s.bind(address)将套接字绑定到地址, 在AF_INET下,以元组（host,port） 的形式表示地址.
s.listen(backlog)开始监听TCP传入连接。backlog指定在拒绝连接之前，操作 系统可以挂起的最大连接数量。该值至少为1，大部分应用程 序设为5就可以了。
s.accept()接受TCP连接并返回（conn,address）,其中conn是新的套 接字对象，可以用来接收和发送数据。address是连接客户 端的地址。

客户端socket函数：

socket函数描述
s.connect(address)连接到address处的套接字。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex(adddress)功能与connect(address)相同，但是成功返回0，失败返回error的值。

公共socket函数：

socket函数描述
s.recv(bufsize[,flag])接受TCP套接字的数据。数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send(string[,flag])发送TCP数据。将string中的数据发送到连接的套接字。返回值是要 收的最大数据量。flag提供有关消发送的字节数量，该数量可能小于 息的其他信息，通常可以忽略。
s.sendall(string[,flag])完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvfrom(bufsize[.flag])接受UDP套接字的数据。与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto(string[,flag],address)发送UDP数据。将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()关闭套接字。
s.getpeername()返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])设置给定套接字选项的值。
s.settimeout(timeout)设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()返回套接字的文件描述符。
s.setblocking(flag)如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()创建一个与该套接字相关连的文件

3、socket 编程

TCP服务端：

  1. 创建套接字，绑定套接字到本地IP与端口

    # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()

  2. 开始监听连接 #s.listen()

  3. 进入循环，不断接受客户端的连接请求 #s.accept()

  4. 然后接收传来的数据，并发送给对方数据 #s.recv() , s.sendall()

  5. 传输完毕后，关闭套接字 #s.close()

TCP客户端:

  1. 创建套接字，连接远端地址

    # socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()

  2. 连接后发送数据和接收数据 # s.sendall(), s.recv()

  3. 传输完毕后，关闭套接字 #s.close()

3.1、TCP

创建 TCP 服务器

创建通用 TCP 服务器的一般伪代码：

ss = socket()       # 创建服务器套接字
ss.bind()           # 套接字与地址绑定
ss.listen()         # 监听连接
inf_loop:           # 服务器无限循环
	cs = ss.accept()        # 接受客户端连接
	comm_loop:              # 通信循环
		cs.recv()/cs.send()     # 对话（接收/发送）
	cs.close()              # 关闭客户端套接字
ss.close()          # 关闭服务器套接字#（可选）

所有套接字都是通过使用 socket.socket()函数来创建的。因为服务器需要占用一个端口并等待客户端的请求，所以它们必须绑定到一个本地地址。因为 TCP 是一种面向连接的通信系统，所以在 TCP 服务器开始操作之前，必须安装一些基础设施。特别地，TCP 服务器必须监听（传入）的连接。一旦这个安装过程完成后，服务器就可以开始它的无限循环。

调用 accept()函数之后，就开启了一个简单的（单线程）服务器，它会等待客户端的连接。默认情况下，accept()是阻塞的，这意味着执行将被暂停，直到一个连接到达。

一旦服务器接受了一个连接，就会返回（利用 accept()）一个独立的客户端套接字，用来与即将到来的消息进行交换。使用新的客户端套接字类似于将客户的电话切换给客服代表。当一个客户电话最后接进来时，主要的总机接线员会接到这个电话，并使用另一条线路将这个电话转接给合适的人来处理客户的需求。

服务器端示例代码：

HOST = ""  # HOST 变量是空白的，表示它可以使用任何可用的地址。
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpSerSock = socket(family=AF_INET, type=SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5)  # 开始TCP监听,监听5个请求

while True:
    print("waiting for connection...")
    tcpCliSock, addr = tcpSerSock.accept()
    print(f"... connected form: {addr}")
    while True:
        data = tcpCliSock.recv(BUFSIZ)
        if not data:
            break
        tcpCliSock.send(bytes('[{}]: {}'.format(time.time(), data), 'utf-8'))
    tcpCliSock.close()

创建 TCP 客户端

创建客户端比服务器要简单得多。与对 TCP 服务器的描述类似，伪代码如下：

cs = socket() # 创建客户端套接字
cs.connect() # 尝试连接服务器
comm_loop: # 通信循环
	cs.send()/cs.recv() # 对话（发送/接收）
cs.close() # 关闭客户端套接字

一旦客户端拥有了一个套接字，它就可以利用套接字的 connect()方法直接创建一个到服务器的连接。当连接建立之后，它就可以参与到与服务器的一个对话中。最后，一旦客户端完成了它的事务，它就可以关闭套接字，终止此次连接。

客户端示例代码：

HOST = 'localhost'  # or 127.0.0.1
PORT = 21567   # 端口一定要一样
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)

while True:
    data = input('> ')
    if not data:
        break
    tcpCliSock.send(bytes(data, 'utf-8'))
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8'))
tcpCliSock.close()

先运行服务器端，再运行客户端。

3.2、UDP

创建 UDP 服务器

UDP 服务器不需要 TCP 服务器那么多的设置，因为它们不是面向连接的。除了等待传入的连接之外，几乎不需要做其他工作。

ss = socket() # 创建服务器套接字
ss.bind() # 绑定服务器套接字
inf_loop: # 服务器无限循环
	cs = ss.recvfrom()/ss.sendto() # 关闭（接收/发送）
ss.close() # 关闭服务器套接字

从以上伪代码中可以看到，除了普通的创建套接字并将其绑定到本地地址（主机名/端口号对）外，并没有额外的工作。无限循环包含接收客户端消息、打上时间戳并返回消息，然后回到等待另一条消息的状态。

UDP 和 TCP 服务器之间的另一个显著差异是，因为数据报套接字是无连接的，所以就没有为了成功通信而使一个客户端连接到一个独立的套接字“转换”的操作。这些服务器仅仅接受消息并有可能回复数据。

服务器端示例代码：

HOST = ""
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpSerSock = socket(AF_INET, SOCK_DGRAM)
udpSerSock.bind(ADDR)

while True:
    print("waiting for message...")
    data, addr = udpSerSock.recvfrom(BUFSIZ)
    udpSerSock.sendto(bytes('[{}]: {}'.format(ctime(), data), 'utf-8'), addr)
    print('...received from and returned to:', addr)
udpSerSock.close()
创建 UDP 客户端

伪代码如下：

cs = socket() # 创建客户端套接字
comm_loop: # 通信循环
cs.sendto()/cs.recvfrom() # 对话（发送/接收）
cs.close() # 关闭客户端套接字

一旦创建了套接字对象，就进入了对话循环之中，在这里我们与服务器交换消息。最后，当通信结束时，就会关闭套接字。

客户端示例代码：

HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpCliSock = socket(AF_INET, SOCK_DGRAM)

while True:
    data = input("> ")
    if not data:
        break
    udpCliSock.sendto(bytes(data, 'utf-8'), ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print(data)
udpCliSock.close()

同样，先运行服务器端，再运行客户端

3.3、socket 模块属性

除了现在熟悉的 socket.socket()函数之外，socket 模块还提供了更多用于网络应用开发的属性。

数据属性：

属性名称描述
AF_UNIX、AF_INET、AF_INET6、AF_NETLINK、AF_TIPCPython 中支持的套接字地址家族
SO_STREAM、SO_DGRAM套接字类型（TCP=流，UDP=数据报）
has_ipv6指示是否支持 IPv6 的布尔标记

异常：

属性名称描述
error套接字相关错误
herror主机和地址相关错误
gaierror地址相关错误
timeout超时时间

函数：

属性名称描述
socket()以给定的地址家族、套接字类型和协议类型（可选）创建一个套接字对象
socketpair()以给定的地址家族、套接字类型和协议类型（可选）创建一对套接字对象
create_connection()常规函数，它接收一个地址（主机名，端口号）对，返回套接字对象
fromfd()以一个打开的文件描述符创建一个套接字对象
ssl()通过套接字启动一个安全套接字层连接；不执行证书验证
getaddrinfo()获取一个五元组序列形式的地址信息
getnameinfo()给定一个套接字地址，返回（主机名，端口号）二元组
getfqdn()返回完整的域名
gethostname()返回当前主机名
gethostbyname()将一个主机名映射到它的 IP 地址
gethostbyname_ex()gethostbyname()的扩展版本，它返回主机名、别名主机集合和 IP 地址列表
gethostbyaddr()将一个 IP 地址映射到 DNS 信息；返回与 gethostbyname_ex()相同的 3 元组
getprotobyname()将一个协议名（如‘tcp’）映射到一个数字
getservbyname()/getservbyport()将一个服务名映射到一个端口号，或者反过来；对于任何一个函数来说，协议名都是可选的
ntohl()/ntohs()将来自网络的整数转换为主机字节顺序
htonl()/htons()将来自主机的整数转换为网络字节顺序
inet_aton()/inet_ntoa()将 IP 地址八进制字符串转换成 32 位的包格式，或者反过来（仅用于 IPv4 地址）
inet_pton()/inet_ntop()将 IP 地址字符串转换成打包的二进制格式，或者反过来（同时适用于 IPv4 和 IPv6 地址）

4、SocketServer 模块

SocketServer 是标准库中的一个高级模块（Python 3.x 中重命名为 socketserver），它的目标是简化很多样板代码，它们是创建网络客户端和服务器所必需的代码。同时SocketServer模块也 是Python标准库中很多服务器框架的基础。

socketserver中包含了两种类，一种为服务类（server class），一种为请求处理类（request handle class）。前者提供了许多方法：像绑定，监听，运行…… （也就是建立连接的过程） 后者则专注于如何处理用户所发送的数据（也就是事务逻辑）。

这个模块中各种各样的类，如下表：

类描述
BaseServer包含核心服务器功能和 mix-in 类的钩子；仅用于推导，这样不会创建这个类的实例；可以用 TCPServer 或 UDPServer 创建类的实例
TCPServer/UDPServer基础的网络同步 TCP/UDP 服务器
UnixStreamServer/UnixDatagramServer基于文件的基础同步 TCP/UDP 服务器
ForkingMixIn/ThreadingMixIn核心派出或线程功能；只用作 mix-in 类与一个服务器类配合实现一些异步性；不能直接实例化这个类
ForkingTCPServer/ForkingUDPServerForkingMixIn 和 TCPServer/UDPServer 的组合
ThreadingTCPServer/ThreadingUDPServerThreadingMixIn 和 TCPServer/UDPServer 的组合
BaseRequestHandler包含处理服务请求的核心功能；仅仅用于推导，这样无法创建这个类的实例；可以使用 StreamRequestHandler 或 DatagramRequestHandler 创建类的实例
StreamRequestHandler/DatagramRequestHandler实现 TCP/UDP 服务器的服务处理器

事件包括消息的发送和接收。事实上，会看到类定义只包括一个用来接收客户端消息的事件处理程序。所有其他的功能都来自使用的 SocketServer 类。你会立即注意到它们的相似性，因为最后一行代码通常是一个服务器的无限循环，它等待并响应客户端的服务请求。它工作起来几乎与本章前面的基础 TCP 服务器中的无限 while 循环一样。

创建 SocketServer TCP 服务器

在原始服务器循环中，我们阻塞等待请求，当接收到请求时就对其提供服务，然后继续等待。在此处的服务器循环中，并非在服务器中创建代码，而是定义一个处理程序，这样当服务器接收到一个传入的请求时，服务器就可以调用你的函数。

一般情况下，所有的服务，都是先建立连接，也就是建立一个服务类的实例，然后开始处理用户请求，也就是建立一个请求处理类的实例。

from socketserver import TCPServer as TCP
from socketserver import StreamRequestHandler as SRH
from time import ctime

HOST = ""
PORT = 21567
ADDR = (HOST, PORT)

class MyRequestHandler(SRH):
    def handle(self):
        print("...connected from:", self.client_address)
        self.wfile.write(bytes('[{}]: {}'.format(ctime(), self.rfile.readline())))

tcpServ = TCP(ADDR, MyRequestHandler)
print('waiting for connection...')
tcpServ.serve_forever()

当接收到一个来自客户端的消息时，MyRequestHandler就会调用 handle()方法。而 StreamRequestHandler类将输入和输出套接字看作类似文件的对象，因此我们将使用 readline()来获取客户端消息，并利用 write()将字符串发送回客户端。

因此，在客户端和服务器代码中，需要额外的回车和换行符。实际上，在代码中你不会看到它，因为我们只是重用那些来自客户端的符号。除了这些细微的差别之外，它看起来就像以前的服务器。

最后的代码利用给定的主机信息和请求处理类创建了 TCP 服务器。然后，无限循环地等待并服务于客户端请求。
.
.
.
----------------------------------END----------------------------------

# python
Logo
华为云开发者联盟

为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。

更多推荐

cover

从原始边列表到邻接矩阵Python实现图数据处理的完整指南

avatar 华为云开发者联盟
cover

解锁HDC 2024之旅：从购票到报名，全程攻略

avatar 华为云开发者联盟
cover

华为云云原生FinOps解决方案，释放云原生最大价值

avatar 华为云开发者联盟