ipaddress --- IPv4/IPv6 操作庫?

源代碼： Lib/ipaddress.py

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

  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?

合適的版本號：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）

如果該地址被保留用于本地鏈接則為 True。 參見 RFC 3927。

class ipaddress.IPv6Address(address)?

構造一個 IPv6 地址。 如果 address 不是一個有效的 IPv6 地址，會拋出 AddressValueError 。

以下是有效的 IPv6 地址：

  1. 一個由八組四個16進制數字組成的字符串, 每組展示為16位. 以冒號分隔. 這可以描述為 分解 (普通書寫). 此字符可以被 壓縮 (速記書寫) . 詳見:RFC:4291 . 例如, "0000:0000:0000:0000:0000:0abc:0007:0def" 可以被精簡為 "::abc:7:def".

  2. 適合 128 位的整數.

  3. 一個打包在長度為 16 字節的大端序 bytes 對象中的整數。

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

地址表示的簡短形式，省略了組中的前導零，完全由零組成的最長的組序列被折疊成一個空組。

這也是``str(addr)``對IPv6地址返回的值。

exploded?

地址的長形式表示，包括所有前導零和完全由零組成的組。

For the following attributes, see the corresponding documentation of the IPv4Address class:

packed?
reverse_pointer?
version?
max_prefixlen?
is_multicast?
is_private?
is_global?
is_unspecified?
is_reserved?
is_loopback?

3.4 新版功能: is_global

is_site_local?

如果地址被保留用于本地站點則為 True。 請注意本地站點地址空間已被 RFC 3879 棄用。 請使用 is_private 來檢測此地址是否位于 RFC 4193 所定義的本地唯一地址空間中。

ipv4_mapped?

映射IPv4的地址 (起始為 ::FFFF/96), 這一屬性記錄為嵌入IPv4地址. 其他的任何地址, 這一屬性為 None.

sixtofour?

對于看起來是6to4的地址（以``2002::/16``開頭），如 RFC 3056 所定義的，此屬性將返回嵌入的IPv4地址。 對于任何其他地址，該屬性將是``None``。

teredo?

對于看起來是:RFC:4380`定義的Teredo地址（以``2001::/32``開頭）的地址，此屬性將返回嵌入式IP地址對``(server, client)`。 對于任何其他地址，該屬性將是``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）。

比較運算符?

Address objects can be compared with the usual set of comparison operators. Some examples:

>>> 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）時，等于網絡地址。 例如，一個帶有掩碼``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中，相當于主機掩碼``0.0.0.255``的是/24`` 。

網絡對象?

所有由地址對象實現的屬性也由網絡對象實現。 此外，網絡對象還實現了額外的屬性。所有這些在 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. 一個整數被打包成一個長度為 4 的大端序 bytes 對象。 其解釋類似于一個整數 address。

  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?

如果這些屬性對網絡地址和廣播地址都是真實的，那么它們對整個網絡來說就是真實的。

network_address?

網絡的網絡地址。網絡地址和前綴長度一起唯一地定義了一個網絡。

broadcast_address?

網絡的廣播地址。發送到廣播地址的數據包應該被網絡上的每臺主機所接收。

hostmask?

主機掩碼，作為一個 IPv4Address 對象。

netmask?

網絡掩碼，作為一個 IPv4Address 對象。

with_prefixlen?
compressed?
exploded?

網絡的字符串表示，其中掩碼為前綴符號。

with_prefixlen 和 compressed 總是與 str(network) 相同，exploded 使用分解形式的網絡地址。

with_netmask?

網絡的字符串表示，掩碼用net mask符號表示。

with_hostmask?

網絡的字符串表示，其中的掩碼為主機掩碼符號。

num_addresses?

網絡中的地址總數。

prefixlen?

網絡前綴的長度，以比特為單位。

hosts()?

Returns an iterator over the usable hosts in the network. The usable hosts are all the IP addresses that belong to the network, except the network address itself and the network broadcast address. For networks with a mask length of 31, the network address and network broadcast address are also included in the result.

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

如果這個網絡部分或全部包含在*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)?

將這個網絡與*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 可以是以下之一：

  1. 一個由IP地址和可選前綴長度組成的字符串，用斜線（/）分開。 IP地址是網絡地址，前綴長度必須是一個數字，即*prefix*。 如果沒有提供前綴長度，就認為是``/128``。

    請注意，目前不支持擴展的網絡掩碼。 這意味著 2001:db00::0/24 是一個有效的參數，而 2001:db00::0/ffff:ff00:: 不是。

  2. 一個適合128位的整數。 這相當于一個單地址網絡，網絡地址是*address*，掩碼是``/128``。

  3. 一個整數被打包成一個長度為 16 的大端序 bytes 對象。 其解釋類似于一個整數的 address。

  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?
network_address?
broadcast_address?
hostmask?
netmask?
with_prefixlen?
compressed?
exploded?
with_netmask?
with_hostmask?
num_addresses?
prefixlen?
hosts()?

Returns an iterator over the usable hosts in the network. The usable hosts are all the IP addresses that belong to the network, except the Subnet-Router anycast address. For networks with a mask length of 127, the Subnet-Router anycast address is also included in the result.

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

接口對象?

接口對象是 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)?

以網絡（大端序）順序將一個地址表示為 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)?

與網絡掩碼有關的任何數值錯誤