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
- ellerIPv6Address
-objekt beroende på den IP-adress som anges som argument. Antingen IPv4- eller IPv6-adresser kan anges; heltal mindre än2**32
kommer att betraktas som IPv4 som standard. EttValueError
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
ellerIPv6Network
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 än2**32
kommer att anses vara IPv4 som standard. strict skickas tillIPv4Network
ellerIPv6Network
konstruktören. EttValueError
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
- ellerIPv6Interface
-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 än2**32
kommer att betraktas som IPv4 som standard. EttValueError
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:
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.Ett heltal som ryms i 32 bitar.
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
ärFalse
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 (seIPv6Address.ipv4_mapped
):address.is_private == address.ipv4_mapped.is_private
is_private
har motsatt värde tillis_global
, utom för det delade adressutrymmet (intervallet100.64.0.0/10
) där de båda ärFalse
.Ä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ör192.0.0.9/32
och192.0.0.10/32
(tidigare: endast underområdet192.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 (seIPv6Address.ipv4_mapped
):address.is_global == address.ipv4_mapped.is_global
is_global
har motsatt värde tillis_private
, utom för det delade adressutrymmet (intervallet100.64.0.0/10
) där de båda ärFalse
.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 endast240.0.0.0/4
, detreserverade
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 kolumnenReserved-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 (seis_site_local
& RFC 3879).
- 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, motsvarandestr()
,'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 avformat
,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:
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 kanfe80::1234%1
identifiera adressenfe80::1234
på nodens första länk.Ett heltal som ryms inom 128 bitar.
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_link_local¶
- 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ändis_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 varaNone
.
- 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
.
- 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:
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
och192.168.1.0/0.0.0.255
.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
.Ett heltal packat i ett
bytes
-objekt med längd 4, big-endian. Tolkningen liknar en adress för ett heltal.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. EttNetmaskValueError
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årValueError
. 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 medsig 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¶
- is_link_local¶
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
ochcompressed
är alltid samma sak somstr(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
eller1
.>>> 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:
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 medan2001:db00::0/ffff:ff00::
inte är det.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
.Ett heltal packat i ett
bytes
-objekt med längden 16, big-endian. Tolkningen liknar en adress för ett heltal.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. EttNetmaskValueError
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årValueError
. 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¶
- is_link_local¶
- 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 tillIPv4Address
, 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 tillIPv6Address
, 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
ellerIPv6Address
i intervallet och last är den sistaIPv4Address
ellerIPv6Address
i intervallet. EttTypeError
uppstår om first eller last inte är IP-adresser eller inte är av samma version. EttValueError
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
ellerIPv6Network
objekten. addresses är en iterable avIPv4Network
ellerIPv6Network
objekt. EttTypeError
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 tillsorted()
.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.