ipaddress — IPv4/IPv6 操作库

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

ipaddress 提供在 IPv4 和 IPv6 地址和网络上创建、操作和操作的功能。

该模块中的函数和类可以直接处理与 IP 地址相关的各种任务，包括检查两台主机是否在同一个子网上，迭代特定子网中的所有主机，检查字符串是否代表有效IP 地址或网络定义等。

这是完整的模块 API 参考 - 有关概述和介绍，请参阅 ipaddress 模块的介绍。

3.3 版中的新功能。

便利工厂功能

ipaddress模块提供了工厂函数，方便创建IP地址、网络和接口：

ipaddress.ip_address(address)

根据作为参数传递的 IP 地址，返回 IPv4Address 或 IPv6Address 对象。可以提供 IPv4 或 IPv6 地址；默认情况下，小于 2**32 的整数将被视为 IPv4。如果 address 不代表有效的 IPv4 或 IPv6 地址，则会引发 ValueError。

>>> ipaddress.ip_address('192.168.0.1')
IPv4Address('192.168.0.1')
>>> ipaddress.ip_address('2001:db8::')
IPv6Address('2001:db8::')

ipaddress.ip_network(address, strict=True)

根据作为参数传递的 IP 地址，返回 IPv4Network 或 IPv6Network 对象。 address 是表示 IP 网络的字符串或整数。可以提供 IPv4 或 IPv6 网络；默认情况下，小于 2**32 的整数将被视为 IPv4。 strict 传递给 IPv4Network 或 IPv6Network 构造函数。如果 address 不代表有效的 IPv4 或 IPv6 地址，或者网络设置了主机位，则会引发 ValueError。

>>> ipaddress.ip_network('192.168.0.0/28')
IPv4Network('192.168.0.0/28')

ipaddress.ip_interface(address): 根据作为参数传递的 IP 地址，返回 IPv4Interface 或 IPv6Interface 对象。 address 是表示 IP 地址的字符串或整数。可以提供 IPv4 或 IPv6 地址；默认情况下，小于 2**32 的整数将被视为 IPv4。如果 address 不代表有效的 IPv4 或 IPv6 地址，则会引发 ValueError。

这些便利函数的一个缺点是需要同时处理 IPv4 和 IPv6 格式，这意味着错误消息提供的关于精确错误的信息最少，因为函数不知道是 IPv4 格式还是 IPv6 格式。可以通过直接调用适当的版本特定类构造函数来获得更详细的错误报告。

IP地址

地址对象

IPv4Address 和 IPv6Address 对象共享许多公共属性。一些仅对 IPv6 地址有意义的属性也由 IPv4Address 对象实现，以便更容易地编写正确处理两个 IP 版本的代码。地址对象是 hashable，因此它们可以用作字典中的键。

class ipaddress.IPv4Address(address)

构造一个 IPv4 地址。如果 address 不是有效的 IPv4 地址，则会引发 AddressValueError。

以下构成有效的 IPv4 地址：

十进制点表示法的字符串，由 0-255 范围内的四个十进制整数组成，用点分隔（例如 192.168.0.1）。每个整数代表地址中的一个八位字节（字节）。不允许使用前导零以防止与八进制符号混淆。
一个适合 32 位的整数。
一个整数，装入长度为 4 的 bytes 对象（最重要的八位字节在前）。

>>> ipaddress.IPv4Address('192.168.0.1')
IPv4Address('192.168.0.1')
>>> ipaddress.IPv4Address(3232235521)
IPv4Address('192.168.0.1')
>>> ipaddress.IPv4Address(b'\xC0\xA8\x00\x01')
IPv4Address('192.168.0.1')

3.8 版更改：允许使用前导零，即使在看起来像八进制表示法的模棱两可的情况下也是如此。

3.10 版更改：不再容忍前导零并被视为错误。 IPv4 地址字符串的解析与 glibc inet_pton() 一样严格。

在 3.9.5 版中更改：从 3.9.5 版开始，上述更改也包含在 Python 3.9 中。

在 3.8.12 版中更改：从 3.8.12 版开始，上述更改也包含在 Python 3.8 中。

version: 适当的版本号：4 用于 IPv4，6 用于 IPv6。

max_prefixlen

此版本的地址表示中的总位数：32 用于 IPv4，128 用于 IPv6。

前缀定义了地址中前导位的数量，用于比较以确定地址是否是网络的一部分。

compressed

exploded

以点分十进制表示法表示的字符串。表示中从不包含前导零。

由于 IPv4 没有为八位字节设置为零的地址定义速记符号，因此这两个属性始终与 IPv4 地址的 str(addr) 相同。公开这些属性可以更轻松地编写可以处理 IPv4 和 IPv6 地址的显示代码。

packed: 此地址的二进制表示 - 适当长度的 bytes 对象（最重要的八位字节在前）。这是 IPv4 的 4 个字节和 IPv6 的 16 个字节。

reverse_pointer

IP 地址的反向 DNS PTR 记录的名称，例如：

>>> ipaddress.ip_address("127.0.0.1").reverse_pointer
'1.0.0.127.in-addr.arpa'
>>> ipaddress.ip_address("2001:db8::1").reverse_pointer
'1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa'

这是可用于执行 PTR 查找的名称，而不是解析的主机名本身。

3.5 版中的新功能。

is_multicast: True 如果地址保留用于多播。请参阅 RFC 3171（对于 IPv4）或 RFC 2373（对于 IPv6）。

is_private: True 如果地址是为专用网络分配的。请参阅 iana-ipv4-special-registry（对于 IPv4）或 iana-ipv6-special-registry（对于 IPv6）。

is_global: True 如果地址分配给公共网络。请参阅 iana-ipv4-special-registry（对于 IPv4）或 iana-ipv6-special-registry（对于 IPv6）。

3.4 版中的新功能。

is_unspecified: True 如果地址未指定。请参阅 RFC 5735（对于 IPv4）或 RFC 2373（对于 IPv6）。

is_reserved: True 如果地址是 IETF 保留的。

is_loopback: True 如果这是一个环回地址。请参阅 RFC 3330（对于 IPv4）或 RFC 2373（对于 IPv6）。

is_link_local: True 如果地址是为链路本地使用保留的。参见 RFC 3927。

IPv4Address.__format__(fmt)

返回由显式格式字符串控制的 IP 地址的字符串表示形式。 fmt 可以是以下之一： 's'，默认选项，相当于 str(), 'b' 用于补零的二进制字符串, 'X' 或 'x' 表示大写或小写十六进制表示，或 'n'，相当于 'b' 表示 IPv4 地址和 'x'对于 IPv6。对于二进制和十六进制表示，可以使用形式说明符 '#' 和分组选项 '_'。 __format__ 由 format、str.format 和 f 弦使用。

>>> format(ipaddress.IPv4Address('192.168.0.1'))
'192.168.0.1'
>>> '{:#b}'.format(ipaddress.IPv4Address('192.168.0.1'))
'0b11000000101010000000000000000001'
>>> f'{ipaddress.IPv6Address("2001:db8::1000"):s}'
'2001:db8::1000'
>>> format(ipaddress.IPv6Address('2001:db8::1000'), '_X')
'2001_0DB8_0000_0000_0000_0000_0000_1000'
>>> '{:#_n}'.format(ipaddress.IPv6Address('2001:db8::1000'))
'0x2001_0db8_0000_0000_0000_0000_0000_1000'

3.9 版中的新功能。

class ipaddress.IPv6Address(address)

构造一个 IPv6 地址。如果 address 不是有效的 IPv6 地址，则会引发 AddressValueError。

以下构成有效的 IPv6 地址：

由八组四个十六进制数字组成的字符串，每组代表 16 位。组由冒号分隔。这描述了 exploded（普通）符号。字符串也可以通过各种方式压缩（速记符号）。有关详细信息，请参阅 RFC 4291。例如，"0000:0000:0000:0000:0000:0abc:0007:0def" 可以压缩为 "::abc:7:def"。

可选地，该字符串还可以有一个范围区域 ID，用后缀 %scope_id 表示。如果存在，范围 ID 必须非空，并且不能包含 %。有关详细信息，请参阅 RFC 4007。例如，fe80::1234%1 可能标识节点第一条链路上的地址 fe80::1234。
适合 128 位的整数。
一个整数，打包到一个 bytes 长度为 16 的大端对象中。

>>> ipaddress.IPv6Address('2001:db8::1000')
IPv6Address('2001:db8::1000')
>>> ipaddress.IPv6Address('ff02::5678%1')
IPv6Address('ff02::5678%1')

compressed

地址表示的简短形式，省略了组中的前导零，并且最长的完全由零组成的组序列折叠为单个空组。

这也是 str(addr) 为 IPv6 地址返回的值。

exploded

地址表示的长格式，包括所有前导零和完全由零组成的组。

以下属性和方法参见IPv4Address类的对应文档：

packed

reverse_pointer

version

max_prefixlen

is_multicast

is_private

is_global

is_unspecified

is_reserved

is_loopback

is_link_local: 3.4 新功能：is_global

is_site_local: True 如果地址是为站点本地使用保留的。请注意，站点本地地址空间已被 RFC 3879 弃用。使用 is_private 测试此地址是否在 RFC 4193 定义的唯一本地地址空间中。

ipv4_mapped: 对于似乎是 IPv4 映射地址（以 ::FFFF/96 开头）的地址，此属性将报告嵌入的 IPv4 地址。对于任何其他地址，此属性将为 None。

scope_id: 对于 RFC 4007 定义的范围地址，此属性将地址所属的地址范围的特定区域标识为字符串。当未指定范围区域时，此属性将为 None。

sixtofour: 对于由 RFC 3056 定义的 6to4 地址（以 2002::/16 开头）的地址，该属性将报告嵌入的 IPv4 地址。对于任何其他地址，此属性将为 None。

teredo: 对于由 RFC 4380 定义的似乎是 Teredo 地址（以 2001::/32 开头）的地址，该属性将报告嵌入的 (server, client) IP 地址一对。对于任何其他地址，此属性将为 None。

IPv6Address.__format__(fmt): 参考IPv4Address中对应的方法文档。

3.9 版中的新功能。

转换为字符串和整数

要与套接字模块等网络接口互操作，地址必须转换为字符串或整数。这是使用 str() 和 int() 内置函数处理的：

>>> str(ipaddress.IPv4Address('192.168.0.1'))
'192.168.0.1'
>>> int(ipaddress.IPv4Address('192.168.0.1'))
3232235521
>>> str(ipaddress.IPv6Address('::1'))
'::1'
>>> int(ipaddress.IPv6Address('::1'))
1

请注意，IPv6 范围地址将转换为没有范围区域 ID 的整数。

运营商

地址对象支持一些运算符。除非另有说明，运算符只能应用于兼容对象之间（即 IPv4 与 IPv4，IPv6 与 IPv6）。

比较运算符

地址对象可以与一组常用的比较运算符进行比较。具有不同范围区域 ID 的相同 IPv6 地址不相等。一些例子：

>>> IPv4Address('127.0.0.2') > IPv4Address('127.0.0.1')
True
>>> IPv4Address('127.0.0.2') == IPv4Address('127.0.0.1')
False
>>> IPv4Address('127.0.0.2') != IPv4Address('127.0.0.1')
True
>>> IPv6Address('fe80::1234') == IPv6Address('fe80::1234%1')
False
>>> IPv6Address('fe80::1234%1') != IPv6Address('fe80::1234%2')
True

算术运算符

整数可以添加到地址对象或从地址对象中减去。一些例子：

>>> IPv4Address('127.0.0.2') + 3
IPv4Address('127.0.0.5')
>>> IPv4Address('127.0.0.2') - 3
IPv4Address('126.255.255.255')
>>> IPv4Address('255.255.255.255') + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ipaddress.AddressValueError: 4294967296 (>= 2**32) is not permitted as an IPv4 address

IP 网络定义

IPv4Network 和 IPv6Network 对象提供了一种用于定义和检查 IP 网络定义的机制。网络定义由掩码和 网络地址 组成，因此定义了 IP 地址范围，当使用掩码进行掩码（二进制 AND）时，该 IP 地址范围等于网络地址。例如，具有掩码 255.255.255.0 和网络地址 192.168.1.0 的网络定义由 192.168.1.0 到 192.168.1.255 范围内的 IP 地址组成。

前缀、网络掩码和主机掩码

有几种等效的方法可以指定 IP 网络掩码。 prefix /<nbits> 是一种表示在网络掩码中设置了多少高阶位的符号。 网络掩码 是设置了一些高阶位的 IP 地址。因此前缀 /24 相当于 IPv4 中的网络掩码 255.255.255.0，或 IPv6 中的 ffff:ff00::。此外， 主机掩码 是 网络掩码 的逻辑倒数，有时用于（例如在 Cisco 访问控制列表中）表示网络掩码。 IPv4中相当于/24的主机掩码是0.0.0.255。

网络对象

地址对象实现的所有属性也由网络对象实现。此外，网络对象实现了额外的属性。所有这些在 IPv4Network 和 IPv6Network 之间都是通用的，所以为了避免重复，它们只记录在 IPv4Network 中。网络对象是 hashable，因此它们可以用作字典中的键。

class ipaddress.IPv4Network(address, strict=True)

构建 IPv4 网络定义。 address 可以是以下之一：

由 IP 地址和可选掩码组成的字符串，以斜杠 (/) 分隔。 IP 地址是网络地址，掩码可以是单个数字，即前缀，也可以是 IPv4 地址的字符串表示。如果是后者，则掩码如果以非零字段开头，则解释为 网络掩码 ，如果以零字段开头，则解释为 主机掩码 ，其中被视为 网络掩码 的全零掩码的唯一例外。如果没有提供掩码，则认为是 /32。

例如，以下地址规格等效：192.168.1.0/24、192.168.1.0/255.255.255.0和192.168.1.0/0.0.0.255。
一个适合 32 位的整数。这相当于一个单地址网络，网络地址为address，掩码为/32。
一个整数打包到一个 bytes 长度为 4 的对象中，大端。解释类似于整数地址。
地址描述和网络掩码的二元组，其中地址描述是字符串、32 位整数、4 字节压缩整数或现有 IPv4Address 对象；并且网络掩码是表示前缀长度的整数（例如 24) 或表示前缀掩码的字符串（例如 255.255.255.0）。

如果 address 不是有效的 IPv4 地址，则会引发 AddressValueError。如果掩码对 IPv4 地址无效，则会引发 NetmaskValueError。

如果 strict 是 True 并且在提供的地址中设置了主机位，则会引发 ValueError。否则，主机位被屏蔽以确定适当的网络地址。

除非另有说明，如果参数的 IP 版本与 self 不兼容，则所有接受其他网络/地址对象的网络方法都将引发 TypeError。

3.5 版更改：为 address 构造函数参数添加了二元组形式。

version

max_prefixlen: 参考IPv4Address中对应的属性文档。

is_multicast

is_private

is_unspecified

is_reserved

is_loopback

is_link_local: 如果这些属性对于网络地址和广播地址都为真，则这些属性对于整个网络也为真。

network_address: 网络的网络地址。网络地址和前缀长度共同唯一地定义了一个网络。

broadcast_address: 网络的广播地址。发送到广播地址的数据包应该被网络上的每个主机接收。

hostmask: 主机掩码，作为 IPv4Address 对象。

netmask: 网络掩码，作为 IPv4Address 对象。

with_prefixlen

compressed

exploded

网络的字符串表示形式，掩码采用前缀表示法。

with_prefixlen 和 compressed 始终与 str(network) 相同。 exploded 使用分解形式的网络地址。

with_netmask: 网络的字符串表示形式，掩码采用网络掩码表示法。

with_hostmask: 网络的字符串表示形式，掩码采用主机掩码表示法。

num_addresses: 网络中的地址总数。

prefixlen: 网络前缀的长度，以位为单位。

hosts()

返回网络中可用主机上的迭代器。可用主机是除了网络地址本身和网络广播地址之外的所有属于网络的IP地址。对于掩码长度为 31 的网络，网络地址和网络广播地址也包含在结果中。掩码为 32 的网络将返回一个包含单个主机地址的列表。

>>> list(ip_network('192.0.2.0/29').hosts())  
[IPv4Address('192.0.2.1'), IPv4Address('192.0.2.2'),
 IPv4Address('192.0.2.3'), IPv4Address('192.0.2.4'),
 IPv4Address('192.0.2.5'), IPv4Address('192.0.2.6')]
>>> list(ip_network('192.0.2.0/31').hosts())
[IPv4Address('192.0.2.0'), IPv4Address('192.0.2.1')]
>>> list(ip_network('192.0.2.1/32').hosts())
[IPv4Address('192.0.2.1')]

overlaps(other): True 如果该网络部分或全部包含在 other 或 other 全部包含在该网络中。

address_exclude(network)

计算从这个网络中删除给定的 network 所产生的网络定义。返回网络对象的迭代器。如果 network 未完全包含在此网络中，则引发 ValueError。

>>> n1 = ip_network('192.0.2.0/28')
>>> n2 = ip_network('192.0.2.1/32')
>>> list(n1.address_exclude(n2))  
[IPv4Network('192.0.2.8/29'), IPv4Network('192.0.2.4/30'),
 IPv4Network('192.0.2.2/31'), IPv4Network('192.0.2.0/32')]

subnets(prefixlen_diff=1, new_prefix=None)

加入以创建当前网络定义的子网，具体取决于参数值。 prefixlen_diff 是我们的前缀长度应该增加的量。 new_prefix 是子网所需的新前缀；它必须大于我们的前缀。必须设置 prefixlen_diff 和 new_prefix 中的一个且仅一个。返回网络对象的迭代器。

>>> list(ip_network('192.0.2.0/24').subnets())
[IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/25')]
>>> list(ip_network('192.0.2.0/24').subnets(prefixlen_diff=2))  
[IPv4Network('192.0.2.0/26'), IPv4Network('192.0.2.64/26'),
 IPv4Network('192.0.2.128/26'), IPv4Network('192.0.2.192/26')]
>>> list(ip_network('192.0.2.0/24').subnets(new_prefix=26))  
[IPv4Network('192.0.2.0/26'), IPv4Network('192.0.2.64/26'),
 IPv4Network('192.0.2.128/26'), IPv4Network('192.0.2.192/26')]
>>> list(ip_network('192.0.2.0/24').subnets(new_prefix=23))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    raise ValueError('new prefix must be longer')
ValueError: new prefix must be longer
>>> list(ip_network('192.0.2.0/24').subnets(new_prefix=25))
[IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/25')]

supernet(prefixlen_diff=1, new_prefix=None)

包含此网络定义的超网，取决于参数值。 prefixlen_diff 是我们的前缀长度应该减少的数量。 new_prefix 是超网所需的新前缀；它必须小于我们的前缀。必须设置 prefixlen_diff 和 new_prefix 中的一个且仅一个。返回单个网络对象。

>>> ip_network('192.0.2.0/24').supernet()
IPv4Network('192.0.2.0/23')
>>> ip_network('192.0.2.0/24').supernet(prefixlen_diff=2)
IPv4Network('192.0.0.0/22')
>>> ip_network('192.0.2.0/24').supernet(new_prefix=20)
IPv4Network('192.0.0.0/20')

subnet_of(other)

如果此网络是 other 的子网，则返回 True。

>>> a = ip_network('192.168.1.0/24')
>>> b = ip_network('192.168.1.128/30')
>>> b.subnet_of(a)
True

3.7 版中的新功能。

supernet_of(other)

如果此网络是 other 的超网，则返回 True。

>>> a = ip_network('192.168.1.0/24')
>>> b = ip_network('192.168.1.128/30')
>>> a.supernet_of(b)
True

3.7 版中的新功能。

compare_networks(other)

将此网络与其他进行比较。在这个比较中，只考虑了网络地址；主机位不是。返回 -1、0 或 1。

>>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.2/32'))
-1
>>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.0/32'))
1
>>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.1/32'))
0

自 3.7 版起已弃用：它使用与“”相同的排序和比较算法

class ipaddress.IPv6Network(address, strict=True)

构建 IPv6 网络定义。 address 可以是以下之一：

由 IP 地址和可选前缀长度组成的字符串，以斜杠 (/) 分隔。 IP地址是网络地址，前缀长度必须是单个数字，前缀。如果未提供前缀长度，则认为是 /128。

请注意，不支持当前扩展的网络掩码。这意味着 2001:db00::0/24 是一个有效的参数，而 2001:db00::0/ffff:ff00:: 不是。
适合 128 位的整数。这相当于一个单地址网络，网络地址为address，掩码为/128。
一个整数，打包到一个 bytes 长度为 16 的大端对象中。解释类似于整数地址。
地址描述和网络掩码的二元组，其中地址描述是字符串、128 位整数、16 字节压缩整数或现有 IPv6Address 对象；并且网络掩码是一个表示前缀长度的整数。

如果 address 不是有效的 IPv6 地址，则会引发 AddressValueError。如果掩码对 IPv6 地址无效，则会引发 NetmaskValueError。

如果 strict 是 True 并且在提供的地址中设置了主机位，则会引发 ValueError。否则，主机位被屏蔽以确定适当的网络地址。

3.5 版更改：为 address 构造函数参数添加了二元组形式。

version

max_prefixlen

is_multicast

is_private

is_unspecified

is_reserved

is_loopback

is_link_local

network_address

broadcast_address

hostmask

netmask

with_prefixlen

compressed

exploded

with_netmask

with_hostmask

num_addresses

prefixlen

hosts(): 返回网络中可用主机上的迭代器。可用主机是属于网络的所有 IP 地址，但 Subnet-Router 任播地址除外。对于掩码长度为 127 的网络，子网路由器任播地址也包含在结果中。掩码为 128 的网络将返回一个包含单个主机地址的列表。

overlaps(other)

address_exclude(network)

subnets(prefixlen_diff=1, new_prefix=None)

supernet(prefixlen_diff=1, new_prefix=None)

subnet_of(other)

supernet_of(other)

compare_networks(other): 参考IPv4Network中对应的属性文档。

is_site_local: 如果网络地址和广播地址都为真，则这些属性对于整个网络也为真。

运营商

网络对象支持一些运算符。除非另有说明，运算符只能应用于兼容对象之间（即 IPv4 与 IPv4，IPv6 与 IPv6）。

逻辑运算符

网络对象可以与通常的逻辑运算符集进行比较。网络对象首先按网络地址排序，然后按网络掩码排序。

迭代

可以迭代网络对象以列出属于网络的所有地址。对于迭代，返回 all 主机，包括不可用的主机（对于可用的主机，使用 hosts() 方法）。一个例子：

>>> for addr in IPv4Network('192.0.2.0/28'):
...     addr
...
IPv4Address('192.0.2.0')
IPv4Address('192.0.2.1')
IPv4Address('192.0.2.2')
IPv4Address('192.0.2.3')
IPv4Address('192.0.2.4')
IPv4Address('192.0.2.5')
IPv4Address('192.0.2.6')
IPv4Address('192.0.2.7')
IPv4Address('192.0.2.8')
IPv4Address('192.0.2.9')
IPv4Address('192.0.2.10')
IPv4Address('192.0.2.11')
IPv4Address('192.0.2.12')
IPv4Address('192.0.2.13')
IPv4Address('192.0.2.14')
IPv4Address('192.0.2.15')

作为地址容器的网络

网络对象可以充当地址的容器。一些例子：

>>> IPv4Network('192.0.2.0/28')[0]
IPv4Address('192.0.2.0')
>>> IPv4Network('192.0.2.0/28')[15]
IPv4Address('192.0.2.15')
>>> IPv4Address('192.0.2.6') in IPv4Network('192.0.2.0/28')
True
>>> IPv4Address('192.0.3.6') in IPv4Network('192.0.2.0/28')
False

接口对象

接口对象是 hashable，因此它们可以用作字典中的键。

class ipaddress.IPv4Interface(address)

构建IPv4接口。 address 的含义与 IPv4Network 的构造函数中的含义相同，只是始终接受任意主机地址。

IPv4Interface 是 IPv4Address 的子类，因此它继承了该类的所有属性。此外，还有以下属性可用：

ip

没有网络信息的地址 (IPv4Address)。

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.ip
IPv4Address('192.0.2.5')

network

此接口所属的网络 (IPv4Network)。

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.network
IPv4Network('192.0.2.0/24')

with_prefixlen

带有前缀表示法掩码的接口的字符串表示形式。

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.with_prefixlen
'192.0.2.5/24'

with_netmask

作为网络掩码的网络接口的字符串表示。

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.with_netmask
'192.0.2.5/255.255.255.0'

with_hostmask

以网络为主机掩码的接口的字符串表示形式。

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.with_hostmask
'192.0.2.5/0.0.0.255'

class ipaddress.IPv6Interface(address)

构建IPv6接口。 address 的含义与 IPv6Network 的构造函数中的含义相同，只是始终接受任意主机地址。

IPv6Interface 是 IPv6Address 的子类，因此它继承了该类的所有属性。此外，还有以下属性可用：

ip

network

with_prefixlen

with_netmask

with_hostmask: 参考IPv4Interface中对应的属性文档。

运营商

接口对象支持一些运算符。除非另有说明，运算符只能应用于兼容对象之间（即 IPv4 与 IPv4，IPv6 与 IPv6）。

逻辑运算符

接口对象可以与通常的逻辑运算符集进行比较。

对于相等比较（== 和 !=），IP 地址和网络必须相同才能使对象相等。接口不会与任何地址或网络对象进行比较。

对于订购（<、> 等），规则是不同的。可以比较具有相同 IP 版本的接口和地址对象，并且地址对象将始终排在接口对象之前。两个接口对象首先通过它们的网络进行比较，如果它们相同，则通过它们的 IP 地址进行比较。

其他模块级功能

该模块还提供以下模块级功能：

ipaddress.v4_int_to_packed(address)

以网络（大端）顺序将地址表示为 4 个压缩字节。 address 是 IPv4 IP 地址的整数表示。如果整数为负数或太大而无法成为 IPv4 IP 地址，则会引发 ValueError。

>>> ipaddress.ip_address(3221225985)
IPv4Address('192.0.2.1')
>>> ipaddress.v4_int_to_packed(3221225985)
b'\xc0\x00\x02\x01'

ipaddress.v6_int_to_packed(address): 以网络（大端）顺序将地址表示为 16 个压缩字节。 address 是 IPv6 IP 地址的整数表示。如果整数为负数或太大而无法成为 IPv6 IP 地址，则会引发 ValueError。

ipaddress.summarize_address_range(first, last)

返回给定第一个和最后一个 IP 地址的汇总网络范围的迭代器。 first 是范围内的第一个 IPv4Address 或 IPv6Address，而 last 是最后一个 IPv4Address 或范围内的 IPv6Address。如果 first 或 last 不是 IP 地址或版本不同，则会引发 TypeError。如果 last 不大于 first 或 first 地址版本不是 4 或 6，则会引发 ValueError。

>>> [ipaddr for ipaddr in ipaddress.summarize_address_range(
...    ipaddress.IPv4Address('192.0.2.0'),
...    ipaddress.IPv4Address('192.0.2.130'))]
[IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'), IPv4Network('192.0.2.130/32')]

ipaddress.collapse_addresses(addresses)

返回折叠的 IPv4Network 或 IPv6Network 对象的迭代器。 addresses 是 IPv4Network 或 IPv6Network 对象的迭代器。如果 addresses 包含混合版本对象，则会引发 TypeError。

>>> [ipaddr for ipaddr in
... ipaddress.collapse_addresses([ipaddress.IPv4Network('192.0.2.0/25'),
... ipaddress.IPv4Network('192.0.2.128/25')])]
[IPv4Network('192.0.2.0/24')]

ipaddress.get_mixed_type_key(obj)

返回一个适合在网络和地址之间排序的键。默认情况下，地址和网络对象不可排序；它们根本不同，所以表达式：

IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')

没有意义。但是，有时您可能希望 ipaddress 无论如何对这些进行排序。如果您需要这样做，您可以将此函数用作 sorted() 的 key 参数。

obj 是网络或地址对象。

自定义异常

为了支持来自类构造函数的更具体的错误报告，该模块定义了以下异常：

exception ipaddress.AddressValueError(ValueError): 与地址相关的任何值错误。

exception ipaddress.NetmaskValueError(ValueError): 与网络掩码相关的任何值错误。

ipaddress — IPv4/IPv6 操作库 — Python 文档

目录

ipaddress — IPv4/IPv6 操作库

便利工厂功能

IP地址

地址对象

转换为字符串和整数

运营商

比较运算符

算术运算符

IP 网络定义

前缀、网络掩码和主机掩码

网络对象

运营商

逻辑运算符

迭代

作为地址容器的网络

接口对象

运营商

逻辑运算符

其他模块级功能

自定义异常