原文: http://zetcode.com/python/socket/

Python 套接字教程展示了如何使用套接字进行 Python 网络编程。 套接字编程是低级的。 本教程的目的是介绍包括这些低级详细信息的网络编程。 有更高级的 Python API,例如 Twisted,可能更适合。

在编程中,套接字是网络上运行的两个程序之间通信的端点。 套接字用于在客户端程序和服务器程序之间创建连接。

Python 的socket模块提供了与 Berkeley 套接字 API 的接口。

注意:在网络中,“套接字”一词具有不同的含义。 它用于 IP 地址和端口号的组合。

网络协议

TCP/IP 是设备用于在互联网和大多数本地网络上进行通信的一组协议。 TCP 更可靠,具有大量错误检查并需要更多资源。 HTTP,SMTP 或 FTP 等服务使用它。 UDP 的可靠性要差得多,错误检查的能力也有限,所需资源也更少。 VoIP 等服务使用它。

socket.SOCK_STREAM用于为 TCP 创建套接字,而socket.SOCK_DGRAM为 UDP 创建套接字。

地址族

创建套接字时,必须指定其地址族。 然后,我们只能在套接字中使用该类型的地址。

  • AF_UNIXAF_LOCAL - 本地通讯
  • AF_INET - IPv4 互联网协议
  • AF_INET6 - IPv6 互联网协议
  • AF_IPX - IPX-Novell 协议
  • AF_BLUETOOTH - 无线蓝牙协议
  • AF_PACKET - 底层数据包接口

对于AF_INET地址族,指定了一对(主机,端口)。 host是一个字符串,表示互联网域表示法中的主机名(如example.com)或 IPv4 地址(如93.184.216.34),并且port是整数。

Python 获取 IP 地址

使用gethostbyname(),我们获得主机的 IP 地址。

get_ip.py

  1. #!/usr/bin/env python
  2. import socket
  3. ip = socket.gethostbyname('example.com')
  4. print(ip)

该示例打印example.com的 IP 地址。

  1. $ ./get_ip.py
  2. 93.184.216.34

这是输出。

Python UDP 套接字示例

UDP 是一种通信协议,它通过网络传输独立的数据包,不保证到达且也不保证传递顺序。 使用 UDP 的一项服务是每日报价(QOTD)。

qotd_client.py

  1. #!/usr/bin/env python
  2. import socket
  3. with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
  4. message = b''
  5. addr = ("djxmmx.net", 17)
  6. s.sendto(message, addr)
  7. data, address = s.recvfrom(1024)
  8. print(data.decode())

该示例创建一个连接到 QOTD 服务的客户端程序。

  1. import socket

我们导入socket模块。

  1. with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:

创建了用于 IPv4 的数据报套接字。

  1. message = b''

我们发送空消息; QOTD 服务通过向套接字发送任意数据来工作; 它只是用引号引起来。 为了通过 TCP/UDP 进行通信,我们使用二进制字符串。

  1. addr = ("djxmmx.net", 17)

我们提供地址和端口。

  1. s.sendto(message, addr)

我们使用sendto()方法发送数据。

  1. data, address = s.recvfrom(1024)

UDP 套接字使用recvfrom()接收数据。 它的参数是缓冲区大小。 返回值是一对(数据,地址),其中数据是代表接收到的数据的字节字符串,而地址是发送数据的套接字的地址。

  1. print(data.decode())

我们将解码后的数据打印到终端。

  1. $ ./qotd_client.py
  2. "Oh the nerves, the nerves; the mysteries of this machine called man!
  3. Oh the little that unhinges it, poor creatures that we are!"
  4. Charles Dickens (1812-70)

这是一个示例输出。

Python TCP 套接字示例

是提供当前时间的服务器。 客户端无需任何命令即可直接连接到服务器,服务器以当前时间作为响应。

注意:时间服务器来来往往,因此我们可能需要在 https://www.ntppool.org/en/ 上找到可用的服务器。

time_client.py

  1. #!/usr/bin/env python
  2. import socket
  3. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
  4. host = "time.nist.gov"
  5. port = 13
  6. s.connect((host, port))
  7. s.sendall(b'')
  8. print(str(s.recv(4096), 'utf-8'))

该示例通过连接到时间服务器的 TCP 套接字来确定当前时间。

  1. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:

创建用于 IPv4 的 TCP 套接字。

  1. host = "time.nist.gov"
  2. port = 13

这是工作时间服务器的主机名和端口号。

  1. s.connect((host, port))

我们使用connect()连接到远程套接字。

  1. s.sendall(b'')

sendall()方法将数据发送到套接字。 套接字必须连接到远程套接字。 它继续从字节发送数据,直到发送完所有数据或发生错误为止。

  1. print(str(s.recv(4096), 'utf-8'))

我们打印接收到的数据。 recv()方法从套接字接收最多buffersize个字节。 当没有数据可用时,它将阻塞,直到至少一个字节可用或直到远端关闭为止。 当远端关闭并读取所有数据时,它将返回一个空字节字符串。

Python 套接字 HEAD 请求

HEAD 请求是没有消息正文的 GET 请求。 请求/响应的标头包含元数据,例如 HTTP 协议版本或内容类型。

head_request.py

  1. #!/usr/bin/env python
  2. import socket
  3. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
  4. s.connect(("webcode.me" , 80))
  5. s.sendall(b"HEAD / HTTP/1.1\r\nHost: webcode.me\r\nAccept: text/html\r\n\r\n")
  6. print(str(s.recv(1024), 'utf-8'))

在示例中,我们向webcode.me发送 HEAD 请求。

  1. s.sendall(b"HEAD / HTTP/1.1\r\nHost: webcode.me\r\nAccept: text/html\r\n\r\n")

HEAD命令发出头请求,后跟资源 URL 和 HTTP 协议版本。 请注意,\r\n是通信过程中必不可少的部分。 在 RFC 7231 文档中描述了详细信息。

  1. $ head_request.py
  2. HTTP/1.1 200 OK
  3. Server: nginx/1.6.2
  4. Date: Sun, 08 Sep 2019 11:23:25 GMT
  5. Content-Type: text/html
  6. Content-Length: 348
  7. Last-Modified: Sat, 20 Jul 2019 11:49:25 GMT
  8. Connection: keep-alive
  9. ETag: "5d32ffc5-15c"
  10. Accept-Ranges: bytes

这是输出。

Python 套接字 GET 请求

HTTP GET 方法请求指定资源的表示形式。 使用 GET 的请求应仅检索数据。

get_request.py

  1. #!/usr/bin/env python
  2. import socket
  3. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
  4. s.connect(("webcode.me" , 80))
  5. s.sendall(b"GET / HTTP/1.1\r\nHost: webcode.me\r\nAccept: text/html\r\nConnection: close\r\n\r\n")
  6. while True:
  7. data = s.recv(1024)
  8. if not data:
  9. break
  10. print(data.decode())

该示例使用 GET 请求读取webcode.me的主页。

  1. s.sendall(b"GET / HTTP/1.1\r\nHost: webcode.me\r\nAccept: text/html\r\nConnection: close\r\n\r\n")

对于 HTTP 1.1 协议,默认情况下,连接可以是持久的。 这就是为什么我们发送Connection: close标头的原因。

  1. while True:
  2. data = s.recv(1024)
  3. if not data:
  4. break
  5. print(data.decode())

我们使用while循环来处理接收到的数据。 如果没有错误发生,则recv()返回接收到的字节。 如果连接已正常关闭,则返回值为空字节字符串。 recv()是一种阻止方法,直到完成它,或者达到超时或发生另一个异常为止。

  1. $ ./get_request.py
  2. HTTP/1.1 200 OK
  3. Server: nginx/1.6.2
  4. Date: Sun, 08 Sep 2019 11:39:34 GMT
  5. Content-Type: text/html
  6. Content-Length: 348
  7. Last-Modified: Sat, 20 Jul 2019 11:49:25 GMT
  8. Connection: keep-alive
  9. ETag: "5d32ffc5-15c"
  10. Access-Control-Allow-Origin: *
  11. Accept-Ranges: bytes
  12. <!DOCTYPE html>
  13. <html lang="en">
  14. <head>
  15. <meta charset="UTF-8">
  16. <meta name="viewport" content="width=device-width, initial-scale=1.0">
  17. <title>My html page</title>
  18. </head>
  19. <body>
  20. <p>
  21. Today is a beautiful day. We go swimming and fishing.
  22. </p>
  23. <p>
  24. Hello there. How are you?
  25. </p>
  26. </body>
  27. </html>

这是输出。

回显客户端服务器示例

回显服务器将来自客户端的消息发送回去。 这是用于测试和学习的经典示例。

echo_server.py

  1. #!/usr/bin/env python
  2. import socket
  3. import time
  4. with socket.socket() as s:
  5. host = 'localhost'
  6. port = 8001
  7. s.bind((host, port))
  8. print(f'socket binded to {port}')
  9. s.listen()
  10. con, addr = s.accept()
  11. with con:
  12. while True:
  13. data = con.recv(1024)
  14. if not data:
  15. break
  16. con.sendall(data)

回显服务器将客户端消息发送回客户端。

  1. host = 'localhost'
  2. port = 8001

服务器在端口 8001 上的 localhost 上运行。

  1. s.bind((host, port))

bind()方法建立通信端点。 它将套接字绑定到指定的地址。 套接字必须尚未绑定。 (地址的格式取决于地址系列。)

  1. s.listen()

listen()方法使服务器可以接受连接。 服务器现在可以监听套接字上的连接。 listen()具有backlog参数。 它指定系统在拒绝新连接之前允许的不可接受的连接数。 自 Python 3.5 起,此参数是可选的。 如果未指定,则选择默认的积压值。

  1. con, addr = s.accept()

使用accept(),服务器接受连接。 它阻止并等待传入连接。 套接字必须绑定到一个地址并监听连接。 返回值是一对(con, addr),其中con是可用于在连接上发送和接收数据的新套接字对象,而addr是绑定到连接另一端上的套接字的地址。

请注意,accept()创建了一个新的套接字,用于与客户端进行通信,该套接字与监听套接字不同。

echo_client.py

  1. #!/usr/bin/env python
  2. import socket
  3. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
  4. host = "localhost"
  5. port = 8001
  6. s.connect((host, port))
  7. s.sendall(b'hello there')
  8. print(str(s.recv(4096), 'utf-8'))

客户端将消息发送到回显服务器。

异步服务器示例

为了提高服务器的性能,我们可以使用asyncio模块。

async_server.py

  1. #!/usr/bin/env python
  2. # from threading import current_thread
  3. import asyncio
  4. async def handle_client(reader, writer):
  5. data = (await reader.read(1024))
  6. writer.write(data)
  7. writer.close()
  8. loop = asyncio.get_event_loop()
  9. loop.create_task(asyncio.start_server(handle_client, 'localhost', 8001))
  10. loop.run_forever()

现在,我们可以测试阻塞服务器和非阻塞服务器的性能。

  1. $ ab -c 50 -n 1000 http://localhost:8001/

例如,我们可以使用 Apache 基准测试工具测试性能。 在我们的例子中,命令发送 1000 个请求,一次发送 50 个。

在本教程中,我们展示了如何在 Python 中使用套接字创建简单的网络程序。

您可能也对以下相关教程感兴趣: Python 字符串Python Jinja 教程Python 教程,或列出所有 Python 教程