Python socket模块

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

• 第一个是 Socket&＃xff0c;它提供了标准的 BSD Sockets API。

• 第二个是 SocketServer&＃xff0c; 它提供了服务器中心类&＃xff0c;可以简化网络服务器的开发。

下面讲的是Socket模块功能

1、Socket 类型

套接字格式&＃xff1a;

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

2、Socket 函数

注意点&＃xff1a;

• TCP发送数据时&＃xff0c;已建立好TCP连接&＃xff0c;所以不需要指定地址。UDP是面向无连接的&＃xff0c; 每次发送要指定是发给谁。

• 服务端与客户端不能直接发送列表&＃xff0c;元组&＃xff0c;字典。需要字符串化repr(data)。

服务端socket函数&＃xff1a;

客户端socket函数&＃xff1a;

公共socket函数&＃xff1a;

3、socket 编程

TCP服务端&＃xff1a;

1. 创建套接字&＃xff0c;绑定套接字到本地IP与端口

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

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

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

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

5. 传输完毕后&＃xff0c;关闭套接字 #s.close()

TCP客户端:

1. 创建套接字&＃xff0c;连接远端地址

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

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

3. 传输完毕后&＃xff0c;关闭套接字 #s.close()

3.1、TCP

创建 TCP 服务器

创建通用 TCP 服务器的一般伪代码&＃xff1a;

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

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

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

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

服务器端示例代码&＃xff1a;

HOST &＃61; "" # HOST 变量是空白的&＃xff0c;表示它可以使用任何可用的地址。
PORT &＃61; 21567
BUFSIZ &＃61; 1024
ADDR &＃61; (HOST, PORT)
tcpSerSock &＃61; socket(family&＃61;AF_INET, type&＃61;SOCK_STREAM)
tcpSerSock.bind(ADDR)
tcpSerSock.listen(5) # 开始TCP监听,监听5个请求
while True:
print("waiting for connection...")
tcpCliSock, addr &＃61; tcpSerSock.accept()
print(f"... connected form: {addr}")
while True:
data &＃61; tcpCliSock.recv(BUFSIZ)
if not data:
break
tcpCliSock.send(bytes(&＃39;[{}]: {}&＃39;.format(time.time(), data), &＃39;utf-8&＃39;))
tcpCliSock.close()

创建 TCP 客户端

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

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

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

客户端示例代码&＃xff1a;

HOST &＃61; &＃39;localhost&＃39; # or 127.0.0.1
PORT &＃61; 21567 # 端口一定要一样
BUFSIZ &＃61; 1024
ADDR &＃61; (HOST, PORT)
tcpCliSock &＃61; socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)
while True:
data &＃61; input(&＃39;> &＃39;)
if not data:
break
tcpCliSock.send(bytes(data, &＃39;utf-8&＃39;))
data &＃61; tcpCliSock.recv(BUFSIZ)
if not data:
break
print(data.decode(&＃39;utf-8&＃39;))
tcpCliSock.close()

先运行服务器端&＃xff0c;再运行客户端。

3.2、UDP

创建 UDP 服务器

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

ss &＃61; socket() # 创建服务器套接字
ss.bind() # 绑定服务器套接字
inf_loop: # 服务器无限循环
cs &＃61; ss.recvfrom()/ss.sendto() # 关闭&＃xff08;接收/发送&＃xff09;
ss.close() # 关闭服务器套接字

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

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

服务器端示例代码&＃xff1a;

HOST &＃61; ""
PORT &＃61; 21567
BUFSIZ &＃61; 1024
ADDR &＃61; (HOST, PORT)
udpSerSock &＃61; socket(AF_INET, SOCK_DGRAM)
udpSerSock.bind(ADDR)
while True:
print("waiting for message...")
data, addr &＃61; udpSerSock.recvfrom(BUFSIZ)
udpSerSock.sendto(bytes(&＃39;[{}]: {}&＃39;.format(ctime(), data), &＃39;utf-8&＃39;), addr)
print(&＃39;...received from and returned to:&＃39;, addr)
udpSerSock.close()

创建 UDP 客户端

伪代码如下&＃xff1a;

cs &＃61; socket() # 创建客户端套接字
comm_loop: # 通信循环
cs.sendto()/cs.recvfrom() # 对话&＃xff08;发送/接收&＃xff09;
cs.close() # 关闭客户端套接字

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

客户端示例代码&＃xff1a;

HOST &＃61; &＃39;localhost&＃39;
PORT &＃61; 21567
BUFSIZ &＃61; 1024
ADDR &＃61; (HOST, PORT)
udpCliSock &＃61; socket(AF_INET, SOCK_DGRAM)
while True:
data &＃61; input("> ")
if not data:
break
udpCliSock.sendto(bytes(data, &＃39;utf-8&＃39;), ADDR)
data, ADDR &＃61; udpCliSock.recvfrom(BUFSIZ)
if not data:
break
print(data)
udpCliSock.close()

同样&＃xff0c;先运行服务器端&＃xff0c;再运行客户端

3.3、socket 模块属性

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

数据属性&＃xff1a;

异常&＃xff1a;

函数&＃xff1a;

4、SocketServer 模块

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

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

这个模块中各种各样的类&＃xff0c;如下表&＃xff1a;

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

创建 SocketServer TCP 服务器

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

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

from socketserver import TCPServer as TCP
from socketserver import StreamRequestHandler as SRH
from time import ctime
HOST &＃61; ""
PORT &＃61; 21567
ADDR &＃61; (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print("...connected from:", self.client_address)
self.wfile.write(bytes(&＃39;[{}]: {}&＃39;.format(ctime(), self.rfile.readline())))
tcpServ &＃61; TCP(ADDR, MyRequestHandler)
print(&＃39;waiting for connection...&＃39;)
tcpServ.serve_forever()

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

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

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