ipaddress — IPv4/IPv6 操作库

ipaddress提供了在 IPv4 和 IPv6 地址和网络上创建，操作和操作的Function。

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

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

版本 3.3 中的新Function。

便利工厂Function

ipaddress模块提供了工厂Function，可以方便地创建 IP 地址，网络和接口：

ipaddress. ip_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(地址)
- 返回IPv4Interface或IPv6Interface对象，具体取决于作为参数传递的 IP 地址。 * address 是代表 IP 地址的字符串或整数。可以提供 IPv4 或 IPv6 地址。小于 2 ** 32 的整数默认情况下将被视为 IPv4.如果 address *不代表有效的 IPv4 或 IPv6 地址，则引发ValueError。

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

IP Addresses

Address objects

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

类别 ipaddress. IPv4Address(地址)
- 构造一个 IPv4 地址。如果* address *不是有效的 IPv4 地址，则引发AddressValueError。

以下内容构成有效的 IPv4 地址：

十进制小数点形式的字符串，由四个小数点组成，范围在 0 到 255 之间(包括 0 和 255)，并用点号分隔(例如192.168.0.1)。每个整数代表地址中的一个八位位组(字节)。仅对于小于 8 的值才允许使用前导零(因为此类字符串的十进制和八进制解释之间没有歧义)。
可以容纳 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')

version
- 适当的版本号：4表示 IPv4，6表示 IPv6.
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 版中的新Function。

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

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。
类别 ipaddress. IPv6Address(地址)
- 构造一个 IPv6 地址。如果* address *不是有效的 IPv6 地址，则引发AddressValueError。

以下内容构成有效的 IPv6 地址：

由八组四个十六进制数字组成的字符串，每组代表 16 位。各组之间用冒号隔开。这描述了爆炸(竖写)符号。也可以pass各种方式对字符串进行“压缩”(简写)。有关详情，请参见 RFC 4291。例如，"0000:0000:0000:0000:0000:0abc:0007:0def"可以压缩为"::abc:7:def"。
可容纳 128 位的整数。
打包为长度为 16，big-endian 的bytes对象的整数。

>>> ipaddress.IPv6Address('2001:db8::1000')
IPv6Address('2001:db8::1000')

compressed

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

这也是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 版的新Function：is_global
is_site_local
- True(如果该地址保留供站点本地使用)。请注意， RFC 3879已弃用站点本地地址空间。使用is_private测试此地址是否在 RFC 4193定义的唯一本地地址的空间内。
ipv4_mapped
- 对于似乎是 IPv4Map 地址(以::FFFF/96开头)的地址，此属性将报告嵌入式 IPv4 地址。对于其他任何地址，此属性均为None。
sixtofour
- 对于似乎是 RFC 3056定义的 6to4 地址(以2002::/16开头)的地址，此属性将报告嵌入式 IPv4 地址。对于其他任何地址，此属性均为None。
teredo
- 对于似乎是 RFC 4380定义的 Teredo 地址(以2001::/32开头)的地址，此属性将报告嵌入式(server, client) IP 地址对。对于其他任何地址，此属性均为None。

转换为字符串和整数

要与套接字模块等网络接口进行互操作，必须将地址转换为字符串或整数。这是使用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

Operators

地址对象支持某些运算符。除非另有说明，否则运算符只能在兼容对象(即 IPv4 与 IPv4，IPv6 与 IPv6)之间应用。

Comparison operators

可以将地址对象与通常的一组比较运算符进行比较。一些例子：

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

Arithmetic operators

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

>>> 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 网络定义的机制。网络定义由* mask 和 network address *组成，因此定义了一个 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::。另外，* host mask 是 net mask *的逻辑逆，有时(例如在 Cisco 访问控制列表中)用于表示网络掩码。与 IPv4 中的/24等效的主机掩码为0.0.0.255。

Network objects

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

- class * ipaddress. IPv4Network(* address ， strict = True *)
- 构造一个 IPv4 网络定义。地址可以是以下之一：
由 IP 地址和可选掩码组成的字符串，用斜杠(/)分隔。 IP 地址是网络地址，掩码可以是单个数字，这意味着它是* prefix 或 IPv4 地址的字符串表示形式。如果是后者，则该掩码如果以非零字段开头，则解释为 net mask ；如果以零字段开头，则解释为 host mask ，唯一 exception 是全零掩码被视为网络掩码*。如果未提供遮罩，则将其视为/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，big-endian 的bytes对象的整数。解释类似于整数* address *。
地址描述和网络掩码的二 Tuples，其中地址描述可以是字符串，32 位整数，4 字节压缩整数或现有的 IPv4Address 对象；网络掩码可以是代表前缀长度的整数(例如24)，也可以是代表前缀掩码的字符串(例如255.255.255.0)。

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

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

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

在版本 3.5 中进行了更改：为* address *构造函数参数添加了两 Tuples 形式。

version
max_prefixlen
- 请参阅IPv4Address中的相应属性文档。
is_multicast
is_private
is_unspecified
is_reserved
is_loopback
is_link_local
- 如果这些属性对于网络地址和 Broadcast 地址都是正确的，则它们对于整个网络都是正确的。
network_address
- 网络的网络地址。网络地址和前缀长度一起唯一地定义了一个网络。
broadcast_address
- 网络的 Broadcast 地址。网络上的每个主机都应接收发送到 Broadcast 地址的数据包。
hostmask
- 主机掩码，作为IPv4Address对象。
netmask
- 网络掩码，作为IPv4Address对象。
with_prefixlen
compressed
exploded
- 网络的字符串表示形式，掩码为前缀表示法。

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

with_netmask
- 网络的字符串表示形式，其掩码为网络掩码表示法。
with_hostmask
- 网络的字符串表示形式，其掩码为主机掩码表示法。
num_addresses
- 网络中的地址总数。
prefixlen
- 网络前缀的长度(以位为单位)。
hosts ( )
- 返回网络中可用主机上的迭代器。可用主机是属于网络的所有 IP 地址，但网络地址本身和网络 Broadcast 地址除外。对于掩码长度为 31 的网络，结果中还包括网络地址和网络 Broadcast 地址。

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

overlaps(其他)
- True如果此网络部分或全部包含在* other 中，或者 other *全部包含在此网络中。
address_exclude(网络)
- 计算从此网络中删除给定的“网络”而得出的网络定义。返回网络对象的迭代器。如果* 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 *的子网，则返回True。

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

3.7 版中的新Function。

supernet_of(其他)
- 如果此网络是* 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 版中的新Function。

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 版起已弃用：它使用与“ <", "==", and ">”相同的排序和比较算法

- class * ipaddress. IPv6Network(* address ， strict = True *)
- 构造一个 IPv6 网络定义。地址可以是以下之一：
由 IP 地址和可选的前缀长度组成的字符串，以斜杠(/)分隔。 IP 地址是网络地址，前缀长度必须是一个数字，即* prefix *。如果未提供前缀长度，则将其视为/128。

请注意，当前不支持扩展的网络掩码。这意味着2001:db00::0/24是有效参数，而2001:db00::0/ffff:ff00::不是有效参数。

可容纳 128 位的整数。这等效于单地址网络，网络地址为* address *，掩码为/128。
打包为长度为 16，big-endian 的bytes对象的整数。解释类似于整数* address *。
地址描述和网络掩码的二 Tuples，其中地址描述可以是字符串，128 位整数，16 字节打包整数或现有的 IPv6Address 对象；网络掩码是代表前缀长度的整数。

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

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

在版本 3.5 中进行了更改：为* address *构造函数参数添加了两 Tuples 形式。

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 地址，但子网 Router 任意播地址除外。对于掩码长度为 127 的网络，子网 Router 的任意播地址也包括在结果中。
overlaps(其他)
address_exclude(网络)
subnets(* prefixlen_diff = 1 ， new_prefix = None *)
supernet(* prefixlen_diff = 1 ， new_prefix = None *)
subnet_of(其他)
supernet_of(其他)
compare_networks(其他)
- 请参阅IPv4Network中的相应属性文档。
is_site_local
- 如果网络地址和 Broadcast 地址都为 true，则这些属性对于整个网络都是 true。

Operators

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

Logical operators

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

Iteration

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

Interface objects

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

类别 ipaddress. IPv4Interface(地址)
- 构造一个 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'

类别 ipaddress. IPv6Interface(地址)
- 构造一个 IPv6 接口。 * address *的含义与IPv6Network的构造函数相同，只是始终接受任意主机地址。

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

ip
network
with_prefixlen
with_netmask
with_hostmask
- 请参阅IPv4Interface中的相应属性文档。

Operators

接口对象支持某些运算符。除非另有说明，否则运算符只能在兼容对象(即 IPv4 与 IPv4，IPv6 与 IPv6)之间应用。

Logical operators

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

对于相等性比较(==和!=)，IP 地址和网络必须相同，对象才能相等。接口将不等于任何地址或网络对象进行比较。

对于 Order(<，>等)，规则是不同的。可以比较具有相同 IP 版本的接口和地址对象，并且地址对象将始终在接口对象之前排序。首先比较两个接口对象的网络，如果比较，则比较它们的 IP 地址。

其他模块级Function

该模块还提供以下模块级别的Function：

ipaddress. v4_int_to_packed(地址)
- 以网络(大端)Sequences 将地址表示为 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(地址)
- 以网络(大端)Sequences 将地址表示为 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 *是网络或地址对象。

Custom Exceptions

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

- exception * ipaddress. AddressValueError(* ValueError *)
- 与地址有关的任何值错误。
- exception * ipaddress. NetmaskValueError(* ValueError *)
- 与网络掩码有关的任何值错误。

Name	Python 中文文档
Version
Language
Badge
Last Updated	2021-07-03T12:24:35