ipaddress — Bibliotek för manipulering av IPv4/IPv6

Källkod: Lib/ipaddress.py


ipaddress ger möjlighet att skapa, manipulera och använda IPv4- och IPv6-adresser och nätverk.

Funktionerna och klasserna i den här modulen gör det enkelt att hantera olika uppgifter som rör IP-adresser, t.ex. att kontrollera om två värddatorer finns i samma subnät eller inte, att iterera över alla värddatorer i ett visst subnät, att kontrollera om en sträng representerar en giltig IP-adress eller nätverksdefinition eller inte osv.

Detta är den fullständiga API-referensen för modulen - för en översikt och introduktion, se En introduktion till modulen ipaddress.

Tillagd i version 3.3.

Bekväma fabriksfunktioner

Modulen ipaddress innehåller fabriksfunktioner för att enkelt skapa IP-adresser, nätverk och gränssnitt:

ipaddress.ip_address(address)

Returnerar ett IPv4Address- eller IPv6Address-objekt beroende på den IP-adress som anges som argument. Antingen IPv4- eller IPv6-adresser kan anges; heltal mindre än 2**32 kommer att betraktas som IPv4 som standard. Ett ValueError uppstår om address inte representerar en giltig IPv4- eller IPv6-adress.

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

Returnerar ett IPv4Network eller IPv6Network objekt beroende på den IP-adress som anges som argument. address är en sträng eller ett heltal som representerar IP-nätverket. Antingen IPv4- eller IPv6-nätverk kan anges; heltal som är mindre än 2**32 kommer att anses vara IPv4 som standard. strict skickas till IPv4Network eller IPv6Network konstruktören. Ett ValueError uppstår om address inte representerar en giltig IPv4- eller IPv6-adress, eller om nätverket har host-bitar inställda.

>>> ipaddress.ip_network('192.168.0.0/28')
IPv4Network('192.168.0.0/28')
ipaddress.ip_interface(address)

Returnerar ett IPv4Interface- eller IPv6Interface-objekt beroende på IP-adressen som anges som argument. address är en sträng eller ett heltal som representerar IP-adressen. Antingen IPv4- eller IPv6-adresser kan anges; heltal som är mindre än 2**32 kommer att betraktas som IPv4 som standard. Ett ValueError uppstår om address inte representerar en giltig IPv4- eller IPv6-adress.

En nackdel med dessa bekvämlighetsfunktioner är att behovet av att hantera både IPv4- och IPv6-format innebär att felmeddelanden ger minimal information om det exakta felet, eftersom funktionerna inte vet om IPv4- eller IPv6-formatet var avsett. Mer detaljerad felrapportering kan erhållas genom att anropa de lämpliga versionsspecifika klasskonstruktörerna direkt.

IP-adresser

Adressobjekt

Objekten IPv4Address och IPv6Address har många gemensamma attribut. Vissa attribut som bara är meningsfulla för IPv6-adresser implementeras också av IPv4Address-objekt, för att göra det enklare att skriva kod som hanterar båda IP-versionerna korrekt. Adressobjekt är hashable, vilket innebär att de kan användas som nycklar i ordböcker.

class ipaddress.IPv4Address(address)

Konstruera en IPv4-adress. Ett AddressValueError uppstår om address inte är en giltig IPv4-adress.

Följande utgör en giltig IPv4-adress:

  1. En sträng i decimal-punktnotation, bestående av fyra decimala heltal i det inkluderande intervallet 0–255, åtskilda av punkter (t.ex. 192.168.0.1). Varje heltal representerar en oktett (byte) i adressen. Ledande nollor tolereras inte för att förhindra förväxling med oktal notation.

  2. Ett heltal som ryms i 32 bitar.

  3. Ett heltal packat i ett bytes-objekt med längden 4 (den mest signifikanta oktetten först).

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

Ändrad i version 3.8: Ledande nollor tolereras, även i tvetydiga fall som ser ut som oktal notation.

Ändrad i version 3.9.5: Ledande nollor tolereras inte längre och behandlas som ett fel. IPv4-adresssträngar analyseras nu lika strikt som glibc inet_pton().

version

Lämpligt versionsnummer: 4 för IPv4, 6 för IPv6.

Ändrad i version 3.14: Tillgängliggörs i klassen.

max_prefixlen

Det totala antalet bitar i adressrepresentationen för den här versionen: 32 för IPv4, 128 för IPv6.

Prefixet definierar antalet inledande bitar i en adress som jämförs för att avgöra om en adress är en del av ett nätverk eller inte.

Ändrad i version 3.14: Tillgängliggörs i klassen.

compressed
exploded

Strängens representation i punktformig decimalnotation. Ledande nollor ingår aldrig i representationen.

Eftersom IPv4 inte definierar en kortfattad notation för adresser med oktetter som är nollställda, är dessa två attribut alltid desamma som str(addr) för IPv4-adresser. Genom att exponera dessa attribut blir det enklare att skriva visningskod som kan hantera både IPv4- och IPv6-adresser.

packed

Den binära representationen av denna adress - ett bytes-objekt med lämplig längd (den mest signifikanta oktetten först). Detta är 4 byte för IPv4 och 16 byte för IPv6.

reverse_pointer

Namnet på den omvända DNS PTR-posten för IP-adressen, t.ex.:

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

Detta är det namn som kan användas för att utföra en PTR-uppslagning, inte själva det upplösta värdnamnet.

Tillagd i version 3.5.

is_multicast

True om adressen är reserverad för multicast-användning. Se RFC 3171 (för IPv4) eller RFC 2373 (för IPv6).

is_private

True om adressen definieras som inte globalt nåbar av iana-ipv4-special-registry (för IPv4) eller iana-ipv6-special-registry (för IPv6) med följande undantag:

  • is_private är False för det delade adressutrymmet (100.64.0.0/10)

  • För IPv4-mappade IPv6-adresser bestäms värdet is_private av semantiken för de underliggande IPv4-adresserna och följande villkor gäller (se IPv6Address.ipv4_mapped):

    address.is_private == address.ipv4_mapped.is_private
    

is_private har motsatt värde till is_global, utom för det delade adressutrymmet (intervallet 100.64.0.0/10) där de båda är False.

Ändrad i version 3.13: Fixat några falska positiva och falska negativa resultat.

  • 192.0.0.0/24 betraktas som privat med undantag för 192.0.0.9/32 och 192.0.0.10/32 (tidigare: endast underområdet 192.0.0.0/29 betraktades som privat).

  • 64:ff9b:1::/48 anses vara privat.

  • 2002::/16 betraktas som privat.

  • Det finns undantag inom 2001::/23 (som annars betraktas som privata): 2001:1::1/128, 2001:1::2/128, 2001:3::/32, 2001:4:112::/48, 2001:20::/28, 2001:30::/28. Undantagen anses inte vara privata.

is_global

True om adressen definieras som globalt nåbar av iana-ipv4-special-registry (för IPv4) eller iana-ipv6-special-registry (för IPv6) med följande undantag:

För IPv4-mappade IPv6-adresser bestäms värdet is_private av semantiken för de underliggande IPv4-adresserna och följande villkor gäller (se IPv6Address.ipv4_mapped):

address.is_global == address.ipv4_mapped.is_global

is_global har motsatt värde till is_private, utom för det delade adressutrymmet (intervallet 100.64.0.0/10) där de båda är False.

Tillagd i version 3.4.

Ändrad i version 3.13: Fixade några falska positiva och falska negativa resultat, se is_private för detaljer.

is_unspecified

True om adressen är ospecificerad. Se RFC 5735 (för IPv4) eller RFC 2373 (för IPv6).

is_reserved

True om adressen är noterad som reserverad av IETF. För IPv4 är detta endast 240.0.0.0/4, det reserverade adressblocket. För IPv6 är detta alla adresser som ”tilldelats <iana-ipv6-address-space>” som ”reserverade av IETF” för framtida användning.

Anteckning

För IPv4 är is_reserved inte relaterat till adressblocksvärdet för kolumnen Reserved-by-Protocol i iana-ipv4-special-registry.

Försiktighet

För IPv6, fec0::/10 ett tidigare Site-Local scoped adressprefix är för närvarande utesluten från listan (se is_site_local & RFC 3879).

is_loopback

True om detta är en loopback-adress. Se RFC 3330 (för IPv4) eller RFC 2373 (för IPv6).

True om adressen är reserverad för link-local användning. Se RFC 3927.

ipv6_mapped

IPv4Address-objekt som representerar en IPv4-mappad IPv6-adress. Se RFC 4291.

Tillagd i version 3.13.

IPv4Address.__format__(fmt)

Returnerar en strängrepresentation av IP-adressen, styrd av en explicit formatsträng. fmt kan vara något av följande: 's', standardalternativet, motsvarande str(), 'b' för en nollutfylld binär sträng, 'X' eller 'x' för en hexadecimal representation med stora eller små bokstäver, eller 'n', vilket motsvarar 'b' för IPv4-adresser och 'x' för IPv6. För binära och hexadecimala representationer finns formspecificeraren '#' och grupperingsalternativet '_' tillgängliga. __format__ används av format, str.format och f-strängar.

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

Tillagd i version 3.9.

class ipaddress.IPv6Address(address)

Konstruera en IPv6-adress. Ett AddressValueError uppstår om address inte är en giltig IPv6-adress.

Följande utgör en giltig IPv6-adress:

  1. En sträng som består av åtta grupper om fyra hexadecimala siffror, där varje grupp representerar 16 bitar. Grupperna är åtskilda med kolon. Detta beskriver en exploderad (longhand) notation. Strängen kan också komprimeras (stenografisk notation) på olika sätt. Se RFC 4291 för detaljer. Till exempel kan "0000:0000:0000:0000:0000:0000:0abc:0007:0def" komprimeras till "::abc:7:def".

    Eventuellt kan strängen också ha ett scope zone ID, uttryckt med suffixet %scope_id. Om det finns måste scope-ID:t vara icke-tomt och får inte innehålla %. Se RFC 4007 för detaljer. Till exempel kan fe80::1234%1 identifiera adressen fe80::1234 på nodens första länk.

  2. Ett heltal som ryms inom 128 bitar.

  3. Ett heltal packat i ett bytes-objekt med längden 16, big-endian.

>>> ipaddress.IPv6Address('2001:db8::1000')
IPv6Address('2001:db8::1000')
>>> ipaddress.IPv6Address('ff02::5678%1')
IPv6Address('ff02::5678%1')
compressed

Kortformen av adressrepresentationen, där inledande nollor i grupper utelämnas och den längsta sekvensen av grupper som enbart består av nollor kollapsar till en enda tom grupp.

Detta är också det värde som returneras av str(addr) för IPv6-adresser.

exploded

Den långa formen av adressrepresentationen, med alla inledande nollor och grupper som enbart består av nollor inkluderade.

För följande attribut och metoder, se motsvarande dokumentation för klassen IPv4Address:

packed
reverse_pointer
version
max_prefixlen
is_multicast
is_private
is_global

Tillagd i version 3.4.

is_unspecified
is_reserved
is_loopback
is_site_local

True om adressen är reserverad för platslokal användning. Observera att det site-lokala adressutrymmet har utgått genom RFC 3879. Använd is_private för att testa om den här adressen ingår i utrymmet för unika lokala adresser enligt definitionen i RFC 4193.

ipv4_mapped

För adresser som verkar vara IPv4-mappade adresser (börjar med ::FFFF/96) kommer denna egenskap att rapportera den inbäddade IPv4-adressen. För alla andra adresser kommer denna egenskap att vara None.

scope_id

För scoped-adresser enligt definitionen i RFC 4007 identifierar den här egenskapen den särskilda zon i adressens scope som adressen tillhör, som en sträng. Om ingen scope-zon anges kommer denna egenskap att vara None.

sixtofour

För adresser som verkar vara 6to4-adresser (börjar med 2002::/16) enligt definitionen i RFC 3056, kommer denna egenskap att rapportera den inbäddade IPv4-adressen. För alla andra adresser kommer denna egenskap att vara None.

teredo

För adresser som verkar vara Teredo-adresser (börjar med 2001::/32) enligt definitionen i RFC 4380, kommer den här egenskapen att rapportera det inbäddade IP-adressparet (server, klient). För alla andra adresser kommer denna egenskap att vara None.

IPv6Address.__format__(fmt)

Se motsvarande metoddokumentation i IPv4Address.

Tillagd i version 3.9.

Konvertering till strängar och heltal

För att fungera tillsammans med nätverksgränssnitt som t.ex. socket-modulen måste adresser konverteras till strängar eller heltal. Detta hanteras med hjälp av de inbyggda funktionerna str() och 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

Observera att IPv6-scopade adresser konverteras till heltal utan scope zone ID.

Operatorer

Adressobjekt stöder vissa operatorer. Om inte annat anges kan operatorer endast användas mellan kompatibla objekt (dvs. IPv4 med IPv4, IPv6 med IPv6).

Jämförelseoperatorer

Adressobjekt kan jämföras med den vanliga uppsättningen jämförelseoperatorer. Samma IPv6-adresser med olika scope zone-ID är inte lika. Några exempel:

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

Aritmetiska operatorer

Heltal kan adderas till eller subtraheras från adressobjekt. Några exempel:

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

Definitioner av IP-nätverk

Objekten IPv4Network och IPv6Network tillhandahåller en mekanism för att definiera och inspektera IP-nätverksdefinitioner. En nätverksdefinition består av en mask och en nätverksadress och definierar därmed ett intervall av IP-adresser som är lika med nätverksadressen när den maskeras (binär AND) med masken. Till exempel består en nätverksdefinition med masken 255.255.255.0 och nätverksadressen 192.168.1.0 av IP-adresser i det inkluderande intervallet 192.168.1.0 till 192.168.1.255.

Prefix, nätmask och värdmask

Det finns flera likvärdiga sätt att ange IP-nätverksmasker. Ett prefix /<nbits> är en notation som anger hur många högordningsbitar som är inställda i nätverksmasken. En nätverksmask är en IP-adress med ett visst antal högordningsbitar inställda. Prefixet /24 motsvarar alltså nätmasken 255.255.255.0 i IPv4, eller ffffff:ff00:: i IPv6. Dessutom är en host mask den logiska motsatsen till en net mask och används ibland (t.ex. i Cisco access control lists) för att beteckna en nätverksmask. Värdmasken som motsvarar /24 i IPv4 är 0.0.0.255.

Nätverksobjekt

Alla attribut som implementeras av adressobjekt implementeras också av nätverksobjekt. Dessutom implementerar nätverksobjekt ytterligare attribut. Alla dessa är gemensamma för IPv4Network och IPv6Network, så för att undvika duplicering dokumenteras de endast för IPv4Network. Nätverksobjekt är hashable, så de kan användas som nycklar i ordböcker.

class ipaddress.IPv4Network(address, strict=True)

Konstruera en IPv4-nätverksdefinition. address kan vara något av följande:

  1. En sträng som består av en IP-adress och en valfri mask, åtskilda av ett snedstreck (/). IP-adressen är nätverksadressen och masken kan antingen vara ett enda tal, vilket innebär att det är ett prefix, eller en strängrepresentation av en IPv4-adress. Om det är det sistnämnda tolkas masken som en nätverksmask om den börjar med ett fält som inte är noll, eller som en hostmask om den börjar med ett nollfält, med ett enda undantag för en mask som är helt noll och som behandlas som en nätverksmask. Om ingen mask anges anses den vara /32.

    Exempelvis är följande adressspecifikationer likvärdiga: 192.168.1.0/24, 192.168.1.0/255.255.255.0 och 192.168.1.0/0.0.0.255.

  2. Ett heltal som ryms i 32 bitar. Detta motsvarar ett nätverk med en adress, där nätverksadressen är adress och masken är /32.

  3. Ett heltal packat i ett bytes-objekt med längd 4, big-endian. Tolkningen liknar en adress för ett heltal.

  4. En tvåtupel av en adressbeskrivning och en nätmask, där adressbeskrivningen är antingen en sträng, ett 32-bitars heltal, ett 4-bitars packat heltal eller ett befintligt IPv4Address-objekt; och nätmasken är antingen ett heltal som representerar prefixlängden (t.ex. 24) eller en sträng som representerar prefixmasken (t.ex. 255.255.255.0).

Ett AddressValueError uppstår om address inte är en giltig IPv4-adress. Ett NetmaskValueError visas om masken inte är giltig för en IPv4-adress.

Om strict är True och värdbitar är inställda i den angivna adressen, så uppstår ValueError. Annars maskeras värdbitarna för att bestämma lämplig nätverksadress.

Om inget annat anges kommer alla nätverksmetoder som accepterar andra nätverks-/adressobjekt att ge upphov till TypeError om argumentets IP-version inte är kompatibel med sig själv.

Ändrad i version 3.5: Lagt till formen två-tupel för konstruktorparametern address.

version
max_prefixlen

Se dokumentationen för motsvarande attribut i IPv4Address.

is_multicast
is_private
is_unspecified
is_reserved
is_loopback

Dessa attribut är sanna för nätverket som helhet om de är sanna för både nätverksadressen och broadcast-adressen.

network_address

Nätverksadressen för nätverket. Nätverksadressen och prefixlängden definierar tillsammans ett nätverk på ett unikt sätt.

broadcast_address

Broadcast-adressen för nätverket. Paket som skickas till broadcast-adressen bör tas emot av alla värdar i nätverket.

hostmask

Värdmasken, som ett IPv4Address-objekt.

netmask

Nätmasken, som ett IPv4Address-objekt.

with_prefixlen
compressed
exploded

En strängrepresentation av nätverket, med masken i prefixnotation.

with_prefixlen och compressed är alltid samma sak som str(network). exploded använder den exploderade formen av nätverksadressen.

with_netmask

En strängrepresentation av nätverket, med masken i nätmasknotation.

with_hostmask

En strängrepresentation av nätverket, med masken i värdmasknotation.

num_addresses

Det totala antalet adresser i nätverket.

prefixlen

Nätverksprefixets längd i bitar.

hosts()

Returnerar en iterator över de användbara värdarna i nätverket. De användbara värdarna är alla IP-adresser som hör till nätverket, utom själva nätverksadressen och nätverkets broadcast-adress. För nätverk med en masklängd på 31 ingår även nätverksadressen och nätverkets broadcast-adress i resultatet. Nätverk med en mask på 32 returnerar en lista som innehåller den enda värdadressen.

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

True om detta nätverk helt eller delvis ingår i other eller other helt och hållet ingår i detta nätverk.

address_exclude(network)

Beräknar de nätverksdefinitioner som blir resultatet av att ta bort det givna nätverket från detta. Returnerar en iterator av nätverksobjekt. Utlöser ValueError om nätverk inte är helt inneslutet i detta nätverk.

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

De subnät som går samman för att skapa den aktuella nätverksdefinitionen, beroende på argumentvärdena. prefixlen_diff är det belopp som vår prefixlängd ska ökas med. new_prefix är det önskade nya prefixet för subnäten; det måste vara större än vårt prefix. Ett och endast ett av prefixlen_diff och new_prefix måste anges. Returnerar en iterator av nätverksobjekt.

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

Det supernät som innehåller denna nätverksdefinition, beroende på argumentvärdena. prefixlen_diff är den mängd som vår prefixlängd ska minskas med. new_prefix är det önskade nya prefixet för supernätet; det måste vara mindre än vårt prefix. Ett och endast ett av prefixlen_diff och new_prefix måste anges. Returnerar ett enda nätverksobjekt.

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

Returnerar True om detta nätverk är ett undernät till other.

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

Tillagd i version 3.7.

supernet_of(other)

Returnerar True om detta nätverk är ett supernät av andra.

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

Tillagd i version 3.7.

compare_networks(other)

Jämför detta nätverk med ett annat. I denna jämförelse beaktas endast nätverksadresserna; värdbitar beaktas inte. Returnerar antingen -1, 0 eller 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

Föråldrad sedan version 3.7: Den använder samma ordnings- och jämförelsealgoritm som ”<”, ”==” och ”>”

class ipaddress.IPv6Network(address, strict=True)

Konstruera en IPv6-nätverksdefinition. address kan vara något av följande:

  1. En sträng som består av en IP-adress och en valfri prefixlängd, åtskilda av ett snedstreck (/). IP-adressen är nätverksadressen och prefixlängden måste vara ett enda tal, prefixet. Om ingen prefixlängd anges anses den vara /128.

    Observera att utökade nätmasker för närvarande inte stöds. Det innebär att 2001:db00::0/24 är ett giltigt argument medan 2001:db00::0/ffff:ff00:: inte är det.

  2. Ett heltal som ryms inom 128 bitar. Detta motsvarar ett nätverk med en adress, där nätverksadressen är adress och masken är /128.

  3. Ett heltal packat i ett bytes-objekt med längden 16, big-endian. Tolkningen liknar en adress för ett heltal.

  4. En tvåtupel av en adressbeskrivning och en nätmask, där adressbeskrivningen är antingen en sträng, ett 128-bitars heltal, ett 16-bytes packat heltal eller ett befintligt IPv6Address-objekt; och nätmasken är ett heltal som representerar prefixlängden.

Ett AddressValueError uppstår om address inte är en giltig IPv6-adress. Ett NetmaskValueError visas om masken inte är giltig för en IPv6-adress.

Om strict är True och värdbitar är inställda i den angivna adressen, så uppstår ValueError. Annars maskeras värdbitarna för att bestämma lämplig nätverksadress.

Ändrad i version 3.5: Lagt till formen två-tupel för konstruktorparametern 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()

Returnerar en iterator över de användbara värdarna i nätverket. De användbara värdarna är alla IP-adresser som hör till nätverket, utom Subnet-Router anycast-adressen. För nätverk med en masklängd på 127 ingår även Subnet-Router anycast-adressen i resultatet. Nätverk med en mask på 128 returnerar en lista som innehåller den enda värdadressen.

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)

Se dokumentationen för motsvarande attribut i IPv4Network.

is_site_local

Detta attribut är sant för nätverket som helhet om det är sant för både nätverksadressen och broadcast-adressen.

Operatorer

Nätverksobjekt stöder vissa operatorer. Om inte annat anges kan operatorer endast användas mellan kompatibla objekt (dvs. IPv4 med IPv4, IPv6 med IPv6).

Logiska operatorer

Nätverksobjekt kan jämföras med den vanliga uppsättningen logiska operatorer. Nätverksobjekten sorteras först efter nätverksadress och sedan efter nätverksmask.

Iteration

Nätverksobjekt kan itereras för att lista alla adresser som hör till nätverket. Vid iteration returneras alla värdar, inklusive oanvändbara värdar (för användbara värdar används metoden hosts()). Ett exempel:

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

Nätverk som behållare av adresser

Nätverksobjekt kan fungera som behållare för adresser. Några exempel:

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

Gränssnittsobjekt

Interface-objekt är hashable, vilket innebär att de kan användas som nycklar i ordböcker.

class ipaddress.IPv4Interface(address)

Konstruerar ett IPv4-gränssnitt. Betydelsen av address är densamma som i konstruktorn för IPv4Network, förutom att godtyckliga värdadresser alltid accepteras.

IPv4Interface är en underklass till IPv4Address, så den ärver alla attribut från den klassen. Dessutom finns följande attribut tillgängliga:

ip

Adressen (IPv4Address) utan nätverksinformation.

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.ip
IPv4Address('192.0.2.5')
network

Det nätverk (IPv4Network) som detta gränssnitt tillhör.

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.network
IPv4Network('192.0.2.0/24')
with_prefixlen

En strängrepresentation av gränssnittet med masken i prefixnotation.

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.with_prefixlen
'192.0.2.5/24'
with_netmask

En strängrepresentation av gränssnittet mot nätverket som en nätmask.

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.with_netmask
'192.0.2.5/255.255.255.0'
with_hostmask

En strängrepresentation av gränssnittet mot nätverket som en värdmask.

>>> interface = IPv4Interface('192.0.2.5/24')
>>> interface.with_hostmask
'192.0.2.5/0.0.0.255'
class ipaddress.IPv6Interface(address)

Konstruerar ett IPv6-gränssnitt. Betydelsen av address är densamma som i konstruktorn för IPv6Network, förutom att godtyckliga värdadresser alltid accepteras.

IPv6Interface är en underklass till IPv6Address, så den ärver alla attribut från den klassen. Dessutom finns följande attribut tillgängliga:

ip
network
with_prefixlen
with_netmask
with_hostmask

Se dokumentationen för motsvarande attribut i IPv4Interface.

Operatorer

Gränssnittsobjekt stöder vissa operatorer. Om inte annat anges kan operatorer endast användas mellan kompatibla objekt (dvs. IPv4 med IPv4, IPv6 med IPv6).

Logiska operatorer

Gränssnittsobjekt kan jämföras med den vanliga uppsättningen logiska operatorer.

Vid jämförelse med likhet (== och !=) måste både IP-adressen och nätverket vara desamma för att objekten ska vara lika. Ett gränssnitt kommer inte att jämföras lika med något adress- eller nätverksobjekt.

För ordning (<, >, etc) är reglerna annorlunda. Interface- och adressobjekt med samma IP-version kan jämföras, och adressobjekten sorteras alltid före interface-objekten. Två interface-objekt jämförs först med sina nätverk och, om dessa är desamma, sedan med sina IP-adresser.

Andra funktioner på modulnivå

Modulen innehåller också följande funktioner på modulnivå:

ipaddress.v4_int_to_packed(address)

Representerar en adress som 4 packade bytes i nätverksordning (big-endian). address är en heltalsrepresentation av en IPv4 IP-adress. Ett ValueError uppstår om heltalet är negativt eller för stort för att vara en IPv4 IP-adress.

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

Representerar en adress som 16 packade byte i nätverksordning (big-endian). address är en heltalsrepresentation av en IPv6 IP-adress. Ett ValueError uppstår om heltalet är negativt eller för stort för att vara en IPv6 IP-adress.

ipaddress.summarize_address_range(first, last)

Returnerar en iterator för det sammanfattade nätverksintervallet givet den första och sista IP-adressen. first är den första IPv4Address eller IPv6Address i intervallet och last är den sista IPv4Address eller IPv6Address i intervallet. Ett TypeError uppstår om first eller last inte är IP-adresser eller inte är av samma version. Ett ValueError visas om last inte är större än first eller om first adressversion inte är 4 eller 6.

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

Returnerar en iterator av de kollapsade IPv4Network eller IPv6Network objekten. addresses är en iterable av IPv4Network eller IPv6Network objekt. Ett TypeError uppstår om addresses innehåller mixed version-objekt.

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

Returnerar en nyckel som är lämplig för sortering mellan nätverk och adresser. Adress- och nätverksobjekt är inte sorterbara som standard; de är fundamentalt olika, så uttrycket:

IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')

är inte meningsfullt. Det finns dock tillfällen då du kanske vill att ipaddress ska sortera dessa ändå. Om du behöver göra det kan du använda den här funktionen som key-argument till sorted().

obj är antingen ett nätverks- eller adressobjekt.

Anpassade undantag

För att stödja mer specifik felrapportering från klasskonstruktörer definierar modulen följande undantag:

exception ipaddress.AddressValueError(ValueError)

Alla värdefel som är relaterade till adressen.

exception ipaddress.NetmaskValueError(ValueError)

Alla värdefel relaterade till nätmasken.