`ipaddress` — IPv4/IPv6 操作库¶

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 版本的代码。地址对象是可哈希的，因此它们可以用作字典中的键。

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
```

is_private 的值与 is_global 相反，但共享地址空间 (100.64.0.0/10 范围) 除外，在该空间中，它们都为 False。

在 3.12.4 版更改: 修复了一些误报和漏报。

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

is_global 的值与 is_private 相反，但共享地址空间 (100.64.0.0/10 范围) 除外，在该空间中，它们都为 False。

3.4 版新增。

在 3.12.4 版更改: 修复了一些误报和漏报，有关详细信息，请参阅 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。

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¶: 对于看起来像是 6to4 地址（以 2002::/16 开头）的地址，如 RFC 3056 所定义，此属性将报告嵌入的 IPv4 地址。对于任何其他地址，此属性将为 None。

teredo¶: 对于看起来像是 Teredo 地址（以 2001::/32 开头）的地址，如 RFC 4380 所定义，此属性将报告嵌入的 (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）时等于网络地址。例如，掩码为 255.255.255.0 且网络地址为 192.168.1.0 的网络定义包含从 192.168.1.0 到 192.168.1.255 的 IP 地址（含）。

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

有几种等效的方法来指定 IP 网络掩码。*前缀* /<位数> 是一种表示网络掩码中设置了多少个高位位的符号。*网络掩码*是一个 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。

例如，以下*地址*规范是等效的：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¶: 如果网络地址和广播地址都为真，则此属性对整个网络都为真。

运算符¶

网络对象支持某些运算符。除非另有说明，否则运算符只能应用于兼容对象之间（即 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 操作库¶