socket — 低级网络接口

源代码： :source:`Lib/socket.py`

该模块提供对 BSD socket 接口的访问。它适用于所有现代 Unix 系统、Windows、MacOS 以及可能的其他平台。

笔记

某些行为可能取决于平台，因为调用的是操作系统套接字 API。

Python 接口是将套接字的 Unix 系统调用和库接口直接转译为 Python 的面向对象风格：socket() 函数返回一个 socket 对象 ，其方法实现了各种套接字系统调用. 参数类型比 C 接口中的级别更高：与 Python 文件上的 read() 和 write() 操作一样，接收操作的缓冲区分配是自动的，并且缓冲区长度在发送操作中是隐式的。

也可以看看

模块 socketserver: 简化编写网络服务器的类。
模块 ssl: 套接字对象的 TLS/SSL 包装器。

插座系列

根据系统和构建选项，此模块支持各种套接字系列。

根据创建套接字对象时指定的地址族自动选择特定套接字对象所需的地址格式。套接字地址表示如下：

绑定到文件系统节点的 AF_UNIX 套接字的地址表示为字符串，使用文件系统编码和 'surrogateescape' 错误处理程序（请参阅 PEP 383）。 Linux 抽象命名空间中的地址作为 bytes-like object 返回，并带有初始空字节；请注意，此命名空间中的套接字可以与普通文件系统套接字通信，因此打算在 Linux 上运行的程序可能需要处理这两种类型的地址。将字符串或字节类对象作为参数传递时，可以将其用于任一类型的地址。

3.3 版更改：以前，假定 AF_UNIX 套接字路径使用 UTF-8 编码。

3.5 版更改：现在接受可写字节类对象。

一对 (host, port) 用于 AF_INET 地址族，其中 host 是一个字符串，表示互联网域符号中的主机名，如 'daring.cwi.nl' 或IPv4 地址如 '100.50.200.5' 和 port 是一个整数。
- 对于 IPv4 地址，接受两种特殊形式而不是主机地址：代表 INADDR_ANY，用于绑定所有接口，字符串 '<broadcast>' 代表 INADDR_BROADCAST。此行为与 IPv6 不兼容，因此，如果您打算在 Python 程序中支持 IPv6，则可能需要避免这些行为。
对于 AF_INET6 地址族，使用四元组 (host, port, flowinfo, scope_id)，其中 flowinfo 和 scope_id 代表 sin6_flowinfo 和 [ C 中 struct sockaddr_in6 中的 X144X] 成员。对于 socket 模块方法，为了向后兼容，可以省略 flowinfo 和 scope_id。但是请注意，省略 scope_id 可能会导致操作范围内的 IPv6 地址出现问题。

在 3.7 版更改：对于多播地址（具有 scope_id 有意义）address 可能不包含 %scope_id（或 zone id）部分。此信息是多余的，可以安全地省略（推荐）。
AF_NETLINK 插槽表示为 (pid, groups) 对。
使用 AF_TIPC 地址系列，仅 Linux 支持 TIPC。 TIPC 是一种开放的、基于非 IP 的网络协议，设计用于集群计算机环境。地址由元组表示，字段取决于地址类型。一般元组形式为 (addr_type, v1, v2, v3 [, scope])，其中：
- addr_type 是 TIPC_ADDR_NAMESEQ、TIPC_ADDR_NAME 或 TIPC_ADDR_ID 之一。
- scope 是 TIPC_ZONE_SCOPE、TIPC_CLUSTER_SCOPE 和 TIPC_NODE_SCOPE 之一。
- 如果 addr_type 是 TIPC_ADDR_NAME，那么 v1 是服务器类型，v2 是端口标识符，而 v3 应该为 0。
  
  如果 addr_type 是 TIPC_ADDR_NAMESEQ，则 v1 是服务器类型，v2 是较低的端口号，而 v3是上面的端口号。
  
  如果addr_type为TIPC_ADDR_ID，则v1为节点，v2为参考，并设置v3到 0。
元组 (interface, ) 用于 AF_CAN 地址族，其中 interface 是表示网络接口名称的字符串，如 'can0'。网络接口名称 可用于从该系列的所有网络接口接收数据包。
- CAN_ISOTP 协议需要一个元组 (interface, rx_addr, tx_addr)，其中两个附加参数都是表示 CAN 标识符（标准或扩展）的无符号长整数。
- CAN_J1939 协议需要一个元组 (interface, name, pgn, addr)，其中附加参数是表示 ECU 名称的 64 位无符号整数、表示参数组编号 (PGN) 的 32 位无符号整数和一个 8-表示地址的位整数。
字符串或元组 (id, unit) 用于 PF_SYSTEM 系列的 SYSPROTO_CONTROL 协议。该字符串是使用动态分配 ID 的内核控件的名称。如果内核控件的 ID 和单元号已知或使用注册 ID，则可以使用元组。

3.3 版中的新功能。
AF_BLUETOOTH 支持以下协议和地址格式：
- BTPROTO_L2CAP 接受 (bdaddr, psm) 其中 bdaddr 是作为字符串的蓝牙地址，而 psm 是一个整数。
- BTPROTO_RFCOMM 接受 (bdaddr, channel) 其中 bdaddr 是作为字符串的蓝牙地址，而 channel 是一个整数。
- BTPROTO_HCI 接受 (device_id,) 其中 device_id 是一个整数或带有接口蓝牙地址的字符串。（这取决于您的操作系统；NetBSD 和 DragonFlyBSD 需要一个蓝牙地址，而其他一切都需要一个整数。）
  
  3.2 版更改：添加了 NetBSD 和 DragonFlyBSD 支持。
- BTPROTO_SCO 接受 bdaddr，其中 bdaddr 是一个 bytes 对象，包含字符串格式的蓝牙地址。（前任。 b'12:23:34:45:56:67') FreeBSD 不支持此协议。
AF_ALG 是一个基于 Linux 套接字的内核加密接口。一个算法套接字配置了一个二到四个元素 (type, name [, feat [, mask]]) 的元组，其中：
- type 是字符串形式的算法类型，例如 aead、hash、skcipher 或 rng。
- name 为字符串形式的算法名称和操作方式，例如 sha256、hmac(sha256)、cbc(aes) 或 drbg_nopr_ctr_aes256。
- feat 和 mask 是无符号 32 位整数。
3.6 版中的新功能。
AF_VSOCK 允许虚拟机与其主机之间的通信。套接字表示为 (CID, port) 元组，其中上下文 ID 或 CID 和端口是整数。

3.7 版中的新功能。
AF_PACKET 是直接连接到网络设备的低级接口。数据包由元组 (ifname, proto[, pkttype[, hatype[, addr]]]) 表示，其中：
- ifname - 指定设备名称的字符串。
- proto - 指定以太网协议编号的网络字节顺序整数。
- pkttype - 指定数据包类型的可选整数：
  - PACKET_HOST（默认值）- 寻址到本地主机的数据包。
  - PACKET_BROADCAST - 物理层广播数据包。
  - PACKET_MULTIHOST - 发送到物理层多播地址的数据包。
  - PACKET_OTHERHOST - 发送到某个其他主机的数据包，该数据包已被处于混杂模式的设备驱动程序捕获。
  - PACKET_OUTGOING - 来自本地主机的数据包循环回数据包套接字。
- hatype - 指定 ARP 硬件地址类型的可选整数。
- addr - 指定硬件物理地址的可选字节类对象，其解释取决于设备。
AF_QIPCRTR 是一个仅基于 Linux 的套接字接口，用于与在 Qualcomm 平台中的协处理器上运行的服务进行通信。地址族表示为 (node, port) 元组，其中 node 和 port 是非负整数。

3.8 版中的新功能。
IPPROTO_UDPLITE 是 UDP 的一种变体，它允许您指定校验和覆盖数据包的哪个部分。它添加了两个可以更改的套接字选项。 self.setsockopt(IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV, length) 将更改校验和覆盖的传出数据包的哪些部分，而 self.setsockopt(IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV, length) 将过滤掉覆盖太少数据的数据包。在这两种情况下，length 都应该在 range(8, 2**16, 8) 中。

对于 IPv4，应该使用 socket(AF_INET, SOCK_DGRAM, IPPROTO_UDPLITE) 或对于 IPv6 使用 socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDPLITE) 构造这样的套接字。

3.9 版中的新功能。

如果在 IPv4/v6 套接字地址的 host 部分使用主机名，程序可能会显示不确定性行为，因为 Python 使用从 DNS 解析返回的第一个地址。套接字地址将以不同的方式解析为实际的 IPv4/v6 地址，具体取决于 DNS 解析和/或主机配置的结果。对于确定性行为，请在 host 部分使用数字地址。

所有错误都会引发异常。可以引发无效参数类型和内存不足情况的正常异常；从 Python 3.3 开始，与套接字或地址语义相关的错误引发 OSError 或其子类之一（它们曾经引发 socket.error）。

通过 setblocking() 支持非阻塞模式。通过 settimeout() 支持基于超时的概括。

模块内容

模块 socket 导出以下元素。

例外

exception socket.error: OSError 的已弃用别名。

3.3 版本更改：继 PEP 3151 之后，该类被设为 OSError 的别名。

exception socket.herror: OSError的一个子类，这个异常是针对地址相关的错误引发的，即对于在 POSIX C API 中使用 h_errno 的函数，包括 gethostbyname_ex() 和 gethostbyaddr()。伴随的值是一对 (h_errno, string) 表示库调用返回的错误。 h_errno 是一个数值，而 string 表示 h_errno 的描述，由 hstrerror() C 函数返回。

3.3 版更改：此类成为 OSError 的子类。

exception socket.gaierror: OSError 的子类，由 getaddrinfo() 和 getnameinfo() 为地址相关错误引发此异常。伴随的值是一对 (error, string) 表示库调用返回的错误。 string 表示 error 的描述，由 gai_strerror() C 函数返回。数字 error 值将匹配此模块中定义的 EAI_* 常量之一。

3.3 版更改：此类成为 OSError 的子类。

exception socket.timeout: OSError 的一个子类，当通过预先调用 settimeout()（或通过 setdefaulttimeout( ))。伴随的值是一个字符串，其值当前总是“超时”。

3.3 版更改：此类成为 OSError 的子类。

常数

AF_* 和 SOCK_* 常量现在是 AddressFamily 和 SocketKind IntEnum 集合。

3.4 版中的新功能。

socket.AF_UNIX

socket.AF_INET
socket.AF_INET6

这些常量代表地址（和协议）族，用于 socket() 的第一个参数。如果未定义 AF_UNIX 常量，则不支持此协议。取决于系统，可能有更多常量可用。

socket.SOCK_STREAM

socket.SOCK_DGRAM
socket.SOCK_RAW
socket.SOCK_RDM
socket.SOCK_SEQPACKET

这些常量代表套接字类型，用于 socket() 的第二个参数。取决于系统，可能有更多常量可用。（只有 SOCK_STREAM 和 SOCK_DGRAM 似乎普遍有用。）

socket.SOCK_CLOEXEC socket.SOCK_NONBLOCK: 如果定义了这两个常量，则可以与套接字类型结合使用，并允许您以原子方式设置一些标志（从而避免可能的竞争条件和单独调用的需要）。

也可以看看

安全文件描述符处理更详尽的解释。

3.2 版中的新功能。

SO_* socket.SOMAXCONN MSG_* SOL_* SCM_* IPPROTO_* IPPORT_* INADDR_* IP_* IPV6_* EAI_* AI_* NI_* TCP_*: 这些形式的许多常量，记录在关于套接字和/或 IP 协议的 Unix 文档中，也在套接字模块中定义。它们通常用于套接字对象的 setsockopt() 和 getsockopt() 方法的参数中。大多数情况下，只定义那些在 Unix 头文件中定义的符号；对于一些符号，提供了默认值。

3.6 版本变更：SO_DOMAIN、SO_PROTOCOL、SO_PEERSEC、SO_PASSSEC、TCP_USER_TIMEOUT、[ X92X] 被添加。

在 3.6.5 版更改：在 Windows 上，如果运行时 Windows 支持，则会出现 TCP_FASTOPEN、TCP_KEEPCNT。

3.7 版更改：添加了 TCP_NOTSENT_LOWAT。

在 Windows 上，如果运行时 Windows 支持，则会出现 TCP_KEEPIDLE、TCP_KEEPINTVL。

socket.AF_CAN socket.PF_CAN SOL_CAN_* CAN_*: Linux 文档中记录的这些形式的许多常量也在 socket 模块中定义。

3.3 版中的新功能。

socket.CAN_BCM CAN_BCM_*: CAN_BCM 属于 CAN 协议族，是广播管理器 (BCM) 协议。 Linux 文档中记录的广播管理器常量也在套接字模块中定义。

笔记

CAN_BCM_CAN_FD_FRAME 标志仅在 Linux >= 4.8 上可用。

3.4 版中的新功能。

socket.CAN_RAW_FD_FRAMES

在 CAN_RAW 套接字中启用 CAN FD 支持。默认情况下禁用此功能。这允许您的应用程序发送 CAN 和 CAN FD 帧；但是，从套接字读取时，您必须同时接受 CAN 和 CAN FD 帧。

该常量记录在 Linux 文档中。

3.5 版中的新功能。

socket.CAN_RAW_JOIN_FILTERS

加入应用的 CAN 过滤器，以便仅将匹配所有给定 CAN 过滤器的 CAN 帧传递到用户空间。

该常量记录在 Linux 文档中。

3.9 版中的新功能。

socket.CAN_ISOTP: CAN_ISOTP 属于 CAN 协议族，是 ISO-TP (ISO 15765-2) 协议。 ISO-TP 常量，记录在 Linux 文档中。

3.7 版中的新功能。

socket.CAN_J1939: CAN_J1939 属于 CAN 协议族，是 SAE J1939 协议。 J1939 常量，记录在 Linux 文档中。

3.9 版中的新功能。

socket.AF_PACKET

socket.PF_PACKET
PACKET_*

Linux 文档中记录的这些形式的许多常量也在 socket 模块中定义。

socket.AF_RDS socket.PF_RDS socket.SOL_RDS RDS_*: Linux 文档中记录的这些形式的许多常量也在 socket 模块中定义。

3.3 版中的新功能。

socket.SIO_RCVALL socket.SIO_KEEPALIVE_VALS socket.SIO_LOOPBACK_FAST_PATH RCVALL_*: Windows 的 WSAIoctl() 常量。这些常量用作套接字对象的 ioctl() 方法的参数。

3.6 版更改：添加了 SIO_LOOPBACK_FAST_PATH。

TIPC_*: TIPC 相关常量，匹配 C 套接字 API 导出的常量。有关详细信息，请参阅 TIPC 文档。

socket.AF_ALG socket.SOL_ALG ALG_*: Linux 内核加密的常量。

3.6 版中的新功能。

socket.AF_VSOCK socket.IOCTL_VM_SOCKETS_GET_LOCAL_CID VMADDR* SO_VM*: Linux 主机/来宾通信的常量。

3.7 版中的新功能。

socket.AF_LINK: 3.4 版中的新功能。

socket.has_ipv6: 此常量包含一个布尔值，指示此平台是否支持 IPv6。

socket.BDADDR_ANY

socket.BDADDR_LOCAL

这些是包含具有特殊含义的蓝牙地址的字符串常量。例如，BDADDR_ANY 可用于在使用 BTPROTO_RFCOMM 指定绑定套接字时指示任何地址。

socket.HCI_FILTER

socket.HCI_TIME_STAMP
socket.HCI_DATA_DIR

与 BTPROTO_HCI 一起使用。 HCI_FILTER 不适用于 NetBSD 或 DragonFlyBSD。 HCI_TIME_STAMP 和 HCI_DATA_DIR 不适用于 FreeBSD、NetBSD 或 DragonFlyBSD。

socket.AF_QIPCRTR: Qualcomm 的 IPC 路由器协议的常量，用于与提供远程处理器的服务进行通信。

功能

创建套接字

下面的函数都创建了socket对象。

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

使用给定的地址族、套接字类型和协议号创建一个新套接字。地址族应为 AF_INET（默认）、AF_INET6、AF_UNIX、AF_CAN、AF_PACKET、 AF_RDS。套接字类型应为 SOCK_STREAM（默认值）、SOCK_DGRAM、SOCK_RAW 或其他 SOCK_ 常量之一。协议编号通常为零且可以省略，或者在地址族为 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() 关闭分离的套接字。

新创建的套接字是不可继承的。

3.3 版本变化： AF_CAN 系列已添加。添加了 AF_RDS 系列。

3.4 版本变化：增加了 CAN_BCM 协议。

3.4 版更改：返回的套接字现在不可继承。

3.7 版本变化：增加了 CAN_ISOTP 协议。

3.7 版更改：当 SOCK_NONBLOCK 或 SOCK_CLOEXEC 位标志应用于 type 时，它们被清除，而 socket.type 不会反映它们。它们仍然传递给底层系统 socket() 调用。所以，

sock = socket.socket(
    socket.AF_INET,
    socket.SOCK_STREAM | socket.SOCK_NONBLOCK)

仍将在支持 SOCK_NONBLOCK 的操作系统上创建非阻塞套接字，但 sock.type 将设置为 socket.SOCK_STREAM。

3.9 版本变化：增加了 CAN_J1939 协议。

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

使用给定的地址族、套接字类型和协议号构建一对连接的套接字对象。地址族、套接字类型和协议编号与上述socket() 功能相同。如果在平台上定义，则默认系列为 AF_UNIX；否则，默认值为 AF_INET。

新创建的套接字是不可继承的。

3.2 版更改：返回的套接字对象现在支持整个套接字 API，而不是一个子集。

3.4 版更改：返回的套接字现在不可继承。

在 3.5 版更改：添加了 Windows 支持。

socket.create_connection(address[, timeout[, source_address]])

连接到侦听 Internet address（一个 2 元组 (host, port)）的 TCP 服务，并返回套接字对象。这是一个比 socket.connect() 更高级别的函数：如果 host 是一个非数字主机名，它将尝试为 AF_INET 解析它和AF_INET6，然后依次尝试连接所有可能的地址，直到连接成功。这使得编写兼容 IPv4 和 IPv6 的客户端变得容易。

传递可选的 timeout 参数将在尝试连接之前设置套接字实例的超时时间。如果未提供 timeout，则使用 getdefaulttimeout() 返回的全局默认超时设置。

如果提供，source_address 必须是一个 2 元组 (host, port) 以便套接字在连接之前绑定到其源地址。如果主机或端口分别为 或 0，则将使用操作系统默认行为。

3.2 版更改：添加了 source_address。

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

创建绑定到 address（一个 2 元组 (host, port)）的 TCP 套接字并返回套接字对象的便捷函数。

family 应该是 AF_INET 或 AF_INET6。 backlog 是传递给 socket.listen() 的队列大小；当 0 选择默认合理值时。 reuse_port 指示是否设置 SO_REUSEPORT 套接字选项。

如果 dualstack_ipv6 为 true 并且平台支持它，则套接字将能够接受 IPv4 和 IPv6 连接，否则将引发 ValueError。大多数 POSIX 平台和 Windows 都应该支持此功能。启用此功能后，发生 IPv4 连接时 socket.getpeername() 返回的地址将是表示为 IPv4 映射 IPv6 地址的 IPv6 地址。如果 dualstack_ipv6 为 false，它将在默认启用它的平台上明确禁用此功能（例如 Linux）。该参数可以与has_dualstack_ipv6()结合使用：

import socket

addr = ("", 8080)  # all interfaces, port 8080
if socket.has_dualstack_ipv6():
    s = socket.create_server(addr, family=socket.AF_INET6, dualstack_ipv6=True)
else:
    s = socket.create_server(addr)

笔记

在 POSIX 平台上，设置 SO_REUSEADDR 套接字选项是为了立即重用先前绑定在相同地址上并保持在 TIME_WAIT 状态的套接字。

3.8 版中的新功能。

socket.has_dualstack_ipv6(): 如果平台支持创建可以处理 IPv4 和 IPv6 连接的 TCP 套接字，则返回 True。

3.8 版中的新功能。

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

复制文件描述符 fd（文件对象的 fileno() 方法返回的整数）并根据结果构建套接字对象。地址族、套接字类型和协议编号与上述socket() 功能相同。文件描述符应该引用一个套接字，但这不会被检查——如果文件描述符无效，对对象的后续操作可能会失败。此函数很少需要，但可用于获取或设置作为标准输入或输出传递给程序的套接字上的套接字选项（例如由 Unix inet 守护程序启动的服务器）。假定套接字处于阻塞模式。

新创建的套接字是不可继承的。

3.4 版更改：返回的套接字现在不可继承。

socket.fromshare(data): 从 socket.share() 方法获得的数据实例化一个套接字。假定套接字处于阻塞模式。

3.3 版中的新功能。

socket.SocketType: 这是一个表示套接字对象类型的 Python 类型对象。与type(socket(...))相同。

其他功能

socket 模块还提供各种与网络相关的服务：

socket.close(fd): 关闭套接字文件描述符。这类似于 os.close()，但用于套接字。在某些平台上（最引人注目的 Windows） os.close() 不适用于套接字文件描述符。

3.7 版中的新功能。

socket.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)

将 host/port 参数转换为 5 元组序列，其中包含创建连接到该服务的套接字所需的所有参数。 host 是一个域名，一个 IPv4/v6 地址的字符串表示或 None。 port 是字符串服务名称，例如 'http'、数字端口号或 None。通过将 None 作为 host 和 port 的值传递，您可以将 NULL 传递给底层 C API。

可以选择指定 family、type 和 proto 参数以缩小返回的地址列表。将零作为每个参数的值传递选择完整范围的结果。 flags 参数可以是 AI_* 常量中的一个或几个，并将影响结果的计算和返回方式。例如，AI_NUMERICHOST 将禁用域名解析，如果 host 是域名，则会引发错误。

该函数返回具有以下结构的 5 元组列表：

(family, type, proto, canonname, sockaddr)

在这些元组中，family、type、proto 都是整数，旨在传递给 socket() 函数。 canonname 将是一个字符串，表示 host 的规范名称，如果 AI_CANONNAME 是 flags 参数的一部分；否则 canonname 将为空。 sockaddr 是一个描述套接字地址的元组，其格式取决于返回的 family（一个 (address, port) 2-tuple for AF_INET，一个 [ X162X] 用于 AF_INET6) 的 4 元组，旨在传递给 socket.connect() 方法。

以下示例为端口 80 上到 example.org 的假设 TCP 连接获取地址信息（如果未启用 IPv6，结果可能会在您的系统上有所不同）：

>>> socket.getaddrinfo("example.org", 80, proto=socket.IPPROTO_TCP)
[(<AddressFamily.AF_INET6: 10>, <SocketType.SOCK_STREAM: 1>,
 6, '', ('2606:2800:220:1:248:1893:25c8:1946', 80, 0, 0)),
 (<AddressFamily.AF_INET: 2>, <SocketType.SOCK_STREAM: 1>,
 6, '', ('93.184.216.34', 80))]

3.2 版更改：现在可以使用关键字参数传递参数。

3.7 版更改：对于 IPv6 多播地址，表示地址的字符串将不包含 %scope_id 部分。

socket.getfqdn([name]): 返回 name 的完全限定域名。如果 name 省略或为空，则解释为本地主机。要查找完全限定名称，会检查 gethostbyaddr() 返回的主机名，然后是主机的别名（如果可用）。选择包含句点的名字。如果没有可用的完全限定域名并且提供了 name，则原样返回。如果 name 为空或等于 '0.0.0.0'，则返回来自 gethostname() 的主机名。

socket.gethostbyname(hostname): 将主机名转换为 IPv4 地址格式。 IPv4 地址作为字符串返回，例如 '100.50.200.5'。如果主机名是 IPv4 地址本身，则返回不变。更完整的接口见 gethostbyname_ex()。 gethostbyname() 不支持 IPv6 名称解析，应使用 getaddrinfo() 代替 IPv4/v6 双栈支持。

socket.gethostbyname_ex(hostname): 将主机名转换为 IPv4 地址格式，扩展接口。返回一个三元组 (hostname, aliaslist, ipaddrlist)，其中 hostname 是主机的主要主机名，aliaslist 是相同地址的备用主机名列表（可能为空），以及 ]ipaddrlist 是同一主机上同一接口的 IPv4 地址列表（通常但不总是单个地址）。 gethostbyname_ex() 不支持 IPv6 名称解析，应使用 getaddrinfo() 代替 IPv4/v6 双栈支持。

socket.gethostname()

返回一个字符串，其中包含 Python 解释器当前正在执行的机器的主机名。

注意：gethostname() 并不总是返回完全限定的域名；为此使用 getfqdn()。

socket.gethostbyaddr(ip_address): 返回一个三元组 (hostname, aliaslist, ipaddrlist)，其中 hostname 是响应给定 ip_address 的主要主机名，aliaslist 是一个（可能是空的）替代列表同一地址的主机名，ipaddrlist 是同一主机上同一接口的 IPv4/v6 地址列表（很可能只包含一个地址）。要查找完全限定的域名，请使用函数 getfqdn()。 gethostbyaddr() 支持 IPv4 和 IPv6。

socket.getnameinfo(sockaddr, flags)

将套接字地址 sockaddr 转换为 2 元组 (host, port)。根据 flags 的设置，结果可以包含完全限定的域名或 host 中的数字地址表示。同样，port 可以包含字符串端口名称或数字端口号。

对于 IPv6 地址，如果 sockaddr 包含有意义的 scope_id，则将 %scope_id 附加到主机部分。通常这发生在多播地址上。

有关 flags 的更多信息，您可以参考 getnameinfo(3)。

socket.getprotobyname(protocolname): 将 Internet 协议名称（例如，'icmp'）转换为适合作为（可选）第三个参数传递给 socket() 函数的常量。这通常仅用于以“原始”模式打开的套接字 (SOCK_RAW)；对于普通套接字模式，如果协议省略或为零，则会自动选择正确的协议。

socket.getservbyname(servicename[, protocolname]): 将 Internet 服务名称和协议名称转换为该服务的端口号。可选的协议名称（如果给出）应该是 'tcp' 或 'udp'，否则任何协议都将匹配。

socket.getservbyport(port[, protocolname]): 将 Internet 端口号和协议名称转换为该服务的服务名称。可选的协议名称（如果给出）应该是 'tcp' 或 'udp'，否则任何协议都将匹配。

socket.ntohl(x): 将 32 位正整数从网络转换为主机字节顺序。在主机字节顺序与网络字节顺序相同的机器上，这是一个空操作；否则，它执行 4 字节交换操作。

socket.ntohs(x): 将 16 位正整数从网络转换为主机字节顺序。在主机字节顺序与网络字节顺序相同的机器上，这是一个空操作；否则，它执行 2 字节交换操作。

自 3.7 版起已弃用：如果 x 不适合 16 位无符号整数，但适合正 C int，它会被静默截断为 16 位无符号整数。此静默截断功能已弃用，并将在 Python 的未来版本中引发异常。

socket.htonl(x): 将 32 位正整数从主机转换为网络字节顺序。在主机字节顺序与网络字节顺序相同的机器上，这是一个空操作；否则，它执行 4 字节交换操作。

socket.htons(x): 将 16 位正整数从主机字节序转换为网络字节序。在主机字节顺序与网络字节顺序相同的机器上，这是一个空操作；否则，它执行 2 字节交换操作。

自 3.7 版起已弃用：如果 x 不适合 16 位无符号整数，但适合正 C int，它会被静默截断为 16 位无符号整数。此静默截断功能已弃用，并将在 Python 的未来版本中引发异常。

socket.inet_aton(ip_string)

将 IPv4 地址从点分四元字符串格式（例如，'123.45.67.89'）转换为 32 位压缩二进制格式，作为长度为四个字符的字节对象。这在与使用标准 C 库并需要 struct in_addr 类型的对象进行对话时很有用，这是此函数返回的 32 位打包二进制文件的 C 类型。

inet_aton() 也接受少于三个点的字符串；有关详细信息，请参阅 Unix 手册页 inet(3)。

如果传递给此函数的 IPv4 地址字符串无效，则会引发 OSError。请注意，究竟什么有效取决于 inet_aton() 的底层 C 实现。

inet_aton() 不支持 IPv6，应使用 inet_pton() 代替 IPv4/v6 双栈支持。

socket.inet_ntoa(packed_ip)

将 32 位打包 IPv4 地址（长度为 4 个字节的字节类对象）转换为其标准的点分四线字符串表示形式（例如，'123.45.67.89'）。这在与使用标准 C 库并需要 struct in_addr 类型对象的程序进行对话时很有用，这是此函数作为参数的 32 位打包二进制数据的 C 类型。

如果传递给此函数的字节序列长度不完全是 4 个字节，则会引发 OSError。 inet_ntoa() 不支持 IPv6，应使用 inet_ntop() 代替 IPv4/v6 双栈支持。

3.5 版更改：现在接受可写字节类对象。

socket.inet_pton(address_family, ip_string)

将 IP 地址从特定于系列的字符串格式转换为打包的二进制格式。 inet_pton() 当库或网络协议调用类型为 struct in_addr（类似于 inet_aton()）或 struct in6_addr 的对象时很有用。

address_family 目前支持的值为 AF_INET 和 AF_INET6。如果 IP 地址字符串 ip_string 无效，则会引发 OSError。请注意，究竟什么有效取决于 address_family 的值和 inet_pton() 的底层实现。

3.4 版更改: 增加了对 Windows 的支持

socket.inet_ntop(address_family, packed_ip)

将打包的 IP 地址（某个字节数的类字节对象）转换为其标准的、特定于系列的字符串表示（例如，'7.10.0.5' 或 '5aef:2b::8'） . inet_ntop() 当库或网络协议返回类型为 struct in_addr（类似于 inet_ntoa()）或 struct in6_addr[ X172X]。

address_family 目前支持的值为 AF_INET 和 AF_INET6。如果字节对象 packed_ip 不是指定地址族的正确长度，则会引发 ValueError。 OSError 在调用 inet_ntop() 时出现错误。

3.4 版更改: 增加了对 Windows 的支持

3.5 版更改：现在接受可写字节类对象。

socket.CMSG_LEN(length): 返回具有给定长度的关联数据的辅助数据项的总长度，不包括尾随填充。该值通常可用作 recvmsg() 的缓冲区大小以接收单个辅助数据项，但 RFC 3542 需要便携式应用程序使用 [ X184X]CMSG_SPACE() 并因此包含用于填充的空间，即使该项目将是缓冲区中的最后一个。如果 length 超出允许的值范围，则引发 OverflowError。

3.3 版中的新功能。

socket.CMSG_SPACE(length)

返回 recvmsg() 接收带有给定 length 关联数据的辅助数据项以及任何尾随填充所需的缓冲区大小。接收多个项目所需的缓冲区空间是其相关数据长度的 CMSG_SPACE() 值的总和。如果 length 超出允许的值范围，则引发 OverflowError。

请注意，某些系统可能支持辅助数据而不提供此功能。另请注意，使用此函数的结果设置缓冲区大小可能无法精确限制可以接收的辅助数据量，因为附加数据可能能够放入填充区域。

3.3 版中的新功能。

socket.getdefaulttimeout(): 返回新套接字对象的默认超时（以秒为单位）。 None 的值表示新的套接字对象没有超时。首次导入socket模块时，默认为None。

socket.setdefaulttimeout(timeout): 为新的套接字对象设置默认超时（以秒为单位）。首次导入socket模块时，默认为None。有关可能的值及其各自的含义，请参阅 settimeout()。

socket.sethostname(name): 将机器的主机名设置为 name。如果您没有足够的权限，这将引发 OSError。

3.3 版中的新功能。

socket.if_nameindex()

返回网络接口信息（索引整数，名称字符串）元组的列表。 OSError 如果系统调用失败。

3.3 版中的新功能。

在 3.8 版更改：添加了 Windows 支持。

笔记

在 Windows 上，网络接口在不同的上下文中有不同的名称（所有名称都是示例）：

UUID：{FB605B73-AAC2-49A6-9A2F-25416AEA0573}
名称：ethernet_32770
友好名称：vEthernet (nat)
描述：Hyper-V Virtual Ethernet Adapter

此函数返回列表中第二种形式的名称，在本例中为 ethernet_32770。

socket.if_nametoindex(if_name): 返回与接口名称对应的网络接口索引号。 OSError 如果不存在具有给定名称的接口。

3.3 版中的新功能。

在 3.8 版更改：添加了 Windows 支持。

也可以看看

“接口名称”是 if_nameindex() 中记录的名称。

socket.if_indextoname(if_index): 返回与接口索引号对应的网络接口名称。 OSError 如果不存在具有给定索引的接口。

3.3 版中的新功能。

在 3.8 版更改：添加了 Windows 支持。

也可以看看

“接口名称”是 if_nameindex() 中记录的名称。

socket.send_fds(sock, buffers, fds[, flags[, address]]): 通过 AF_UNIX 套接字 sock 发送文件描述符列表 fds。 fds 参数是一个文件描述符序列。有关这些参数的文档，请参阅 sendmsg()。

3.9 版中的新功能。

socket.recv_fds(sock, bufsize, maxfds[, flags]): 从 AF_UNIX 套接字 sock 接收最多 maxfds 文件描述符。返回 (msg, list(fds), flags, addr)。有关这些参数的文档，请参阅 recvmsg()。

3.9 版中的新功能。

笔记

文件描述符列表末尾的任何截断整数。

套接字对象

Socket 对象有以下方法。除了 makefile()，这些对应于适用于套接字的 Unix 系统调用。

3.2 版更改：添加了对上下文管理器协议的支持。退出上下文管理器相当于调用 close()。

socket.accept()

接受连接。套接字必须绑定到一个地址并侦听连接。返回值是一对 (conn, address)，其中 conn 是一个 new 套接字对象，可用于在连接上发送和接收数据，address 是绑定到连接另一端的套接字的地址。

新创建的套接字是不可继承的。

3.4 版更改：套接字现在不可继承。

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.bind(address): 将套接字绑定到地址。套接字必须尚未绑定。（address 的格式取决于地址族——见上文。）

socket.close()

标记插座关闭。底层系统资源（例如当所有来自 makefile() 的文件对象都关闭时，一个文件描述符）也会被关闭。一旦发生这种情况，套接字对象上的所有未来操作都将失败。远程端将不再接收数据（在刷新排队数据后）。

套接字在被垃圾收集时会自动关闭，但建议显式 close() 它们，或者在它们周围使用和语句。

在 3.6 版更改：如果在进行底层 close() 调用时发生错误，现在会引发 OSError。

笔记

close() 释放与连接关联的资源，但不一定立即关闭连接。如果您想及时关闭连接，请在 close() 之前调用 shutdown()。

socket.connect(address)

连接到地址处的远程套接字。（address 的格式取决于地址族——见上文。）

如果连接被信号中断，则该方法等待直到连接完成，或者在超时时引发 socket.timeout，如果信号处理程序没有引发异常并且套接字被阻塞或有暂停。对于非阻塞套接字，如果连接被信号（或信号处理程序引发的异常）中断，则该方法会引发 InterruptedError 异常。

3.5 版更改：该方法现在等待连接完成，而不是在连接被信号中断时引发 InterruptedError 异常，信号处理程序不会引发异常并且套接字阻塞或超时（有关基本原理，请参阅 PEP 475）。

socket.connect_ex(address): 与connect(address)类似，但对于C级connect()调用返回的错误返回一个错误指示符而不是引发异常（其他问题，例如“找不到主机”，仍然可以引发异常） . 如果操作成功，错误指示符为 0，否则为 errno 变量的值。这对于支持异步连接等很有用。

socket.detach(): 将套接字对象置于关闭状态而不实际关闭底层文件描述符。文件描述符被返回，并可用于其他目的。

3.2 版中的新功能。

socket.dup()

复制插座。

新创建的套接字是不可继承的。

3.4 版更改：套接字现在不可继承。

socket.fileno()

返回套接字的文件描述符（一个小整数），失败时返回 -1。这对 select.select() 很有用。

在 Windows 下，此方法返回的小整数不能用于可以使用文件描述符的地方（例如 os.fdopen()）。 Unix 没有这个限制。

socket.get_inheritable(): 获取套接字文件描述符或套接字句柄的可继承标志： True 如果套接字可以在子进程中继承，则 False 如果不能。

3.4 版中的新功能。

socket.getpeername(): 返回套接字连接到的远程地址。例如，这对于找出远程 IPv4/v6 套接字的端口号很有用。（返回的地址格式取决于地址族——见上文。）在某些系统上不支持此功能。

socket.getsockname(): 返回套接字自己的地址。例如，这对于找出 IPv4/v6 套接字的端口号很有用。（返回的地址格式取决于地址族——见上文。）

socket.getsockopt(level, optname[, buflen]): 返回给定套接字选项的值（参见 Unix 手册页 getsockopt(2)）。所需的符号常量（SO_* 等）在此模块中定义。如果 buflen 不存在，则假定为整数选项，并由函数返回其整数值。如果 buflen 存在，它指定用于接收选项的缓冲区的最大长度，并且该缓冲区作为字节对象返回。由调用者来解码缓冲区的内容（请参阅可选的内置模块 struct 以获取解码编码为字节字符串的 C 结构的方法）。

socket.getblocking()

如果套接字处于阻塞模式，则返回 True，如果处于非阻塞模式，则返回 False。

这相当于检查 socket.gettimeout() == 0。

3.7 版中的新功能。

socket.gettimeout(): 返回与套接字操作关联的超时（以秒为单位），如果未设置超时，则返回 None。这反映了对 setblocking() 或 settimeout() 的最后一次调用。

socket.ioctl(control, option)

平台: 视窗

ioctl() 方法是 WSAIoctl 系统接口的受限接口。请参阅 Win32 文档了解更多信息。

在其他平台上，可以使用通用的 fcntl.fcntl() 和 fcntl.ioctl() 函数；他们接受一个套接字对象作为他们的第一个参数。

目前仅支持以下控制码：SIO_RCVALL、SIO_KEEPALIVE_VALS和SIO_LOOPBACK_FAST_PATH。

3.6 版更改：添加了 SIO_LOOPBACK_FAST_PATH。

socket.listen([backlog]): 启用服务器以接受连接。如果指定了backlog，则必须至少为0（如果更低，则设置为0）；它指定系统在拒绝新连接之前允许的未接受连接数。如果未指定，则选择默认的合理值。

3.5 版更改：backlog 参数现在是可选的。

socket.makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None)

返回与套接字关联的文件对象。确切的返回类型取决于给 makefile() 的参数。这些参数的解释方式与内置 open() 函数的解释方式相同，除了唯一支持的 mode 值为 'r'（默认）、'w' 和 'b'。

套接字必须处于阻塞模式；它可以有超时，但如果发生超时，文件对象的内部缓冲区可能会以不一致的状态结束。

关闭由 makefile() 返回的文件对象不会关闭原始套接字，除非所有其他文件对象都已关闭并且 socket.close() 已在套接字对象上调用。

笔记

在 Windows 上，由 makefile() 创建的类文件对象不能用于需要具有文件描述符的文件对象，例如 subprocess.Popen() 的流参数.

socket.recv(bufsize[, flags]): 从套接字接收数据。返回值是一个字节对象，表示接收到的数据。一次接收的最大数据量由 bufsize 指定。有关可选参数 flags 的含义，请参见 Unix 手册页 recv(2)；它默认为零。

笔记

为了与硬件和网络实际情况最佳匹配，bufsize 的值应该是相对较小的 2 的幂，例如 4096。

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.recvfrom(bufsize[, flags]): 从套接字接收数据。返回值是一对 (bytes, address)，其中 bytes 是表示接收到的数据的字节对象，address 是发送数据的套接字的地址。有关可选参数 flags 的含义，请参见 Unix 手册页 recv(2)；它默认为零。（address 的格式取决于地址族——见上文。）

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

3.7 版本变更：对于组播 IPv6 地址，address 的第一项不再包含 %scope_id 部分。为了获得完整的 IPv6 地址，请使用 getnameinfo()。

socket.recvmsg(bufsize[, ancbufsize[, flags]])

从套接字接收正常数据（最多 bufsize 字节）和辅助数据。 ancbufsize 参数设置用于接收辅助数据的内部缓冲区的大小（以字节为单位）；它默认为 0，意味着不会收到任何辅助数据。可以使用 CMSG_SPACE() 或 CMSG_LEN() 计算辅助数据的适当缓冲区大小，不适合缓冲区的项目可能会被截断或丢弃。 flags 参数默认为 0，与 recv() 具有相同的含义。

返回值是一个 4 元组：(data, ancdata, msg_flags, address)。 data 项是一个 bytes 对象，保存接收到的非辅助数据。 ancdata 项是零个或多个元组 (cmsg_level, cmsg_type, cmsg_data) 的列表，表示接收到的辅助数据（控制消息）：cmsg_level 和 cmsg_type 是整数分别指定协议级别和协议特定类型，cmsg_data 是一个 bytes 对象，保存相关数据。 msg_flags项是表示接收消息条件的各种标志的按位或；有关详细信息，请参阅您的系统文档。如果接收套接字未连接，则 address 是发送套接字的地址（如果有）；否则，它的值是未指定的。

在某些系统上，sendmsg() 和 recvmsg() 可用于通过 AF_UNIX 套接字在进程之间传递文件描述符。使用此功能时（通常仅限于 SOCK_STREAM 套接字），recvmsg() 将在其辅助数据中返回形式为 (socket.SOL_SOCKET, socket.SCM_RIGHTS, fds) 的项目，其中fds 是一个 bytes 对象，将新文件描述符表示为原生 C int 类型的二进制数组。如果 recvmsg() 在系统调用返回后引发异常，它将首先尝试关闭通过此机制接收到的任何文件描述符。

一些系统不指示仅部分接收的辅助数据项的截断长度。如果一个项目似乎超出了缓冲区的末尾，recvmsg() 将发出一个 RuntimeWarning，并返回它在缓冲区内的部分，前提是它没有被在其关联数据开始之前被截断。

在支持 SCM_RIGHTS 机制的系统上，以下函数将接收最多 maxfds 个文件描述符，返回消息数据和包含描述符的列表（同时忽略不相关的控制消息等意外情况收到）。另见 sendmsg()。

import socket, array

def recv_fds(sock, msglen, maxfds):
    fds = array.array("i")   # Array of ints
    msg, ancdata, flags, addr = sock.recvmsg(msglen, socket.CMSG_LEN(maxfds * fds.itemsize))
    for cmsg_level, cmsg_type, cmsg_data in ancdata:
        if cmsg_level == socket.SOL_SOCKET and cmsg_type == socket.SCM_RIGHTS:
            # Append data, ignoring any truncated integers at the end.
            fds.frombytes(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
    return msg, list(fds)

3.3 版中的新功能。

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.recvmsg_into(buffers[, ancbufsize[, flags]])

从套接字接收普通数据和辅助数据，行为与 recvmsg() 一样，但将非辅助数据分散到一系列缓冲区中，而不是返回新的字节对象。 buffers 参数必须是导出可写缓冲区的对象的可迭代对象（例如 bytearray 对象）；这些将被连续的非辅助数据块填充，直到它被全部写入或没有更多的缓冲区。操作系统可能会对可以使用的缓冲区数量设置限制（sysconf() 值 SC_IOV_MAX）。 ancbufsize 和 flags 参数的含义与 recvmsg() 的含义相同。

返回值是一个 4 元组：(nbytes, ancdata, msg_flags, address)，其中 nbytes 是写入缓冲区的非辅助数据的总字节数，ancdata，[ X163X]msg_flags 和 address 与 recvmsg() 相同。

例子：

>>> import socket
>>> s1, s2 = socket.socketpair()
>>> b1 = bytearray(b'----')
>>> b2 = bytearray(b'0123456789')
>>> b3 = bytearray(b'--------------')
>>> s1.send(b'Mary had a little lamb')
22
>>> s2.recvmsg_into([b1, memoryview(b2)[2:9], b3])
(22, [], 0, None)
>>> [b1, b2, b3]
[bytearray(b'Mary'), bytearray(b'01 had a 9'), bytearray(b'little lamb---')]

3.3 版中的新功能。

socket.recvfrom_into(buffer[, nbytes[, flags]]): 从套接字接收数据，将其写入 buffer 而不是创建新的字节串。返回值是一对 (nbytes, address)，其中 nbytes 是接收到的字节数，address 是发送数据的套接字地址。有关可选参数 flags 的含义，请参见 Unix 手册页 recv(2)；它默认为零。（address 的格式取决于地址族——见上文。）

socket.recv_into(buffer[, nbytes[, flags]]): 从套接字接收最多 nbytes 个字节，将数据存储到缓冲区中而不是创建新的字节串。如果未指定 nbytes（或 0），则最多接收给定缓冲区中可用的大小。返回接收到的字节数。有关可选参数 flags 的含义，请参见 Unix 手册页 recv(2)；它默认为零。

socket.send(bytes[, flags]): 向套接字发送数据。套接字必须连接到远程套接字。可选的 flags 参数与上面的 recv() 具有相同的含义。返回发送的字节数。应用程序负责检查所有数据是否已发送；如果仅传输了部分数据，则应用程序需要尝试传输剩余数据。有关此主题的更多信息，请参阅套接字编程 HOWTO。

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.sendall(bytes[, flags]): 向套接字发送数据。套接字必须连接到远程套接字。可选的 flags 参数与上面的 recv() 具有相同的含义。与 send() 不同，此方法继续从 bytes 发送数据，直到所有数据都已发送或发生错误。 None 成功返回。出错时，会引发异常，并且无法确定成功发送了多少数据（如果有）。

3.5 版本变更：每次数据发送成功时不再重置套接字超时。套接字超时现在是发送所有数据的最大总持续时间。

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.sendto(bytes, address) socket.sendto(bytes, flags, address): 向套接字发送数据。套接字不应连接到远程套接字，因为目标套接字由地址指定。可选的 flags 参数与上面的 recv() 具有相同的含义。返回发送的字节数。（address 的格式取决于地址族——见上文。）

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.sendmsg(buffers[, ancdata[, flags[, address]]])

将正常和辅助数据发送到套接字，从一系列缓冲区中收集非辅助数据并将其连接成单个消息。 buffers 参数将非辅助数据指定为字节类对象的可迭代对象（例如 bytes 对象）；操作系统可能会对可以使用的缓冲区数量设置限制（sysconf() 值 SC_IOV_MAX）。 ancdata 参数将辅助数据（控制消息）指定为可迭代的零个或多个元组 (cmsg_level, cmsg_type, cmsg_data)，其中 cmsg_level 和 cmsg_type 是整数分别指定协议级别和协议特定类型，cmsg_data 是一个类似字节的对象，保存相关数据。请注意，某些系统（特别是没有 CMSG_SPACE() 的系统）可能支持每次调用仅发送一个控制消息。 flags 参数默认为 0，其含义与 send() 相同。如果提供了 address 而不是 None，它会设置消息的目标地址。返回值是发送的非辅助数据的字节数。

以下函数在支持 SCM_RIGHTS 机制的系统上通过 AF_UNIX 套接字发送文件描述符列表 fds。另见 recvmsg()。

import socket, array

def send_fds(sock, msg, fds):
    return sock.sendmsg([msg], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array("i", fds))])

3.3 版中的新功能。

3.5 版更改：如果系统调用被中断并且信号处理程序没有引发异常，该方法现在重试系统调用而不是引发 InterruptedError 异常（参见 ]PEP 475 的基本原理）。

socket.sendmsg_afalg([msg, ]*, op[, iv[, assoclen[, flags]]]): sendmsg() 的特殊版本，用于 AF_ALG 套接字。设置 AF_ALG 套接字的模式、IV、AEAD 相关数据长度和标志。

3.6 版中的新功能。

socket.sendfile(file, offset=0, count=None): 使用高性能 os.sendfile 发送文件直到到达 EOF 并返回已发送的总字节数。 file 必须是以二进制模式打开的常规文件对象。如果 os.sendfile 不可用（例如 Windows) 或 file 不是常规文件 send() 将被使用。 offset 告诉从哪里开始读取文件。如果指定，count 是要传输的总字节数，而不是在到达 EOF 之前发送文件。文件位置在返回时更新，或者在错误的情况下更新，在这种情况下 file.tell() 可用于计算发送的字节数。套接字必须是 SOCK_STREAM 类型。不支持非阻塞套接字。

3.5 版中的新功能。

socket.set_inheritable(inheritable): 设置套接字文件描述符或套接字句柄的可继承标志。

3.4 版中的新功能。

socket.setblocking(flag)

设置socket的阻塞或非阻塞模式：如果flag为false，则socket设置为非阻塞模式，否则为阻塞模式。

此方法是某些 settimeout() 调用的简写：

sock.setblocking(True) 相当于 sock.settimeout(None)
sock.setblocking(False) 相当于 sock.settimeout(0.0)

3.7 版本更改：该方法不再在 socket.type 上应用 SOCK_NONBLOCK 标志。

socket.settimeout(value)

设置阻塞套接字操作的超时时间。 value 参数可以是表示秒的非负浮点数，或 None。如果给出了一个非零值，如果超时时间 value 在操作完成之前已经过去，则后续的套接字操作将引发 timeout 异常。如果给出零，则套接字处于非阻塞模式。如果给出 None，则套接字处于阻塞模式。

有关更多信息，请参阅有关套接字超时的注释。

3.7 版更改：该方法不再切换 socket.type 上的 SOCK_NONBLOCK 标志。

socket.setsockopt(level, optname, value: int)

socket.setsockopt(level, optname, value: buffer)

socket.setsockopt(level, optname, None, optlen: int): 设置给定套接字选项的值（参见 Unix 手册页 setsockopt(2)）。所需的符号常量在 socket 模块（SO_* 等）中定义。该值可以是整数、None 或表示缓冲区的字节类对象。在后一种情况下，由调用者确保字节串包含正确的位（请参阅可选的内置模块 struct 以了解将 C 结构编码为字节串的方法）。当 value 设置为 None 时，需要 optlen 参数。相当于用optval=NULL和optlen=optlen调用setsockopt()C函数。

3.5 版更改：现在接受可写字节类对象。

3.6 版更改：添加了 setsockopt(level, optname, None, optlen: int) 表单。

socket.shutdown(how): 关闭连接的一侧或两侧。如果 how 是 SHUT_RD，则不允许进一步接收。如果 how 是 SHUT_WR，则不允许进一步发送。如果 how 是 SHUT_RDWR，则不允许进一步发送和接收。

socket.share(process_id): 复制套接字并准备与目标进程共享。必须为目标进程提供 process_id。然后可以使用某种形式的进程间通信将生成的字节对象传递给目标进程，并且可以使用 fromshare() 在那里重新创建套接字。调用此方法后，关闭套接字是安全的，因为操作系统已经为目标进程复制了它。

3.3 版中的新功能。

请注意，没有方法 read() 或 write()；使用 recv() 和 send() 代替 flags 参数。

Socket 对象还具有这些（只读）属性，这些属性对应于给 socket 构造函数的值。

socket.family: 插座家族。

socket.type: 插座类型。

socket.proto: 套接字协议。

关于套接字超时的注意事项

套接字对象可以处于以下三种模式之一：阻塞、非阻塞或超时。默认情况下，套接字总是以阻塞模式创建，但这可以通过调用 setdefaulttimeout() 来更改。

在阻塞模式下，操作阻塞直到完成或系统返回错误（如连接超时）。
在 非阻塞模式 中，如果操作不能立即完成，则操作失败（不幸的是系统相关的错误）：来自 select 的函数可用于知道何时以及是否一个套接字可用于读取或写入。
在 超时模式 中，如果操作无法在为套接字指定的超时内完成（它们引发 timeout 异常）或系统返回错误，则操作失败。

笔记

在操作系统层面，超时模式中的套接字在内部设置为非阻塞模式。此外，阻塞和超时模式在引用同一网络端点的文件描述符和套接字对象之间共享。这个实现细节可能会产生明显的后果，例如您决定使用套接字的 fileno()。

超时和 connect 方法

connect()操作也受超时设置的影响，一般情况下建议在调用connect()之前先调用settimeout()或传递一个create_connection() 的超时参数。但是，无论 Python 套接字超时设置如何，系统网络堆栈也可能返回其自身的连接超时错误。

超时和 accept 方法

如果 getdefaulttimeout() 不是 None，accept() 方法返回的套接字继承该超时。否则，行为取决于侦听套接字的设置：

如果监听socket处于阻塞模式或超时模式，则accept()返回的socket处于阻塞模式；
如果侦听套接字处于 非阻塞模式 ，则 accept() 返回的套接字是处于阻塞模式还是非阻塞模式取决于操作系统。如果您想确保跨平台行为，建议您手动覆盖此设置。

例子

下面是四个使用 TCP/IP 协议的最小示例程序：一个服务器回显它收到的所有数据（仅服务一个客户端），一个客户端使用它。请注意，服务器必须执行序列 socket()、bind()、listen()、accept()（可能重复 ]accept() 为多个客户端提供服务），而一个客户端只需要序列 socket(), connect()。另请注意，服务器不会在它正在侦听的套接字上 sendall()/recv()，而是在 accept() 返回的新套接字上。

前两个示例仅支持 IPv4。

# Echo server program
import socket

HOST = ''                 # Symbolic name meaning all available interfaces
PORT = 50007              # Arbitrary non-privileged port
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(1)
    conn, addr = s.accept()
    with conn:
        print('Connected by', addr)
        while True:
            data = conn.recv(1024)
            if not data: break
            conn.sendall(data)

# Echo client program
import socket

HOST = 'daring.cwi.nl'    # The remote host
PORT = 50007              # The same port as used by the server
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    s.sendall(b'Hello, world')
    data = s.recv(1024)
print('Received', repr(data))

接下来的两个示例与上述两个示例相同，但同时支持 IPv4 和 IPv6。服务器端将侦听第一个可用的地址族（它应该同时侦听两者）。在大多数支持 IPv6 的系统上，IPv6 将优先，服务器可能不接受 IPv4 流量。客户端将尝试连接到作为名称解析结果返回的所有地址，并将流量发送到第一个连接成功的地址。

# Echo server program
import socket
import sys

HOST = None               # Symbolic name meaning all available interfaces
PORT = 50007              # Arbitrary non-privileged port
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
                              socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except OSError as msg:
        s = None
        continue
    try:
        s.bind(sa)
        s.listen(1)
    except OSError as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print('could not open socket')
    sys.exit(1)
conn, addr = s.accept()
with conn:
    print('Connected by', addr)
    while True:
        data = conn.recv(1024)
        if not data: break
        conn.send(data)

# Echo client program
import socket
import sys

HOST = 'daring.cwi.nl'    # The remote host
PORT = 50007              # The same port as used by the server
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
    af, socktype, proto, canonname, sa = res
    try:
        s = socket.socket(af, socktype, proto)
    except OSError as msg:
        s = None
        continue
    try:
        s.connect(sa)
    except OSError as msg:
        s.close()
        s = None
        continue
    break
if s is None:
    print('could not open socket')
    sys.exit(1)
with s:
    s.sendall(b'Hello, world')
    data = s.recv(1024)
print('Received', repr(data))

下一个示例展示了如何在 Windows 上使用原始套接字编写一个非常简单的网络嗅探器。该示例需要管理员权限才能修改界面：

import socket

# the public network interface
HOST = socket.gethostbyname(socket.gethostname())

# create a raw socket and bind it to the public interface
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
s.bind((HOST, 0))

# Include IP headers
s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

# receive all packages
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)

# receive a package
print(s.recvfrom(65565))

# disabled promiscuous mode
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

下一个示例说明如何使用套接字接口通过原始套接字协议与 CAN 网络通信。要将 CAN 与广播管理器协议一起使用，请使用以下命令打开套接字：

socket.socket(socket.AF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM)

绑定(CAN_RAW)或连接(CAN_BCM)socket后，可以使用socket.send()和socket.recv() 像往常一样对套接字对象进行操作（及其对应项）。

最后一个示例可能需要特殊权限：

import socket
import struct


# CAN frame packing/unpacking (see 'struct can_frame' in <linux/can.h>)

can_frame_fmt = "=IB3x8s"
can_frame_size = struct.calcsize(can_frame_fmt)

def build_can_frame(can_id, data):
    can_dlc = len(data)
    data = data.ljust(8, b'\x00')
    return struct.pack(can_frame_fmt, can_id, can_dlc, data)

def dissect_can_frame(frame):
    can_id, can_dlc, data = struct.unpack(can_frame_fmt, frame)
    return (can_id, can_dlc, data[:can_dlc])


# create a raw socket and bind it to the 'vcan0' interface
s = socket.socket(socket.AF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
s.bind(('vcan0',))

while True:
    cf, addr = s.recvfrom(can_frame_size)

    print('Received: can_id=%x, can_dlc=%x, data=%s' % dissect_can_frame(cf))

    try:
        s.send(cf)
    except OSError:
        print('Error sending CAN frame')

    try:
        s.send(build_can_frame(0x01, b'\x01\x02\x03'))
    except OSError:
        print('Error sending CAN frame')

多次运行示例，两次执行之间的延迟太小，可能会导致此错误：

OSError: [Errno 98] Address already in use

这是因为之前的执行使套接字处于 TIME_WAIT 状态，不能立即重用。

有一个 socket 标志要设置，为了防止这种情况，socket.SO_REUSEADDR：

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))

SO_REUSEADDR 标志告诉内核重用处于 TIME_WAIT 状态的本地套接字，而无需等待其自然超时到期。

也可以看看

有关套接字编程（在 C 中）的介绍，请参阅以下论文：

介绍 4.3BSD 进程间通信教程 ，作者 Stuart Sechrest
高级 4.3BSD 进程间通信教程 ，作者：Samuel J。莱夫勒等人，

均在 UNIX 程序员手册，补充文档 1（PS1:7 和 PS1:8 部分）中。各种与套接字相关的系统调用的特定于平台的参考资料也是有关套接字语义细节的宝贵信息来源。对于 Unix，请参阅手册页；对于 Windows，请参阅 WinSock（或 Winsock 2）规范。对于支持 IPv6 的 API，读者可能需要参考 RFC 3493 标题为 IPv6 的基本套接字接口扩展。

socket — 低级网络接口 — Python 文档

目录

socket — 低级网络接口

插座系列

模块内容

例外

常数

功能

创建套接字

其他功能

套接字对象

关于套接字超时的注意事项

超时和 connect 方法

超时和 accept 方法

例子