套接字—低级网络接口

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

Note

由于对 os 套接字 API 进行了调用，因此某些行为可能取决于平台。

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

Socket families

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

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

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

Note

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

在版本 3.5 中更改：现在接受可写bytes-like object。

对(host, port)用于AF_INET地址族，其中* host 是一个字符串，表示 Internet 域表示法中的主机名(如'daring.cwi.nl')或 IPv4 地址(如'100.50.200.5')，而 port *是整数。
对于 IPv4 地址，接受两种特殊形式而不是主机地址：''表示INADDR_ANY，用于绑定到所有接口，字符串'<broadcast>'表示INADDR_BROADCAST。此行为与 IPv6 不兼容，因此，如果要使用 Python 程序支持 IPv6，则可能要避免这些行为。
对于AF_INET6地址族，使用四 Tuples(host, port, flowinfo, scopeid)，其中* flowinfo 和 scopeid 代表 C 中struct sockaddr_in6中的sin6_flowinfo和sin6_scope_id成员。对于socket模块方法，可以Ellipsis flowinfo 和 scopeid 只是为了向后兼容性。但是请注意，Ellipsis scopeid *可能会导致在处理作用域 IPv6 地址时出现问题。

在版本 3.7 中更改：对于多播地址(有意义的* scopeid )， address *可能不包含%scope(或zone id)部分。此信息是多余的，可以安全地Ellipsis(推荐)。

AF_NETLINK套接字表示为对(pid, groups)。
使用AF_TIPC地址系列可获得仅 Linux 对 TIPC 的支持。 TIPC 是一种开放的，非基于 IP 的网络协议，旨在用于群集计算机环境中。地址由 Tuples 表示，并且字段取决于地址类型。一般的 Tuples 形式为(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.

Tuples(interface, )用于AF_CAN地址族，其中* interface *是代表诸如'can0'之类的网络接口名称的字符串。网络接口名称''可用于接收来自该系列所有网络接口的数据包。
CAN_ISOTP协议需要一个 Tuples(interface, rx_addr, tx_addr)，其中两个附加参数均为表示 CAN 标识符(标准或扩展)的无符号长整数。
字符串或 Tuples(id, unit)用于PF_SYSTEM系列的SYSPROTO_CONTROL协议。该字符串是使用动态分配的 ID 的内核控件的名称。如果已知内核控件的 ID 和单元号或使用已注册的 ID，则可以使用 Tuples。

版本 3.3 中的新Function。

AF_BLUETOOTH支持以下协议和地址格式：
BTPROTO_L2CAP接受(bdaddr, psm)，其中bdaddr是蓝牙地址作为字符串，而psm是整数。
- BTPROTO_RFCOMM接受(bdaddr, channel)，其中bdaddr是蓝牙地址作为字符串，而channel是整数。
- BTPROTO_HCI接受(device_id,)，其中device_id是具有接口蓝牙地址的整数或字符串。 (这取决于您的 os； 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]])的 Tuples，其中：
- type *是字符串形式的算法类型，例如aead，hash，skcipher或rng。
- - name *是算法名称和操作模式，以字符串形式表示，例如sha256，hmac(sha256)，cbc(aes)或drbg_nopr_ctr_aes256。
- - feat 和 mask *是无符号的 32 位整数。

Availability：Linux 2.6.38，某些算法类型需要更新的内核。

3.6 版的新Function。

AF_VSOCK允许虚拟机与其主机之间进行通信。套接字表示为(CID, port)Tuples，其中上下文 ID 或 CID 和端口是整数。

Availability：Linux> = 4.8 QEMU> = 2.8 ESX> = 4.0 ESX 工作站> = 6.5.

3.7 版中的新Function。

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

3.8 版的新Function。

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

所有错误都会引发异常。无效参数类型和内存不足条件的正常异常可以被提出。从 Python 3.3 开始，与套接字或地址语义相关的错误引发OSError或其子类之一(它们用于引发socket.error)。

passsetblocking()支持非阻塞模式。passsettimeout()支持基于超时的通用化。

Module contents

socket模块导出以下元素。

Exceptions

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 代表gai_strerror() C 函数返回的 error *的描述。 * error *的数字值将与此模块中定义的EAI_*常量之一匹配。

在版本 3.3 中进行了更改：此类已成为OSError的子类。

exception socket. timeout
- OSError的子类，当套接字发生超时时，如果pass事先调用settimeout()(或passsetdefaulttimeout()隐式)启用了超时，则会引发此异常。附带的值是一个字符串，其值当前始终处于“超时”状态。

在版本 3.3 中进行了更改：此类已成为OSError的子类。

Constants

Note

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

3.4 版的新Function。

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
- 这两个常量(如果已定义)可以与套接字类型结合使用，并允许您自动设置一些标志(从而避免了可能的争用条件和单独调用的需要)。

Functions

Creating sockets

以下所有函数均创建socket objects。

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_常量之一。协议编号通常为零，可以Ellipsis，或者在地址系列为AF_CAN的情况下，协议应为CAN_RAW，CAN_BCM或CAN_ISOTP之一。

如果指定了* fileno ，将从指定的文件 Descriptors 中自动检测 family ， type 和 proto 的值。pass使用显式 family ， type 或 proto 参数调用该函数，可以否决自动检测。这只会影响 Python 的表示方式返回值socket.getpeername()，但不是实际的 os 资源。与socket.fromfd()不同， fileno *将返回相同的套接字，而不是重复的套接字。这可能有助于使用socket.close()关闭分离的套接字。

新创建的套接字是non-inheritable。

用参数self，family，type，protocol引发auditing event socket.__new__。

在版本 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的 os 上创建一个非阻塞套接字，但是sock.type将被设置为socket.SOCK_STREAM。

socket. socketpair([* family * [，* type * [，* proto *]]])
- 使用给定的地址族，套接字类型和协议号构建Pair连接的套接字对象。地址族，套接字类型和协议号与上面的socket()函数相同。如果在平台上定义，则默认系列为AF_UNIX；否则，默认值为AF_INET。

新创建的套接字是non-inheritable。

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

在版本 3.4 中进行了更改：现在返回的套接字是不可继承的。

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

socket. create_connection(* address * [，* timeout * [，* source_address *]])
- 连接到侦听 Internet 地址(2Tuples(host, port))的 TCP 服务，并返回套接字对象。这是比socket.connect()更高级别的函数：如果* host *是非数字主机名，它将try同时为AF_INET和AF_INET6解析它，然后try依次连接到所有可能的地址，直到连接成功。这使得编写兼容 IPv4 和 IPv6 的 Client 端变得容易。

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

如果提供，则* source_address *必须为 2Tuples(host, port)，以便套接字在连接之前绑定为其源地址。如果主机或端口分别为''或 0，则将使用 os 默认行为。

在版本 3.2 中更改：添加了* source_address *。

socket. create_server(* address ，**，* family = AF_INET ， backlog = None ， reuse_port = False ， dualstack_ipv6 = False *)
- 便捷函数，该函数创建绑定到* address *(2Tuples(host, port))的 TCP 套接字并返回套接字对象。

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

如果* dualstack_ipv6 为 true 并且平台支持它，则套接字将能够接受 IPv4 和 IPv6 连接，否则它将引发ValueError。大多数 POSIX 平台和 Windows 应该支持此Function。启用此Function后，发生 IPv4 连接时socket.getpeername()返回的地址将是表示为 Map 了 IPv4 的 IPv6 地址的 IPv6 地址。如果 dualstack_ipv6 *为 false，它将在默认情况下在启用该Function的平台上明确禁用此Function(例如 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)

Note

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

3.8 版的新Function。

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

3.8 版的新Function。

socket. fromfd(* fd ， family ， type ， proto = 0 *)
- 复制文件 Descriptors* fd *(由文件对象的fileno()方法返回的整数)，并根据结果构建一个套接字对象。地址族，套接字类型和协议号与上面的socket()函数相同。文件 Descriptors 应该引用一个套接字，但是未选中-如果文件 Descriptors 无效，则对该对象的后续操作可能会失败。很少需要此函数，但可以使用该函数在作为标准 Importing 或输出(例如由 Unix inet 守护程序启动的服务器)传递给程序的套接字上获取或设置套接字选项。假定套接字处于阻止模式。

新创建的套接字是non-inheritable。

在版本 3.4 中进行了更改：现在返回的套接字是不可继承的。

socket. fromshare(* data *)
- 根据从socket.share()方法获得的数据实例化套接字。假定套接字处于阻止模式。

Availability: Windows.

版本 3.3 中的新Function。

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

Other functions

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

socket. close(* fd *)
- 关闭套接字文件 Descriptors。就像os.close()，但是用于套接字。在某些平台(最著名的 Windows)上，os.close()不适用于套接字文件 Descriptors。

3.7 版中的新Function。

socket. getaddrinfo(* host ， port ， family = 0 ， type = 0 ， proto = 0 ， flags = 0 *)
- 将* host / port *参数转换为 5Tuples 的序列，其中包含用于创建连接到该服务的套接字的所有必需参数。 * host *是域名，是 IPv4/v6 地址或None的字符串表示形式。 * port 是字符串服务名称，例如'http'，数字端口号或None。pass将None作为 host 和 port *的值传递，您可以将NULL传递给基础 C API。

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

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

(family, type, proto, canonname, sockaddr)

在这些 Tuples 中，* family ， type ， proto 都是整数，并应传递给socket()函数。如果AI_CANONNAME是 flags 参数的一部分，则* canonname 将是代表 host 规范名称的字符串；否则 canonname *将为空。 * sockaddr 是一个描述套接字地址的 Tuples，其格式取决于返回的 family *(对于AF_INET是(address, port) 2Tuples，对于AF_INET6是(address, port, flow info, scope id) 4Tuples)，并打算传递给socket.connect()方法。

用参数host，port，family，type，protocol引发auditing event socket.getaddrinfo。

以下示例为端口 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部分。

socket. getfqdn([* name *])
- 返回* name 的完全限定域名。如果 name *被Ellipsis或为空，则将其解释为 localhost。要查找标准名称，请检查gethostbyaddr()返回的主机名，然后检查主机的别名(如果有)。选择包含句点的名字。如果没有完全限定的域名可用，则返回gethostname()返回的主机名。
socket. gethostbyname(* hostname *)
- 将主机名转换为 IPv4 地址格式。 IPv4 地址以字符串形式返回，例如'100.50.200.5'。如果主机名本身是 IPv4 地址，则将其保持不变。有关更完整的界面，请参见gethostbyname_ex()。 gethostbyname()不支持 IPv6 名称解析，而应使用getaddrinfo()来支持 IPv4/v6 双协议栈。

用参数hostname引发auditing event socket.gethostbyname。

socket. gethostbyname_ex(* hostname *)
- 将主机名转换为 IPv4 地址格式的扩展接口。返回一个三进制(hostname, aliaslist, ipaddrlist)，其中* hostname 是响应给定 ip_address 的主要主机名， aliaslist 是该地址的替代主机名的列表(可能为空)，而 ipaddrlist *是 IPv4 地址的列表用于同一主机上的同一接口(通常但不总是单个地址)。 gethostbyname_ex()不支持 IPv6 名称解析，而应使用getaddrinfo()来支持 IPv4/v6 双协议栈。

用参数hostname引发auditing event socket.gethostbyname。

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

引发不带参数的auditing event socket.gethostname。

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

socket. gethostbyaddr(* ip_address *)
- 返回一个三 Tuples(hostname, aliaslist, ipaddrlist)，其中* hostname 是响应给定 ip_address 的主要主机名， aliaslist 是该地址的替代主机名的列表(可能为空)，而 ipaddrlist *是 IPv4 /同一主机上同一接口的 v6 地址(很可能仅包含一个地址)。要查找完全合格的域名，请使用函数getfqdn()。 gethostbyaddr()支持 IPv4 和 IPv6.

用参数ip_address引发auditing event socket.gethostbyaddr。

socket. getnameinfo(* sockaddr ， flags *)
- 将套接字地址* sockaddr 转换为 2Tuples(host, port)。根据 flags 的设置，结果可以在 host 中包含标准域名或数字地址表示形式。同样， port *可以包含字符串端口名称或数字端口号。

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

有关* flags 的更多信息，请咨询* getnameinfo(3) *。

用参数sockaddr引发auditing event socket.getnameinfo。

socket. getprotobyname(协议名称)
- 将 Internet 协议名称(例如'icmp')转换为适合作为(可选的)第三个参数传递给socket()函数的常量。通常只有在“原始”模式(SOCK_RAW)中打开的套接字才需要使用此方法。对于正常的套接字模式，如果协议Ellipsis或为零，则会自动选择正确的协议。
socket. getservbyname(* servicename * [，* protocolname *])
- 将 Internet 服务名称和协议名称转换为该服务的端口号。可选协议名称(如果提供)应为'tcp'或'udp'，否则任何协议都将匹配。

用参数servicename，protocolname引发auditing event socket.getservbyname。

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

用参数port，protocolname引发auditing event socket.getservbyport。

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

从 3.7 版开始不推荐使用：如果* x *不适合 16 位无符号整数，但适合正 C int，则将其无声地截断为 16 位无符号整数。不推荐使用此静音截断Function，它将在将来的 Python 版本中引发异常。

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

socket. inet_aton(* ip_string *)
- 将 IPv4 地址从点分四进制字符串格式(例如'123.45.67.89')转换为 32 位压缩二进制格式，作为字节对象，长度为四个字符。与使用标准 C 库并且需要类型为struct in_addr的对象的程序进行对话时，此Function很有用。该对象是此函数返回的 32 位压缩二进制文件的 C 类型。

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

如果传递给此Function的 IPv4 地址字符串无效，则将引发OSError。请注意，确切有效的内容取决于inet_aton()的基础 C 实现。

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

socket. inet_ntoa(* packed_ip *)
- 将 32 位压缩的 IPv4 地址(长度为bytes-like object的四个字节)转换为其标准的点分四进制字符串表示形式(例如'123.45.67.89')。当与使用标准 C 库并且需要类型为struct in_addr的对象的程序进行对话时，此Function很有用。该对象是此函数作为参数的 32 位打包二进制数据的 C 类型。

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

在版本 3.5 中更改：现在接受可写bytes-like object。

socket. inet_pton(* address_family ， ip_string *)
- 将 IP 地址从其特定于家庭的字符串格式转换为压缩的二进制格式。当库或网络协议调用类型为struct in_addr(类似于inet_aton())或struct in6_addr的对象时，inet_pton()很有用。

address_family 支持的值当前为AF_INET和AF_INET6。如果 IP 地址字符串 ip_string 无效，则将引发OSError。请注意，确切有效的内容取决于 address_family *的值和inet_pton()的基础实现。

Availability：Unix(可能不是所有平台)，Windows。

在版本 3.4 中更改：添加了 Windows 支持

socket. inet_ntop(* address_family ， packed_ip *)
- 将打包的 IP 地址(某个字节的bytes-like object)转换为其标准的，特定于家庭的字符串表示形式(例如'7.10.0.5'或'5aef:2b::8')。当库或网络协议返回类型为struct in_addr(类似于inet_ntoa())或struct in6_addr的对象时，inet_ntop()很有用。

address_family 支持的值当前为AF_INET和AF_INET6。如果字节对象 packed_ip *对于指定的地址系列而言不是正确的长度，则将引发ValueError。 OSError因调用inet_ntop()的错误而引发。

Availability：Unix(可能不是所有平台)，Windows。

在版本 3.4 中更改：添加了 Windows 支持

在版本 3.5 中更改：现在接受可写bytes-like object。

socket. CMSG_LEN(* length *)
- 返回带有给定* length 的关联数据的辅助数据项的总长度，而无需尾随填充。此值通常可以用作recvmsg()接收单个辅助数据项的缓冲区大小，但是 RFC 3542要求可移植的应用程序使用CMSG_SPACE()并因此包括填充空间，即使该项将是缓冲区中的最后一个。如果 length *超出值的允许范围，则加OverflowError。

Availability：大多数 Unix 平台，可能还有其他平台。

版本 3.3 中的新Function。

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

请注意，某些系统可能不提供此Function就支持辅助数据。还应注意，使用此Function的结果来设置缓冲区大小可能不会精确地限制可以接收的辅助数据量，因为其他数据可能会适合填充区域。

Availability：大多数 Unix 平台，可能还有其他平台。

版本 3.3 中的新Function。

socket. getdefaulttimeout ( )
- 返回新套接字对象的默认超时(以秒为单位)(Float)。值None表示新的套接字对象没有超时。首次导入套接字模块时，默认值为None。
socket. setdefaulttimeout(* timeout *)
- 为新的套接字对象设置默认超时(以秒为单位)(Float)。首次导入套接字模块时，默认值为None。有关可能的值及其各自的含义，请参见settimeout()。
socket. sethostname(* name *)
- 将机器的主机名设置为* name *。如果您没有足够的权限，这将引发OSError。

用参数name引发auditing event socket.sethostname。

Availability: Unix.

版本 3.3 中的新Function。

socket. if_nameindex ( )
- 返回网络接口信息(索引 int，名称字符串)Tuples 的列表。 OSError，如果系统调用失败。

Availability：Unix，Windows。

版本 3.3 中的新Function。

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

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

Availability：Unix，Windows。

版本 3.3 中的新Function。

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

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

Availability：Unix，Windows。

版本 3.3 中的新Function。

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

Socket Objects

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

在版本 3.2 中更改：添加了对context manager协议的支持。退出上下文 Management 器等效于调用close()。

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

新创建的套接字是non-inheritable。

在版本 3.4 中进行了更改：套接字现在不可继承。

在版本 3.5 中进行了更改：如果系统调用被break并且 signal 处理程序没有引发异常，则该方法现在重试系统调用，而不是引发InterruptedError异常(有关原理，请参见 PEP 475)。

socket. bind(地址)
- 将套接字绑定到* address 。套接字必须尚未绑定。 ( address *的格式取决于地址系列-参见上文.)

用参数self，address引发auditing event socket.bind。

socket. close ( )
- 将 socket 标记为关闭。当来自makefile()的所有文件对象都关闭时，基础系统资源(例如文件 Descriptors)也会关闭。一旦发生这种情况，以后对套接字对象的所有操作将失败。远端将不再接收任何数据(在清除排队的数据之后)。

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

在版本 3.6 中更改：现在，如果在进行基础close()调用时发生错误，则引发OSError。

Note

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

socket. connect(地址)
- 连接到位于* address 的远程套接字。 ( address *的格式取决于地址系列-参见上文.)

如果连接被 signal break，则该方法将 await 直到连接完成，或者如果 signal 处理程序没有引发异常并且套接字正在阻塞或具有超时，则在超时时引发socket.timeout。对于非阻塞套接字，如果连接被 signal break(或 signal 处理程序引发的异常)，则该方法引发InterruptedError异常。

用参数self，address引发auditing event socket.connect。

在版本 3.5 中进行了更改：现在，该方法将 await 直到连接完成，而不是如果连接被 signal break，signal 处理程序不会引发异常并且套接字正在阻塞或具有超时(请参见)，则不会引发InterruptedError异常。 PEP 475)。

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

用参数self，address引发auditing event socket.connect。

socket. detach ( )
- 将套接字对象置于关闭状态，而无需实际关闭基础文件 Descriptors。返回文件 Descriptors，并且可以将其重新用于其他目的。

3.2 版中的新Function。

socket. dup ( )
- 复制套接字。

新创建的套接字是non-inheritable。

在版本 3.4 中进行了更改：套接字现在不可继承。

socket. fileno ( )
- 返回套接字的文件 Descriptors(一个小整数)，如果失败，则返回-1.这对select.select()很有用。

在 Windows 下，不能在可以使用文件 Descriptors 的地方使用此方法返回的小整数(例如os.fdopen())。 Unix 没有此限制。

socket. get_inheritable ( )
- 获取套接字文件 Descriptors 或套接字句柄的inheritable flag：如果套接字可以在子进程中继承，则返回True，否则不能返回False。

3.4 版的新Function。

socket. getpeername ( )
- 返回套接字连接到的远程地址。例如，这对于查找远程 IPv4/v6 套接字的端口号很有用。 (返回的地址格式取决于地址系列-参见上文.)在某些系统上，不支持此Function。
socket. getsockname ( )
- 返回套接字自己的地址。例如，这对于查找 IPv4/v6 套接字的端口号很有用。 (返回的地址格式取决于地址系列-参见上文.)
socket. getsockopt(* level ， optname * [，* buflen *])
- 返回给定套接字选项的值(请参见 Unix 手册页* getsockopt(2) )。所需的符号常量(SO_*等)在此模块中定义。如果不存在 buflen ，则假定使用整数选项，并且该整数值由函数返回。如果存在 buflen *，则它指定用于接收选项的缓冲区的最大长度，并且此缓冲区作为字节对象返回。由调用者决定对缓冲区的内容进行解码(有关对编码为字节字符串的 C 结构进行解码的方法，请参见可选的内置模块struct)。
socket. getblocking ( )
- 如果套接字处于阻塞模式，则返回True；如果处于非阻塞模式，则返回False。

这等效于检查socket.gettimeout() == 0。

3.7 版中的新Function。

socket. gettimeout ( )
- 返回与套接字操作关联的超时(以秒为单位)(浮点数)；如果未设置超时，则返回None。这反映了对setblocking()或settimeout()的最后一次呼叫。
socket. ioctl(* control ， option *)
- - Platform
  - Windows

ioctl()方法是 WSAIoctl 系统接口的受限接口。有关更多信息，请参考Win32 documentation。

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

当前仅支持以下控制代码：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 *)
- 返回与套接字关联的file object。返回的确切类型取决于makefile()给出的参数。这些参数的解释方式与内置open()函数相同，唯一受支持的* mode *值是'r'(默认值)，'w'和'b'。

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

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

Note

在 Windows 上，不能在期望带有文件 Descriptors 的文件对象(例如subprocess.Popen()的流参数)使用makefile()创建的类似文件的对象。

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

Note

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

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

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

socket. recvmsg(* bufsize * [，* ancbufsize * [，* flags *]])
- 从套接字接收普通数据(最多* bufsize *个字节)和辅助数据。 * ancbufsize *参数设置用于接收辅助数据的内部缓冲区的大小(以字节为单位)。它默认为 0，表示将不会接收任何辅助数据。可以使用CMSG_SPACE()或CMSG_LEN()来计算辅助数据的适当缓冲区大小，并且不适合缓冲区的项目可能会被截断或丢弃。 * flags *参数默认为 0，与recv()的含义相同。

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

在某些系统上，sendmsg()和recvmsg()可用于passAF_UNIX套接字在进程之间传递文件 Descriptors。使用此Function时(通常仅限于SOCK_STREAM套接字)，recvmsg()将以其辅助数据形式返回(socket.SOL_SOCKET, socket.SCM_RIGHTS, fds)的项目，其中* fds *是bytes对象，该对象将新文件 Descriptors 表示为本机的二进制数组。 C int类型。如果recvmsg()在系统调用返回后引发异常，它将首先try关闭pass此机制接收到的所有文件 Descriptors。

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

在支持SCM_RIGHTS机制的系统上，以下函数将接收最多* maxfds *个文件 Descriptors，返回消息数据和包含 Descriptors 的列表(同时忽略意外条件，例如接收到无关的控制消息)。另请参见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)

Availability：大多数 Unix 平台，可能还有其他平台。

版本 3.3 中的新Function。

socket. recvmsg_into(* buffers * [，* ancbufsize * [，* flags *]])
- 以recvmsg()的方式从套接字接收普通数据和辅助数据，但是将非辅助数据分散到一系列缓冲区中，而不是返回新的字节对象。 * buffers *参数必须是导出可写缓冲区的对象(例如bytearray对象)的可迭代对象；它们将被连续的非辅助数据块填充，直到全部被写入或不再有缓冲区为止。os 可以在可以使用的缓冲区数上设置限制(sysconf()值SC_IOV_MAX)。 * ancbufsize 和 flags *参数的含义与recvmsg()相同。

返回值是一个四 Tuples：(nbytes, ancdata, msg_flags, address)，其中* nbytes 是写入缓冲区的非辅助数据的字节总数，而 ancdata ， msg_flags 和 address *与recvmsg()相同。

Example:

>>> 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---')]

Availability：大多数 Unix 平台，可能还有其他平台。

版本 3.3 中的新Function。

socket. recvfrom_into(* buffer * [，* nbytes * [，* flags *]])
- 从套接字接收数据，将其写入* buffer 而不是创建新的字节串。返回值是Pair(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()具有相同的含义。返回发送的字节数。应用程序负责检查所有数据是否已发送；如果仅传输了一些数据，则应用程序需要try传送其余数据。有关此主题的更多信息，请查阅套接字编程方法。

socket. sendall(* bytes * [，* flags *])
- 将数据发送到套接字。该套接字必须连接到远程套接字。可选的* flags 参数与上面的recv()具有相同的含义。与send()不同，此方法 continue 从* bytes *发送数据，直到发送完所有数据或发生错误为止。 None成功返回。如果出错，则会引发异常，并且无法确定成功发送了多少数据(如果有)。

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

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

用参数self，address引发auditing event socket.sendto。

socket. sendmsg(* buffers * [，* ancdata * [，* flags * [，* address *]]])
- 将普通数据和辅助数据发送到套接字，从一系列缓冲区中收集非辅助数据，并将其串联为一条消息。 * buffers *参数将非辅助数据指定为bytes-like objects(例如bytes对象)的可迭代值；os 可能会设置可使用的缓冲区数限制(sysconf()值SC_IOV_MAX)。 * ancdata 参数将辅助数据(控制消息)指定为零或多个 Tuples(cmsg_level, cmsg_type, cmsg_data)的可迭代形式，其中 cmsg_level 和 cmsg_type 是分别指定协议级别和协议特定类型的整数，而 cmsg_data *是一个存放相关数据的类似字节的对象。请注意，某些系统(特别是没有CMSG_SPACE()的系统)可能支持每个呼叫仅发送一条控制消息。 * flags 参数默认为 0，与send()的含义相同。如果提供了 address *而不是None，那么它将设置消息的目标地址。返回值是发送的非辅助数据的字节数。

在支持SCM_RIGHTS机制的系统上，以下函数passAF_UNIX套接字发送文件 Descriptors* 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))])

Availability：大多数 Unix 平台，可能还有其他平台。

用参数self，address引发auditing event socket.sendmsg。

版本 3.3 中的新Function。

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

Availability：Linux> = 2.6.38.

3.6 版的新Function。

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 版中的新Function。

socket. set_inheritable(可继承)
- 设置套接字文件 Descriptors 或套接字句柄的inheritable flag。

3.4 版的新Function。

socket. setblocking(* flag *)
- 设置套接字的阻止或非阻止模式：如果* flag *为 false，则将套接字设置为非阻止，否则设置为阻止模式。

此方法是某些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或bytes-like object。在后一种情况下，由调用方确保字节串包含正确的位(有关将 C 结构编码为字节串的方法，请参见可选的内置模块struct)。当 value 设置为None时，需要 optlen *参数。等效于使用optval=NULL和optlen=optlen调用setsockopt() C 函数。

在版本 3.5 中更改：现在接受可写bytes-like object。

在版本 3.6 中更改：添加了 setsockopt(level，optname，None，optlen：int)表单。

socket. shutdown(如何)
- 关闭连接的一半或一半。如果* how 是SHUT_RD，则不允许进一步接收。如果 how 是SHUT_WR，则不允许进一步发送。如果 how *是SHUT_RDWR，则不允许进一步发送和接收。
socket. share(* process_id *)
- 复制套接字，并准备将其与目标进程共享。目标进程必须带有* process_id *。然后，可以使用某种形式的进程间通信将结果字节对象传递给目标进程，并可以使用fromshare()在其中重新创建套接字。一旦调用此方法，就可以安全地关闭套接字，因为 os 已经为目标进程复制了该套接字。

Availability: Windows.

版本 3.3 中的新Function。

注意，没有方法read()或write()；请使用不带* flags 参数的recv()和send()。

套接字对象还具有与赋予socket构造函数的值相对应的这些(只读)属性。

socket. family
- 套接字家族。
socket. type
- 套接字类型。
socket. proto
- 套接字协议。

有关套接字超时的说明

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

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

Note

在 os 级别，处于* timeout 模式*的套接字在内部设置为非阻塞模式。同样，阻塞和超时模式在引用相同网络端点的文件 Descriptors 和套接字对象之间共享。如果，例如，此实施细节可能具有明显的后果。您决定使用套接字的fileno()。

超时和连接方法

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

超时和接受方法

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

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

Example

这是使用 TCP/IP 协议的四个最小示例程序：一台服务器，该服务器回显它收到的所有数据(仅为一个 Client 端提供服务)，以及一个使用它的 Client 端。请注意，服务器必须执行 Sequencessocket()，bind()，listen()，accept()(可能重复accept()以为多个 Client 端提供服务)，而 Client 端仅需要 Sequencessocket()，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 流量。Client 端将try连接到由于名称解析而返回的所有地址，并将流量发送到成功连接的第一个地址。

# 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 上使用原始套接字编写一个非常简单的网络嗅探器。该示例需要 Management 员特权才能修改接口：

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)

下一个示例显示如何使用套接字接口pass原始套接字协议与 CAN 网络通信。要将 CAN 与 BroadcastManagement 器协议结合使用，请打开带有以下内容的套接字：

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

在绑定(CAN_RAW)或连接(CAN_BCM)套接字之后，您可以照常在套接字对象上使用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状态的本地套接字，而不必 await 其自然超时到期。

Docs

Docs4dev

Title here

套接字—低级网络接口

Socket families

Module contents

Exceptions

Constants

Functions

Creating sockets

Other functions

Socket Objects

有关套接字超时的说明

超时和连接方法

超时和接受方法

Example