`ipaddress` — IPv4/IPv6 操作库¶

ipaddress 提供了创建、操作和处理 IPv4 和 IPv6 地址和网络的功能。

此模块中的函数和类使得处理与 IP 地址相关的各种任务变得简单，包括检查两个主机是否在同一子网上、迭代特定子网中的所有主机、检查字符串是否表示有效的 IP 地址或网络定义，等等。

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

在 3.3 版本中添加。

便捷工厂函数¶

ipaddress 模块提供了便捷的工厂函数来创建 IP 地址、网络和接口。

ipaddress.ip_address(address)¶

返回一个 IPv4Address 或 IPv6Address 对象，具体取决于作为参数传递的 IP 地址。可以提供 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)¶

返回一个 IPv4Network 或 IPv6Network 对象，具体取决于作为参数传递的 IP 地址。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)¶: 返回一个 IPv4Interface 或 IPv6Interface 对象，具体取决于作为参数传递的 IP 地址。address 是一个表示 IP 地址的字符串或整数。可以提供 IPv4 或 IPv6 地址；小于 2**32 的整数默认会被认为是 IPv4。如果 address 不表示有效的 IPv4 或 IPv6 地址，则会引发 ValueError。

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

IP 地址¶

地址对象¶

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

class ipaddress.IPv4Address(address)¶

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

以下构成有效的 IPv4 地址

一个十进制点分表示法的字符串，由四个十进制整数组成，范围为 0–255（包括 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.9.5 版本中更改: 不再容忍前导零，并将其视为错误。现在，IPv4 地址字符串的解析与 glibc inet_pton() 一样严格。

version¶: 相应的版本号：IPv4 为 4，IPv6 为 6。

max_prefixlen¶

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

前缀定义了地址中用于确定地址是否属于网络的前导位数。

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¶

如果该地址被定义为 iana-ipv4-special-registry（对于 IPv4）或 iana-ipv6-special-registry（对于 IPv6）指定为非全局可达，则为 True，但有以下例外

共享地址空间（100.64.0.0/10）的 is_private 为 False
对于 IPv4 映射的 IPv6 地址，is_private 值由底层 IPv4 地址的语义确定，并且满足以下条件（请参阅 IPv6Address.ipv4_mapped）
```
address.is_private == address.ipv4_mapped.is_private
```

除了共享地址空间（100.64.0.0/10 范围）它们都为 False 之外，is_private 的值与 is_global 相反。

在 3.13 版本中更改: 修复了一些误报和漏报。

192.0.0.0/24 被认为是私有的，但 192.0.0.9/32 和 192.0.0.10/32 除外（以前：只有 192.0.0.0/29 子范围被认为是私有的）。
64:ff9b:1::/48 被认为是私有的。
2002::/16 被认为是私有的。
2001::/23 中存在例外（否则被认为是私有的）：2001:1::1/128、2001:1::2/128、2001:3::/32、2001:4:112::/48、2001:20::/28、2001:30::/28。这些例外不被认为是私有的。

is_global¶

如果该地址被 iana-ipv4-special-registry（对于 IPv4）或 iana-ipv6-special-registry（对于 IPv6）定义为全局可达，则为 True，但有以下例外

对于 IPv4 映射的 IPv6 地址，is_private 值由底层 IPv4 地址的语义确定，并且满足以下条件（请参阅 IPv6Address.ipv4_mapped）

address.is_global == address.ipv4_mapped.is_global

除了共享地址空间（100.64.0.0/10 范围）它们都为 False 之外，is_global 的值与 is_private 相反。

在 3.4 版本中添加。

在 3.13 版本中更改: 修复了一些误报和漏报，详情请参阅 is_private。

is_unspecified¶: 如果该地址未指定，则为 True。请参阅 RFC 5735 (对于 IPv4) 或 RFC 2373 (对于 IPv6)。

is_reserved¶: 如果该地址是 IETF 保留的，则为 True。

is_loopback¶: 如果这是一个环回地址，则为 True。请参阅 RFC 3330 (对于 IPv4) 或 RFC 2373 (对于 IPv6)。

is_link_local¶: 如果该地址保留用于链路本地使用，则为 True。请参阅 RFC 3927。

ipv6_mapped¶: 表示 IPv4 映射的 IPv6 地址的 IPv4Address 对象。请参阅 RFC 4291。

在 3.13 版本中添加。

IPv4Address.__format__(fmt)¶

返回 IP 地址的字符串表示形式，由显式格式字符串控制。fmt 可以是以下之一：'s'，默认选项，等效于 str()，'b' 表示零填充的二进制字符串，'X' 或 'x' 表示大写或小写十六进制表示形式，或者 'n'，它对于 IPv4 地址等效于 'b'，对于 IPv6 则等效于 'x'。对于二进制和十六进制表示形式，可以使用形式说明符 '#' 和分组选项 '_'。__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 位。这些组由冒号分隔。这描述了展开（长格式）表示法。该字符串也可以通过各种方式进行压缩（简写表示法）。有关详细信息，请参阅 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 位的整数。
一个打包到长度为 16 的 bytes 对象中的整数，大端字节序。

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

compressed¶

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

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

exploded¶

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

对于以下属性和方法，请参阅 IPv4Address 类的相应文档

packed¶

reverse_pointer¶

version¶

max_prefixlen¶

is_multicast¶

is_private¶

is_global¶: 在 3.4 版本中添加。

is_unspecified¶

is_reserved¶

is_loopback¶

is_link_local¶

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 版本中添加。

转换为字符串和整数¶

为了与网络接口（如 socket 模块）互操作，地址必须转换为字符串或整数。这可以使用 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）进行掩码时，该范围等于网络地址。例如，掩码为 255.255.255.0 且网络地址为 192.168.1.0 的网络定义由 192.168.1.0 到 192.168.1.255 包含范围内的 IP 地址组成。

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

有几种等效的方式来指定 IP 网络掩码。前缀 /<nbits> 是一种表示网络掩码中设置了多少高位位的表示法。网络掩码是一个设置了多个高位位的 IP 地址。因此，前缀 /24 等效于 IPv4 中的网络掩码 255.255.255.0 或 IPv6 中的 ffff:ff00::。此外，主机掩码是网络掩码的逻辑反转，有时用于（例如，在 Cisco 访问控制列表中）表示网络掩码。与 IPv4 中的 /24 等效的主机掩码是 0.0.0.255。

网络对象¶

地址对象实现的所有属性也由网络对象实现。此外，网络对象还实现了其他属性。所有这些在 IPv4Network 和 IPv6Network 之间是通用的，因此为了避免重复，它们仅针对 IPv4Network 进行了文档化。网络对象是可哈希的，因此它们可以用作字典中的键。

class ipaddress.IPv4Network(address, strict=True)¶

构造一个 IPv4 网络定义。address 可以是以下之一

一个字符串，由 IP 地址和可选的掩码组成，并用斜杠（/）分隔。IP 地址是网络地址，掩码可以是单个数字，这意味着它是前缀，也可以是 IPv4 地址的字符串表示形式。如果是后者，则如果掩码以非零字段开头，则将其解释为网络掩码，如果掩码以零字段开头，则将其解释为主机掩码，唯一的例外是全零掩码，将其视为网络掩码。如果没有提供掩码，则将其视为 /32。

例如，以下 address 规范是等效的：192.168.1.0/24、192.168.1.0/255.255.255.0 和 192.168.1.0/0.0.0.255。
一个适合 32 位的整数。这等效于单地址网络，网络地址为 address，掩码为 /32。
一个以大端序打包到长度为 4 的 bytes 对象中的整数。其解释与整数 address 类似。
地址描述和网络掩码的二元组，其中地址描述可以是字符串、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)¶: 如果此网络部分或全部包含在 *other* 中，或者 *other* 全部包含在此网络中，则为 True。

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)¶

将此网络与 *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 地址是网络地址，前缀长度必须是单个数字，即 *prefix* 。如果未提供前缀长度，则将其视为 /128。

请注意，目前不支持展开的网络掩码。这意味着 2001:db00::0/24 是一个有效的参数，而 2001:db00::0/ffff:ff00:: 不是。
一个适合 128 位的整数。这等效于一个单地址网络，网络地址为 *address*，掩码为 /128。
一个打包到长度为 16 的 bytes 对象（大端）中的整数。解释与整数 *address* 类似。
地址描述和网络掩码的二元组，其中地址描述是字符串、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 地址，除了子网路由器任播地址。对于掩码长度为 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¶: 如果对于网络地址和广播地址都为 true，则此属性对于整个网络为 true。

运算符¶

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

逻辑运算符¶

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

迭代¶

可以迭代网络对象以列出属于该网络的所有地址。对于迭代，将返回所有主机，包括不可用主机（对于可用主机，请使用 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

接口对象¶

接口对象是可哈希的，因此可以用作字典中的键。

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 操作库¶

便捷工厂函数¶

IP 地址¶

地址对象¶

转换为字符串和整数¶

运算符¶

比较运算符¶

算术运算符¶

IP 网络定义¶

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

网络对象¶

运算符¶

逻辑运算符¶

迭代¶

作为地址容器的网络¶

接口对象¶

运算符¶

逻辑运算符¶

其他模块级函数¶

自定义异常¶

目录

上一主题

下一主题

本页

ipaddress — IPv4/IPv6 操作库¶

便捷工厂函数¶

IP 地址¶

地址对象¶

转换为字符串和整数¶

运算符¶

比较运算符¶

算术运算符¶

IP 网络定义¶

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

网络对象¶

运算符¶

逻辑运算符¶

迭代¶

作为地址容器的网络¶

接口对象¶

运算符¶

逻辑运算符¶

其他模块级函数¶

自定义异常¶

`ipaddress` — IPv4/IPv6 操作库¶