创新互联Python教程：ipaddress—-IPv4/IPv6操作库

ipaddress —- IPv4/IPv6 操作库

源代码： Lib/ipaddress.py

创新互联公司专业为企业提供龙文网站建设、龙文做网站、龙文网站设计、龙文网站制作等企业网站建设、网页设计与制作、龙文企业网站模板建站服务，10年龙文做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

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 网址，或者网络设置了 host 比特位，则会引发 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 版本的代码。地址对象是可哈希的 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
合适的版本号：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
如果该地址被分配至私有网络，返回 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
如果该地址属于互联网工程任务组（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' 相当于 '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进制数字组成的字符串, 每组展示为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

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

这也是``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
对于看起来是6to4的地址（以``2002::/16``开头），如 RFC 3056 所定义的，此属性将返回嵌入的IPv4地址。对于任何其他地址，该属性将是``None``。
teredo
对于看起来是:RFC:4380`定义的Teredo地址（以``2001::/32``开头）的地址，此属性将返回嵌入式IP地址对``(server, client)`。对于任何其他地址，该属性将是``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 "", line 1, in 
  
  
  
  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中，相当于主机掩码``0.0.0.255``的是/24`` 。

网络对象

所有由地址对象实现的属性也由网络对象实现。此外，网络对象还实现了额外的属性。所有这些在 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``。
一个整数被打包成一个长度为 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
如果这些属性对网络地址和广播地址都是True，那么它们对整个网络来说就是True。
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 "", line 1, in 
    
    
    
     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)

将这个网络与*ohter*网络进行比较。在这个比较中，只考虑网络地址；不考虑主机位。返回是``-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地址，除了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
如果这些属性对网络地址和广播地址都是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

接口对象

接口对象是 hashable 的，所以它们可以作为字典中的键使用。

class ipaddress.IPv4Interface(address)

构建一个 IPv4 接口。 address 的含义与 IPv4Network 构造器中的一样，不同之处在于任意主机地址总是会被接受。

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

地址（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)

以网络（大端序）顺序将一个地址表示为 4 个打包的字节。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)

与网络掩码有关的任何数值错误。

网页题目：创新互联Python教程：ipaddress—-IPv4/IPv6操作库
URL链接：http://www.shufengxianlan.com/qtweb/news12/176762.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容