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

来自菜鸟教程
Python/docs/3.7/library/ipaddress
跳转至：导航、​搜索

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 地址：

  1. 十进制点表示法的字符串，由 0-255 范围内的四个十进制整数组成，用点分隔（例如 192.168.0.1）。 每个整数代表地址中的一个八位字节（字节）。 只有小于 8 的值才允许前导零（因为此类字符串的十进制和八进制解释之间没有歧义）。

  2. 一个适合 32 位的整数。

  3. 一个整数，装入长度为 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

此版本的地址表示中的总位数：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。

class ipaddress.IPv6Address(address)

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

以下构成有效的 IPv6 地址：

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

  2. 适合 128 位的整数。

  3. 一个整数，打包到一个 bytes 长度为 16 的大端对象中。

>>> ipaddress.IPv6Address('2001:db8::1000')
IPv6Address('2001:db8::1000')
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。

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

运营商

地址对象支持一些运算符。 除非另有说明，运算符只能应用于兼容对象之间（即 IPv4 与 IPv4，IPv6 与 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

算术运算符

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

>>> 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 可以是以下之一：

  1. 由 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。

  2. 一个适合 32 位的整数。 这相当于一个单地址网络，网络地址为address，掩码为/32。

  3. 一个整数打包到一个 bytes 长度为 4 的对象中，大端。 解释类似于整数地址。

  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 的网络，网络地址和网络广播地址也包含在结果中。

>>> 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(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 可以是以下之一：

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

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

  2. 适合 128 位的整数。 这相当于一个单地址网络，网络地址为address，掩码为/128。

  3. 一个整数，打包到一个 bytes 长度为 16 的大端对象中。 解释类似于整数地址。

  4. 地址描述和网络掩码的二元组，其中地址描述是字符串、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 的网络，子网路由器任播地址也包含在结果中。

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)
与网络掩码相关的任何值错误。



取自“https://cainiaojiaocheng.com/index.php?title=Python/docs/3.7/library/ipaddress&oldid=24160”
Powered by MediaWiki