Socket低级网络连接

link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

套接字系列

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

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

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

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

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

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

版本3.7中已更改： 对于多播地址（具有 scopeid 有意义），地址可能不包含 %scope （或）部分。此信息是多余的，可以安全地省略（推荐）。 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 。
- 范围是一个 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 是表示网络接口名称的字符串。网络接口名称可用于接收来自此系列的所有网络接口的数据包。 (interface, ) AF_CAN 'can0' ''
- CAN_ISOTP protocol需要一个元组，其中两个附加参数都是无符号长整数，表示CAN标识符（标准或扩展）。 (interface, rx_addr, tx_addr)
字符串或元组用于该族的协议。字符串是使用动态分配的ID的内核控件的名称。如果已知内核控件的ID和单元号，或者使用了已注册的ID，则可以使用元组。 (id, unit) SYSPROTO_CONTROL PF_SYSTEM

版本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 在哪里。（例如）FreeBSD不支持此协议。 bdaddr bytes b'12:23:34:45:56:67'
AF_ALG 是一个基于Linux的基于套接字的内核加密接口。算法套接字配置有两到四个元素的元组，其中： (type, name [, feat [, mask]])
- 类型是算法类型为字符串，例如 aead ， hash ， skcipher 或 rng 。
- 名称是该算法的名称和操作模式为字符串，例如 sha256 ， hmac(sha256) ， cbc(aes) 或 drbg_nopr_ctr_aes256 。
- feat 和 mask 是无符号的32位整数。
可用性：Linux 2.6.38，某些算法类型需要更新的内核。

版本3.6中的新功能。
AF_VSOCK 允许虚拟机与其主机之间的通信。套接字表示为元组，其中上下文ID或CID和端口是整数。 (CID,port)

可用性：Linux> = 4.8 QEMU> = 2.8 ESX> = 4.0 ESX工作站> = 6.5。

版本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 - 可选的字节对象，指定硬件物理地址，其解释取决于设备。

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

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

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

该模块 socket 导出以下元素。

异常 socket. error

不推荐使用的别名 OSError 。

在版本3.3中更改： 以下 PEP 3151 ，这个类被别名了 OSError 。

异常 socket. herror

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

版本3.3中已更改： 此类已成为子类 OSError 。

异常 socket. gaierror

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

版本3.3中已更改： 此类已成为子类 OSError 。

异常 socket. timeout

OSError 当一个套接字发生超时时引发此异常的子类，该套接字通过事先调用 settimeout() （或隐式通过 setdefaulttimeout() ）启用了超时。附带的值是一个字符串，其值当前总是“超时”。

版本3.3中已更改： 此类已成为子类 OSError 。

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

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

也可以看看

安全文件描述符处理以获得更全面的解释。

可用性：Linux> = 2.6.27。

版本3.2中的新功能。

socket. SOMAXCONN

MSG_*

SOL_*

SCM_*

IPPROTO_*

IPPORT_*

INADDR_*

IPV6_*

EAI_*

TCP_*

这些形式的许多常量，在套接字和/或IP协议的Unix文档中都有记录，也在套接字模块中定义。它们通常用于socket对象的方法 setsockopt() 和 getsockopt() 方法。在大多数情况下，只定义Unix头文件中定义的那些符号; 对于一些符号，提供默认值。

改变在3.6版： SO_DOMAIN ， SO_PROTOCOL ， SO_PEERSEC ， SO_PASSSEC ， TCP_USER_TIMEOUT ， TCP_CONGESTION 添加。

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

版本3.7中已更改： TCP_NOTSENT_LOWAT 已添加。

在Windows中， TCP_KEEPIDLE ， TCP_KEEPINTVL 出现如果运行时Windows支持。

socket. AF_CAN

socket. PF_CAN

SOL_CAN_*

CAN_*

Linux文档中记录的这些表单的许多常量也在套接字模块中定义。

可用性：Linux> = 2.6.25。

版本3.3中的新功能。

socket. CAN_BCM

CAN_BCM_*

CAN协议族中的CAN_BCM是广播管理器（BCM）协议。Linux文档中记录的广播管理器常量也在套接字模块中定义。

可用性：Linux> = 2.6.25。

版本3.4中的新功能。

socket. CAN_RAW_FD_FRAMES

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

Linux常规文档中记录了此常量。

可用性：Linux> = 3.6。

版本3.5中的新功能。

socket. CAN_ISOTP

CAN协议系列中的CAN_ISOTP是ISO-TP（ISO 15765-2）协议。Linux文档中记录的ISO-TP常量。

可用性：Linux> = 2.6.25。

版本3.7中的新功能。

socket. AF_PACKET

socket. PF_PACKET

PACKET_*

Linux文档中记录的这些表单的许多常量也在套接字模块中定义。

可用性：Linux> = 2.2。

socket. AF_RDS

socket. PF_RDS

socket. SOL_RDS

RDS_*

Linux文档中记录的这些表单的许多常量也在套接字模块中定义。

可用性：Linux> = 2.6.30。

版本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内核加密的常量。

可用性：Linux> = 2.6.38。

版本3.6中的新功能。

socket. AF_VSOCK

socket. IOCTL_VM_SOCKETS_GET_LOCAL_CID

VMADDR*

SO_VM*

Linux主机/来宾通信的常量。

可用性：Linux> = 4.8。

版本3.7中的新功能。

socket. AF_LINK

可用性：BSD，OSX。

版本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. 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 。

如果指定了 fileno ，则会从指定的文件描述符中自动检测 family ， type 和 proto 的值。通过使用显式族，类型或原型参数调用函数，可以推翻自动检测。这仅影响Python表示的方式，例如 socket.getpeername() 实际OS资源的返回值，而不是。与之不同的是 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 位标志应用于 类型， 它们被清除，并且 socket.type 不会反映它们。它们仍然传递给底层系统socket（）调用。因此：：

sock = socket.socket（

socket.AF_INET，socket.SOCK_STREAM | socket.SOCK_NONBLOCK）

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

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 地址（2元组）的TCP服务，并返回套接字对象。这是一个更高层次的功能比：如果主机是一个非数字的主机名，它会尽力解决两个和，然后尝试连接到所有可能的地址，直到有一个连接成功。这样可以轻松编写与IPv4和IPv6兼容的客户端。 (host, port) socket.connect() AF_INET AF_INET6

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

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

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

socket. fromfd （ fd ， family ， type ， proto = 0 ）

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

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

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

socket. fromshare （数据）

根据从该 socket.share() 方法获得的数据实例化套接字。假设套接字处于阻塞模式。

可用性：Windows。

版本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 。通过传递 host 和 port None 的值，您可以传递给底层的C API。 NULL

该家族，类型和原参数可以以缩小返回的地址的列表中随意指定的。将零作为每个参数的值传递选择全部结果。该标志参数可以是一个或几个的 AI_* 常数，会影响结果的方式计算并返回。例如， AI_NUMERICHOST 将禁用域名解析，如果主机是域名，则会引发错误。

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

(family, type, proto, canonname, sockaddr)

在这些元组中， family ， type ， proto 都是整数，并且意味着传递给 socket() 函数。如果是 flags 参数的一部分， canonname 将是一个表示主机规范名称的字符串; 否则 canonname 将为空。 sockaddr 是一个描述套接字地址的元组，其格式取决于返回的族（一个2元组，一个4元组），并且意味着传递给该方法。 AI_CANONNAME (address, port) AF_INET (address, port, flow info, scope id) AF_INET6 socket.connect()

以下示例获取 example.org 端口80上假设的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))]
    socket.getfqdn（[ 名称] ） 
    返回的一个完全合格的域名名称。如果省略name或为空，则将其解释为本地主机。要查找完全限定名称，请gethostbyaddr()检查返回的主机名，然后检查主机的别名（如果可用）。选择包含句点的名字。如果没有完全限定的域名，gethostname()则返回返回的主机名 。 
    socket.gethostbyname（主机名） 
    将主机名转换为IPv4地址格式。IPv4地址以字符串形式返回，例如 '100.50.200.5'。如果主机名是IPv4地址本身，则返回不变。有关gethostbyname_ex()更完整的界面，请参阅。gethostbyname()不支持IPv6名称解析， getaddrinfo()应该用于IPv4 / v6双栈支持。 
    socket.gethostbyname_ex（主机名） 
    将主机名转换为IPv4地址格式，扩展接口。返回一个三元组，其中hostname是响应给定ip_address的主要主机名，aliaslist是同一地址的备用主机名的（可能为空）列表，ipaddrlist是同一主机上同一接口的IPv4地址列表（通常但不总是一个地址）。不支持IPv6名称解析，应该用于IPv4 / v6双栈支持。(hostname, aliaslist,ipaddrlist)gethostbyname_ex()getaddrinfo() 
    socket.gethostname（） 
    返回一个字符串，其中包含Python解释器当前正在执行的机器的主机名。 
    注意：gethostname()并不总是返回完全限定的域名; 使用getfqdn()了点。 
    socket.gethostbyaddr（ip_address ） 
    返回一个三元组，其中hostname是响应给定ip_address的主要主机名，aliaslist是同一地址的备用主机名的（可能为空）列表， ipaddrlist是同一接口上的IPv4 / v6地址列表主机（最有可能只包含一个地址）。要查找完全限定的域名，请使用该功能。支持IPv4和IPv6。(hostname, aliaslist,ipaddrlist)getfqdn()gethostbyaddr() 
    socket.getnameinfo（sockaddr，flags ） 
    将套接字地址sockaddr转换为2元组。根据标志的设置，结果可以包含主机中的完全限定域名或数字地址表示。同样，port可以包含字符串端口名称或数字端口号。(host, port) 
    对于IPv6地址，%scope如果sockaddr 包含有意义的scopeid，则附加到主机部分。通常这发生在多播地址上。 
    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库并需要类型对象的程序进行对话时，这非常有用，该对象是此函数返回的32位打包二进制文件的C类型。struct in_addr 
    inet_aton()也接受少于三个点的字符串; 有关详细信息，请参见Unix手册页inet（3）。 
    如果传递给此函数的IPv4地址字符串无效， OSError则会引发。请注意，确切的有效内容取决于底层的C实现inet_aton()。 
    inet_aton()不支持IPv6，inet_pton()应该用于IPv4 / v6双栈支持。 
    socket.inet_ntoa（packed_ip ） 
    将32位打包的IPv4地址（长度为4个字节的字节对象）转换为标准的点分四字符串表示形式（例如，“123.45.67.89”）。当与使用标准C库并需要类型对象的程序进行对话时，这非常有用，该对象是此函数用作参数的32位打包二进制数据的C类型。struct in_addr 
    如果传递给该函数的字节序列长度不是4个字节，OSError则会引发。inet_ntoa()不支持IPv6，inet_ntop()应该用于IPv4 / v6双栈支持。 
     在版本3.5中更改：现在接受可写的字节对象。 
    socket.inet_pton（address_family，ip_string ） 
    将IP地址从其特定于系列的字符串格式转换为打包的二进制格式。inet_pton()当库或网络协议调用类型（类似于 ）或类型的对象时，此选项很有用。struct in_addrinet_aton()struct in6_addr 
    当前和 支持的address_family值。如果IP地址字符串ip_string无效， 将被引发。请注意，确切的有效内容取决于address_family的值和底层实现 。AF_INETAF_INET6OSErrorinet_pton() 
    可用性：Unix（可能不是所有平台），Windows。 
     版本3.4中已更改：添加了Windows支持 
    socket.inet_ntop（address_family，packed_ip ） 
    将打包的IP地址（一些字节数的字节对象）转换为其标准的，特定于系列的字符串表示形式（例如，'7.10.0.5'或'5aef:2b::8'）。 inet_ntop()当库或网络协议返回类型（类似于）或 类型的对象时非常有用。struct in_addrinet_ntoa()struct in6_addr 
    当前和 支持的address_family值。如果字节对象packed_ip不是指定地址族的正确长度，则将引发。 因呼叫错误引发错误。AF_INETAF_INET6ValueErrorOSErrorinet_ntop() 
    可用性：Unix（可能不是所有平台），Windows。 
     版本3.4中已更改：添加了Windows支持 
     在版本3.5中更改：现在接受可写的字节对象。 
    socket.CMSG_LEN（长度） 
    返回具有给定长度的关联数据的辅助数据项的总长度，而不用尾随填充。此值通常可用作recvmsg()接收单个辅助数据项的缓冲区大小，但是RFC 3542要求使用便携式应用程序CMSG_SPACE()，因此包括填充空间，即使该项目将是缓冲区中的最后一项。OverflowError如果长度超出允许的值范围，则引发。 
    可用性：大多数Unix平台，可能还有其他。 
     版本3.3中的新功能。 
    socket.CMSG_SPACE（长度） 
    返回recvmsg()接收具有给定长度的关联数据的辅助数据项 所需的缓冲区大小，以及任何尾随填充。接收多个项所需的缓冲区空间是CMSG_SPACE() 其关联数据长度值的总和。OverflowError如果长度超出允许的值范围，则引发 。 
    请注意，某些系统可能在不提供此功能的情况下支持辅助数据。另请注意，使用此函数的结果设置缓冲区大小可能无法精确限制可接收的辅助数据量，因为其他数据可能能够适合填充区域。 
    可用性：大多数Unix平台，可能还有其他。 
     版本3.3中的新功能。 
    socket.getdefaulttimeout（） 
    返回新套接字对象的默认超时（以秒为单位）。值为None表示新套接字对象没有超时。首次导入套接字模块时，默认为None。 
    socket.setdefaulttimeout（超时） 
    设置新套接字对象的默认超时（以秒为单位）。首次导入套接字模块时，默认为None。请参阅 settimeout()可能的值及其各自的含义。 
    socket.sethostname（名字） 
    将计算机的主机名设置为name。OSError如果您没有足够的权利，这将引发一个 。 
    可用性：Unix。 
     版本3.3中的新功能。 
    socket.if_nameindex（） 
    返回网络接口信息列表（索引int，名称字符串）元组。 OSError如果系统调用失败。 
    可用性：Unix。 
     版本3.3中的新功能。 
    socket.if_nametoindex（if_name ） 
    返回与接口名称对应的网络接口索引号。 OSError如果不存在具有给定名称的接口。 
    可用性：Unix。 
     版本3.3中的新功能。 
    socket.if_indextoname（if_index ） 
    返回与接口索引号对应的网络接口名称。 OSError如果没有与给定索引的接口存在。 
    可用性：Unix。 
     版本3.3中的新功能。 
  套接字对象具有以下方法。除此之外 makefile()，这些对应于适用于套接字的Unix系统调用。 
   版本3.2中已更改：添加了对上下文管理器协议的支持。退出上下文管理器等同于调用close()。 
  socket.accept（） 
  接受连接。套接字必须绑定到一个地址并侦听连接。返回值是一对，其中conn是可用于在连接上发送和接收数据的 新套接字对象， address是绑定到连接另一端的套接字的地址。(conn, address) 
  新创建的套接字是不可继承的。




    
 
   版本3.4中已更改：套接字现在是不可继承的。 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.bind（地址） 
  将套接字绑定到地址。套接字必须尚未绑定。（地址格式取决于地址族 - 见上文。） 
  socket.close（） 
  标记插座已关闭。当所有文件对象makefile() 都关闭时，底层系统资源（例如文件描述符）也会关闭。一旦发生这种情况，套接字对象上的所有未来操作都将失败。远程端将不再接收数据（刷新排队数据后）。 
  套接字在被垃圾收集时会自动关闭，但建议close()明确使用它们，或者使用with它们周围的 语句。 
   在版本3.6中更改：OSError如果在进行基础close()调用时发生错误，则现在引发 。 
   close()释放与连接关联的资源，但不一定立即关闭连接。如果要及时关闭连接，shutdown() 请先致电close()。 
  socket.connect（地址） 
  连接到地址处的远程套接字。（地址格式取决于地址族 - 见上文。） 
  如果连接被信号中断，则该方法等待直到连接完成，或者socket.timeout如果信号处理程序没有引发异常并且套接字阻塞或超时，则等待超时。对于非阻塞套接字，InterruptedError如果连接被信号（或信号处理程序引发的异常）中断，则该方法引发 异常。 
   在版本3.5中更改：该方法现在等待连接完成而不是 InterruptedError在连接被信号中断时引发异常，信号处理程序不会引发异常并且套接字阻塞或超时（请参阅PEP 475的理由）。 
  socket.connect_ex（地址） 
  比如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，则它指定用于接收选项的缓冲区的最大长度，并且此缓冲区作为bytes对象返回。由调用者来解码缓冲区的内容（有关struct解码编码为字节字符串的C结构的方法，请参阅可选的内置模块）。 
  socket.getblocking（） 
  True如果套接字处于阻塞模式，False则返回，如果处于非阻塞状态。 
  这相当于检查。socket.gettimeout() == 0 
   版本3.7中的新功能。 
  socket.gettimeout（） 
  返回与套接字操作关联的超时（秒）（浮点数），或者None未设置超时。这反映了对setblocking()或的最后一次通话 settimeout()。 
  socket.ioctl（控制，选项） 
  平台： 视窗 
  该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版本：该积压参数现在是可选的。 
  socket.makefile（mode ='r'，buffering = None，*，encoding = None，errors = None，newline = None ） 
  返回与套接字关联的文件对象。确切的返回类型取决于给出的参数makefile()。open()除了唯一支持的模式值是'r'（默认）'w'和之外，这些参数的解释方式与内置函数的解释方式相同'b'。 
  套接字必须处于阻塞模式; 它可能有超时，但如果发生超时，文件对象的内部缓冲区可能会以不一致的状态结束。 
  关闭返回的文件对象makefile()将不会关闭原始套接字，除非已关闭所有其他文件对象并 socket.close()已在套接字对象上调用。 
   在Windows上，创建makefile()的类文件对象不能用于需要带文件描述符的文件对象的位置，例如的流参数subprocess.Popen()。 
  socket.recv（bufsize [，flags ] ） 
  从套接字接收数据。返回值是表示接收数据的字节对象。一次接收的最大数据量由bufsize指定。有关可选参数标志的含义，请参见Unix手册页recv（2） ; 它默认为零。 
   为了最好地匹配硬件和网络现实，bufsize的值 应该是2的相对较小的幂，例如4096。 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.recvfrom（bufsize [，flags ] ） 
  从套接字接收数据。返回值是一对 ，其中bytes是表示接收数据的字节对象，address是发送数据的套接字的地址。有关可选参数标志的含义，请参见Unix手册页 recv（2） ; 它默认为零。（地址格式取决于地址族 - 见上文。）(bytes, address) 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
   版本3.7中已更改：对于多播IPv6地址，第一个地址项不再包含 %scope部分。为了获得完整的IPv6地址使用getnameinfo()。 
  socket.recvmsg（bufsize [，ancbufsize [，flags ] ] ） 
  从套接字接收正常数据（最多bufsize字节）和辅助数据。所述ancbufsize参数设置在用于接收的辅助数据的内部缓冲区的字节大小; 它默认为0，表示不会收到任何辅助数据。可以使用CMSG_SPACE()或计算辅助数据的适当缓冲区大小 CMSG_LEN()，并且可以截断或丢弃不适合缓冲区的项目。该标志 参数默认为0，有用法相同recv()。 
  返回值是一个4元组：。该数据项是一个保持接收到的非辅助性的数据对象。该ancdata项是零个或多个元组的列表表示辅助数据（控制消息）接收：cmsg_level和 cmsg_type分别指定协议级和协议特定的类型整数，且cmsg_data是 保持相关联的数据对象。该msg_flags 项是按位或的各种标志指示在接收到的消息的条件; 有关详细信息，请参阅系统文档 如果接收套接字未连接，请寻址(data, ancdata, msg_flags,address)bytes(cmsg_level, cmsg_type, cmsg_data)bytes是发送套接字的地址，如果可用; 否则，其值未指定。 
  在某些系统，sendmsg()并且recvmsg()可以被用于在一个进程之间传递文件描述符AF_UNIX 插座。当使用此工具时（通常仅限于 SOCK_STREAM套接字），recvmsg()将在其辅助数据中返回表单项，其中fds是表示新文件描述符的对象，作为本机C 类型的二进制数组。如果在系统调用返回后引发异常，它将首先尝试关闭通过此机制接收的任何文件描述符。(socket.SOL_SOCKET, socket.SCM_RIGHTS, fds)bytesintrecvmsg() 
  某些系统不指示仅部分接收的辅助数据项的截断长度。如果某个项似乎超出缓冲区的末尾，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.fromstring(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
    return msg, list(fds)
  可用性：大多数Unix平台，可能还有其他。 
   版本3.3中的新功能。 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.recvmsg_into（buffers [，ancbufsize [，flags ] ] ） 
  从套接字接收正常数据和辅助数据，行为相同 recvmsg()，但将非辅助数据分散到一系列缓冲区而不是返回新的字节对象。所述 缓冲器参数必须是可写入的出口缓冲器（例如对象的可迭代bytearray的对象）; 这些将填充连续的非辅助数据块，直到它全部写入或没有更多的缓冲区。操作系统可以设置可以使用的缓冲区数量的限制（sysconf()值SC_IOV_MAX）。该ancbufsize和 标志参数的含义为相同recvmsg()。




    
 
  返回值是一个4元组：其中nbytes是写入缓冲区的非辅助数据的总字节数，而acdata， msg_flags和address是相同的。(nbytes, ancdata, 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')
>>> 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---')]
  可用性：大多数Unix平台，可能还有其他。 
   版本3.3中的新功能。 
  socket.recvfrom_into（buffer [，nbytes [，flags ] ] ） 
  从套接字接收数据，将其写入缓冲区而不是创建新的字节串。返回值是一对，其中nbytes是接收的字节数，address是发送数据的套接字的地址。有关可选参数标志的含义，请参见Unix手册页recv（2） ; 它默认为零。（地址格式 取决于地址族 - 见上文。）(nbytes, address) 
  socket.recv_into（buffer [，nbytes [，flags ] ] ） 
  从套接字接收最多nbytes个字节，将数据存储到缓冲区而不是创建新的字节串。如果未指定nbytes（或0），则接收最大为给定缓冲区中可用的大小。返回接收的字节数。有关可选参数标志的含义，请参见Unix手册页recv（2） ; 它默认为零。 
  socket.send（bytes [，flags ] ） 
  将数据发送到套接字。套接字必须连接到远程套接字。可选的flags参数与recv()上面的含义相同。返回发送的字节数。应用程序负责检查是否已发送所有数据; 如果仅传输了一些数据，则应用程序需要尝试传递剩余数据。有关该主题的更多信息，请参阅Socket Programming HOWTO。 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.sendall（bytes [，flags ] ） 
  将数据发送到套接字。套接字必须连接到远程套接字。可选的flags参数与recv()上面的含义相同。与send()此不同，此方法继续从字节发送数据，直到所有数据都已发送或发生错误。 None成功归还。出错时，会引发异常，并且无法确定成功发送了多少数据（如果有）。 
   版本3.5中已更改：每次成功发送数据时，套接字超时不再重置。套接字超时现在是发送所有数据的最大总持续时间。 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.sendto（字节，地址） 
  socket.sendto（字节，标志，地址） 
  将数据发送到套接字。套接字不应连接到远程套接字，因为目标套接字由地址指定。可选的flags 参数与recv()上面的含义相同。返回发送的字节数。（地址格式取决于地址族 - 见上文。） 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.sendmsg（buffers [，ancdata [，flags [，address ] ] ] ） 
  将正常和辅助数据发送到套接字，从一系列缓冲区收集非辅助数据并将其连接成单个消息。所述缓冲器参数指定为可迭代非辅助数据 等字节的对象 （例如，bytes对象）; 操作系统可以设置可以使用的缓冲区数量的限制（sysconf()值SC_IOV_MAX）。所述ancdata参数指定所述辅助数据（控制消息）作为零个或多个元组的迭代，其中cmsg_level和 cmsg_type分别指定协议级和协议特定的类型整数，且cmsg_data(cmsg_level,cmsg_type, cmsg_data)是一个类似字节的对象，保存相关数据。请注意，某些系统（特别是没有系统CMSG_SPACE()）可能支持每次调用只发送一个控制消息。该 标志参数默认为0，有用法相同 send()。如果提供了地址而不是None，则它设置消息的目标地址。返回值是发送的非辅助数据的字节数。 
  以下函数在支持该机制的系统 上通过套接字 发送文件描述符列表fds。另见。AF_UNIXSCM_RIGHTSrecvmsg() 
    import socket, array
def send_fds(sock, msg, fds):
    return sock.sendmsg([msg], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array("i", fds))])
  可用性：大多数Unix平台，可能还有其他。 
   版本3.3中的新功能。 
   在版本3.5中更改：如果系统调用中断且信号处理程序未引发异常，则该方法现在重试系统调用而不是引发InterruptedError异常（请参阅PEP 475的理由）。 
  socket.sendmsg_afalg（[ msg，] *，op [，iv [，assoclen [，flags ] ] ] ） 
  专业版sendmsg()的AF_ALG插座。设置模式，IV，AEAD关联数据长度和AF_ALG套接字标志。 
  可用性：Linux> = 2.6.38。 
   版本3.6中的新功能。 
  socket.sendfile（文件，偏移= 0，计数=无） 
  通过使用高性能发送文件直到达到EOF os.sendfile并返回已发送的总字节数。 file必须是以二进制模式打开的常规文件对象。如果 os.sendfile不可用（例如Windows）或文件不是常规文件send()将被使用。offset告诉从哪里开始读取文件。如果指定，count是要发送的总字节数，而不是发送文件直到达到EOF。文件位置在返回时更新，或者在出现错误的情况下更新，在这种情况下 file.tell()可以用来计算发送的字节数。套接字必须是SOCK_STREAM类型。不支持非阻塞套接字。 
   版本3.5中的新功能。 
  socket.set_inheritable（可继承） 
  设置套接字文件描述符或套接字句柄的可继承标志。 
   版本3.4中的新功能。 
  socket.setblocking（旗） 
  设置套接字的阻塞或非阻塞模式：如果flag为false，则套接字设置为非阻塞，否则设置为阻塞模式。 
  此方法是某些settimeout()调用的简写： 
  sock.setblocking(True) 相当于 sock.settimeout(None)
sock.setblocking(False) 相当于 sock.settimeout(0.0) 
   版本3.7中已更改：该方法不再应用SOCK_NONBLOCK标记 socket.type。 
  socket.settimeout（值） 
  阻止套接字操作设置超时。所述值参数可以是表达秒的非负的浮点数，或None。如果给出非零值，则timeout如果在操作完成之前已超过超时时间段值，则后续套接字操作将引发 异常。如果给出零，则套接字处于非阻塞模式。如果None给出，则套接字处于阻塞模式。 
  有关详细信息，请参阅有关套接字超时的说明。 
   版本3.7中已更改：该方法不再切换SOCK_NONBLOCK标记 socket.type。 
  socket.setsockopt（level，optname，value：int ） 
  socket.setsockopt（级别，optname，值：缓冲区） 
  socket.setsockopt（level，optname，None，optlen：int ） 
  设置给定套接字选项的值（参见Unix手册页 setsockopt（2））。所需的符号常量在socket模块（SO_*等）中定义 。该值可以是整数，也可以是 表示缓冲区None的字节对象。在后一种情况下，由调用者来确保bytestring包含适当的位（有关将structC结构编码为字节串的方法，请参阅可选的内置模块）。当value设置None为时，需要optlen参数。它相当于使用optval = NULL和optlen = optlen调用setsockopt C函数。 
   在版本3.5中更改：现在接受可写的字节对象。 
   在版本3.6中更改：添加了 setsockopt（level，optname，None，optlen：int）表单。 
  socket.shutdown（怎么样） 
  关闭连接的一半或两半。如果怎么是SHUT_RD，还接收被禁止。如果怎么是SHUT_WR，进一步将是不允许的。If 怎么是SHUT_RDWR，进一步发送和接收被禁止。 
  socket.share（process_id ） 
  复制套接字并准备与目标进程共享。必须为process_id提供目标进程。然后，可以使用某种形式的进程间通信将生成的字节对象传递给目标进程，并使用可以在那里重新创建套接字fromshare()。一旦调用了此方法，就可以安全地关闭套接字，因为操作系统已经为目标进程复制了它。 
  可用性：Windows。 
   版本3.3中的新功能。 
  请注意，没有方法read()或write(); 使用recv()和send()不使用 flags参数。 
  套接字对象也具有这些（只读）属性，这些属性对应于赋予socket构造函数的值。 
  socket.family 
  套接字系列。 
  socket.type 
  套接字类型。 
  socket.proto 
  套接字协议。 
  套接字超时的注意事项 
  套接字对象可以是以下三种模式之一：阻塞，非阻塞或超时。默认情况下，套接字始终以阻塞模式创建，但可以通过调用来更改setdefaulttimeout()。 
  在阻塞模式下，操作将阻塞直到完成或系统返回错误（例如连接超时）。
在非阻塞模式下，如果无法立即完成操作，则操作失败（不幸的是系统相关的错误）：来自的函数 select可用于了解套接字何时以及是否可用于读取或写入。
在超时模式下，如果无法在为套接字指定的超时内完成操作（它们引发timeout异常）或系统返回错误，则操作将失败。 
   在操作系统级别，超时模式下的套接字在内部设置为非阻塞模式。此外，阻塞和超时模式在文件描述符和引用同一网络端点的套接字对象之间共享。如果您决定使用fileno()套接字，则此实现细节可能会产生明显的后果。 
   超时和connect方法 
   该connect()操作也受超时设置的限制，一般建议settimeout() 在调用connect()或传递超时参数 之前调用create_connection()。但是，无论任何Python套接字超时设置如何，系统网络堆栈也可能返回其自身的连接超时错误。




    
 
   超时和accept方法 
   如果getdefaulttimeout()不是None，则该accept()方法返回的套接字继承该超时。否则，行为取决于侦听套接字的设置： 
   如果侦听套接字处于阻塞模式或超时模式，则返回的套接字accept()处于阻塞模式 ;
如果侦听套接字处于非阻塞模式，则返回的套接字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)
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)
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.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中），请参阅以下文章： 
   由Stuart Sechrest撰写的4.3BSD进程间通信教程
Samuel J. Leffler等人的高级4.3BSD进程间通信教程， 
   两者都在UNIX程序员手册，补充文档1（PS1：7和PS1：8部分）中。各种与套接字相关的系统调用的特定于平台的参考资料也是有关套接字语义细节的宝贵信息来源。对于Unix，请参阅手册页; 对于Windows，请参阅WinSock（或Winsock 2）规范。对于支持IPv6的API，读者可能希望参考RFC 3493标题为IPv6的基本套接字接口扩展。 
转载于:https://my.oschina.net/u/3612528/blog/3050928
 包socket提供了一种低级网络连接类型，该类型与Go的运行时网络轮询器集成在一起，以提供异步I / O和期限支持。 麻省理工学院许可。
 该软件包专注于利用BSD套接字系统调用API的类UNIX操作系统。 它旨在用作创建特定于操作系统的套接字包的基础，用于套接字家族，例如Linux的AF_NETLINK ， AF_PACKET或AF_VSOCK 。 此软件包不应直接在最终用户应用程序中使用。
 软件包套接字的任何使用都应由build标签保护，就像导入syscall或golang.org/x/sys软件包时一样。
				1. socket->accept->rcv(阻塞/非阻塞)->read/write(单线程\多线程）
2.socket0/socket1->select/poll/epoll->accept->rcv(阻塞/非阻塞)->read/write(单线程\多线程）
3.socket0/socket1->select/poll/epoll->accept->rcv(阻塞/非阻塞)->aio_read/write
				vsock
 软件包vsock提供了对Linux VM套接字（ AF_VSOCK ）的访问，以在虚拟机管理程序与其虚拟机之间进行通信。 麻省理工学院许可。
 有关VM套接字的更多信息，请有关博客。
转到版本支持
该软件包支持不同级别的功能，具体取决于编译期间使用的Go版本。 此程序包产生的Listener和Conn类型由非阻塞I / O支持，以便与Go 1.11+中的Go的运行时网络轮询器集成。 从Go 1.12+开始提供其他功能。 仅在仅阻止模式下才支持较旧的Go 1.10。
 可以在上找到支持的Go版本的完整功能列表。
此时，软件包vsock处于v1.0.0之前的状态。 所做的更改可能会影响此软件包及其生态系统中其他组件的导出API。
 如果您在应用程序中依赖此软件包，请在构建应用程序时使用Go模块。
要通过QEMU和virtio-vsock使用VM套接字，您必须具有：
				Linux Without Wires The Basics of Bluetooth
蓝牙技术用于短距离（1米至100米）的通信。 它是最广泛的无线技术，根据功率和通信范围分为多个类别
蓝牙是基于分组的协议，并具有主从结构。 它工作在2400MHz和2483.5MHz频率范围之间，并使用跳频扩频。 蓝牙将数据分成数据包并在79个指定的频道之一上发送。 每个通道具有1MHz的带宽。 蓝牙4.0
				Socket 是网络协议栈暴露给编程人员的 API，相比复杂的计算机网络协议，API 对关键操作和配置数据进行了抽象，简化了程序编程。        本文讲述的 socket 内容源自 Linux 发行版 centos 9 上的 man 工具，和其他平台（比如 os-x 及不同版本会有些出入）。本文主要对各 API 进行详细介绍，从而更好的理解 socket 编程。
2.头文件
Linux source code (v5.15.11) - Bootlin    Linux内核 在线源代码 查询函数定义和使用
	Linux Kernel(Android) 加密算法总结(一)（cipher、compress、digest）_万能的终端和网络-程序员宅基地 - 程序员宅基地

套接字系列

创建套接字

套接字超时的注意事项

超时和`connect`方法

超时和`accept`方法