ipaddress — Bibliothek zur Manipulation von IPv4/IPv6-Adressen

Quellcode: Lib/ipaddress.py

Das Modul ipaddress stellt die Funktionalität zum Erstellen, Manipulieren und Betreiben von IPv4- und IPv6-Adressen und -Netzwerken bereit.

Die Funktionen und Klassen in diesem Modul vereinfachen die Handhabung verschiedener Aufgaben im Zusammenhang mit IP-Adressen, einschließlich der Überprüfung, ob zwei Hosts im selben Subnetz liegen, der Iteration über alle Hosts in einem bestimmten Subnetz, der Überprüfung, ob eine Zeichenkette eine gültige IP-Adresse oder Netzwerkdefinition darstellt, und so weiter.

Dies ist die vollständige API-Referenz des Moduls – für einen Überblick und eine Einführung siehe Eine Einführung in das Modul ipaddress.

Hinzugefügt in Version 3.3.

Bequeme Factory-Funktionen

Das Modul ipaddress bietet Factory-Funktionen zum bequemen Erstellen von IP-Adressen, Netzwerken und Schnittstellen

ipaddress.ip_address(address)

Gibt ein IPv4Address- oder IPv6Address-Objekt zurück, abhängig von der als Argument übergebenen IP-Adresse. Entweder IPv4- oder IPv6-Adressen können übergeben werden; ganze Zahlen kleiner als 2**32 werden standardmäßig als IPv4 betrachtet. Ein ValueError wird ausgelöst, wenn address keine gültige IPv4- oder IPv6-Adresse darstellt.

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

Gibt ein IPv4Network- oder IPv6Network-Objekt zurück, abhängig von der als Argument übergebenen IP-Adresse. address ist eine Zeichenkette oder ganze Zahl, die das IP-Netzwerk darstellt. Entweder IPv4- oder IPv6-Netzwerke können übergeben werden; ganze Zahlen kleiner als 2**32 werden standardmäßig als IPv4 betrachtet. strict wird an den Konstruktor von IPv4Network oder IPv6Network übergeben. Ein ValueError wird ausgelöst, wenn address keine gültige IPv4- oder IPv6-Adresse darstellt oder wenn das Netzwerk Host-Bits gesetzt hat.

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

Gibt ein IPv4Interface- oder IPv6Interface-Objekt zurück, abhängig von der als Argument übergebenen IP-Adresse. address ist eine Zeichenkette oder ganze Zahl, die die IP-Adresse darstellt. Entweder IPv4- oder IPv6-Adressen können übergeben werden; ganze Zahlen kleiner als 2**32 werden standardmäßig als IPv4 betrachtet. Ein ValueError wird ausgelöst, wenn address keine gültige IPv4- oder IPv6-Adresse darstellt.

Ein Nachteil dieser bequemen Funktionen ist, dass die Notwendigkeit, sowohl IPv4- als auch IPv6-Formate zu behandeln, dazu führt, dass Fehlermeldungen nur minimale Informationen über den genauen Fehler liefern, da die Funktionen nicht wissen, welches Format beabsichtigt war. Detailliertere Fehlerberichte können durch direktes Aufrufen der entsprechenden versionsspezifischen Klassenkonstruktoren erhalten werden.

IP-Adressen

Adressenobjekte

Die Objekte IPv4Address und IPv6Address teilen sich viele gemeinsame Attribute. Einige Attribute, die nur für IPv6-Adressen von Bedeutung sind, werden auch von IPv4Address-Objekten implementiert, um die Erstellung von Code zu erleichtern, der beide IP-Versionen korrekt behandelt. Adressenobjekte sind hashable, sodass sie als Schlüssel in Wörterbüchern verwendet werden können.

class ipaddress.IPv4Address(address)

Konstruiert eine IPv4-Adresse. Ein AddressValueError wird ausgelöst, wenn address keine gültige IPv4-Adresse ist.

Folgendes stellt eine gültige IPv4-Adresse dar

  1. Eine Zeichenkette in Dezimalpunktnotation, bestehend aus vier Dezimalzahlen im Bereich von 0–255, getrennt durch Punkte (z. B. 192.168.0.1). Jede Zahl stellt ein Oktett (Byte) in der Adresse dar. Führende Nullen werden nicht toleriert, um Verwechslungen mit Oktalnotation zu vermeiden.

  2. Eine ganze Zahl, die in 32 Bits passt.

  3. Eine ganze Zahl, verpackt in ein bytes-Objekt der Länge 4 (höchstwertiges Oktett zuerst).

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

Geändert in Version 3.8: Führende Nullen werden toleriert, auch in mehrdeutigen Fällen, die wie Oktalnotation aussehen.

Geändert in Version 3.9.5: Führende Nullen werden nicht mehr toleriert und als Fehler behandelt. IPv4-Adresszeichenketten werden jetzt so streng wie glibc inet_pton() geparst.

version

Die entsprechende Versionsnummer: 4 für IPv4, 6 für IPv6.

Geändert in Version 3.14: Auf der Klasse verfügbar gemacht.

max_prefixlen

Die Gesamtzahl der Bits in der Adressdarstellung für diese Version: 32 für IPv4, 128 für IPv6.

Der Präfix definiert die Anzahl der führenden Bits in einer Adresse, die verglichen werden, um festzustellen, ob eine Adresse Teil eines Netzwerks ist oder nicht.

Geändert in Version 3.14: Auf der Klasse verfügbar gemacht.

compressed
exploded

Die Zeichenkettendarstellung in Dezimalpunktnotation. Führende Nullen sind in der Darstellung niemals enthalten.

Da IPv4 keine Kurzschreibweise für Adressen mit Oktetten, die auf Null gesetzt sind, definiert, sind diese beiden Attribute immer gleich str(addr) für IPv4-Adressen. Die Bereitstellung dieser Attribute erleichtert die Erstellung von Anzeigecode, der sowohl IPv4- als auch IPv6-Adressen verarbeiten kann.

packed

Die binäre Darstellung dieser Adresse – ein bytes-Objekt der entsprechenden Länge (höchstwertiges Oktett zuerst). Dies sind 4 Bytes für IPv4 und 16 Bytes für IPv6.

reverse_pointer

Der Name des Reverse-DNS-PTR-Eintrags für die IP-Adresse, z. B.

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

Dies ist der Name, der für eine PTR-Suche verwendet werden könnte, nicht der aufgelöste Hostname selbst.

Hinzugefügt in Version 3.5.

is_multicast

True, wenn die Adresse für die Multicast-Nutzung reserviert ist. Siehe RFC 3171 (für IPv4) oder RFC 2373 (für IPv6).

is_private

True, wenn die Adresse gemäß iana-ipv4-special-registry (für IPv4) oder iana-ipv6-special-registry (für IPv6) als nicht global erreichbar definiert ist, mit folgenden Ausnahmen

  • is_private ist False für den Shared Address Space (100.64.0.0/10)

  • Für IPv4-gemappte IPv6-Adressen wird der Wert von is_private durch die Semantik der zugrunde liegenden IPv4-Adressen bestimmt und die folgende Bedingung gilt (siehe IPv6Address.ipv4_mapped)

    address.is_private == address.ipv4_mapped.is_private

is_private hat den entgegengesetzten Wert zu is_global, mit Ausnahme des Shared Address Space (Bereich 100.64.0.0/10), wo beide False sind.

Geändert in Version 3.13: Einige Fehlalarme und Falschaussagen behoben.

  • 192.0.0.0/24 gilt als privat mit der Ausnahme von 192.0.0.9/32 und 192.0.0.10/32 (zuvor galt nur der Unterbereich 192.0.0.0/29 als privat).

  • 64:ff9b:1::/48 gilt als privat.

  • 2002::/16 gilt als privat.

  • Es gibt Ausnahmen innerhalb von 2001::/23 (andernfalls als privat betrachtet): 2001:1::1/128, 2001:1::2/128, 2001:3::/32, 2001:4:112::/48, 2001:20::/28, 2001:30::/28. Die Ausnahmen gelten nicht als privat.

is_global

True, wenn die Adresse gemäß iana-ipv4-special-registry (für IPv4) oder iana-ipv6-special-registry (für IPv6) als global erreichbar definiert ist, mit folgender Ausnahme

Für IPv4-gemappte IPv6-Adressen wird der Wert von is_private durch die Semantik der zugrunde liegenden IPv4-Adressen bestimmt und die folgende Bedingung gilt (siehe IPv6Address.ipv4_mapped)

address.is_global == address.ipv4_mapped.is_global

is_global hat den entgegengesetzten Wert zu is_private, mit Ausnahme des Shared Address Space (Bereich 100.64.0.0/10), wo beide False sind.

Hinzugefügt in Version 3.4.

Geändert in Version 3.13: Einige Fehlalarme und Falschaussagen behoben, siehe is_private für Details.

is_unspecified

True, wenn die Adresse unbestimmt ist. Siehe RFC 5735 (für IPv4) oder RFC 2373 (für IPv6).

is_reserved

True, wenn die Adresse vom IETF als reserviert gekennzeichnet ist. Für IPv4 ist dies nur 240.0.0.0/4, der Adressblock Reserved. Für IPv6 sind dies alle Adressen, die als Reserved by IETF für zukünftige Verwendung zugewiesen wurden.

Hinweis

Für IPv4 steht is_reserved in keinem Zusammenhang mit dem Adressblockwert der Spalte Reserved-by-Protocol in iana-ipv4-special-registry.

Vorsicht

Für IPv6 ist fec0::/10, ein früherer Site-Local-Scope-Adresspräfix, derzeit aus dieser Liste ausgeschlossen (siehe is_site_local & RFC 3879).

is_loopback

True, wenn dies eine Loopback-Adresse ist. Siehe RFC 3330 (für IPv4) oder RFC 2373 (für IPv6).

True, wenn die Adresse für die Link-Local-Nutzung reserviert ist. Siehe RFC 3927.

ipv6_mapped

Ein IPv4Address-Objekt, das die IPv4-gemappte IPv6-Adresse darstellt. Siehe RFC 4291.

Hinzugefügt in Version 3.13.

IPv4Address.__format__(fmt)

Gibt eine Zeichenkettendarstellung der IP-Adresse zurück, gesteuert durch eine explizite Formatzeichenkette. fmt kann eine der folgenden sein: 's', die Standardoption, äquivalent zu str(), 'b' für eine binäre Zeichenkette mit führenden Nullen, 'X' oder 'x' für eine hexadezimale Darstellung in Groß- bzw. Kleinbuchstaben oder 'n', was für IPv4-Adressen 'b' und für IPv6-Adressen 'x' entspricht. Für binäre und hexadezimale Darstellungen sind die Formatspezifizierer '#' und die Gruppierungsoption '_' verfügbar. __format__ wird von format, str.format und f-Strings verwendet.

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

Hinzugefügt in Version 3.9.

class ipaddress.IPv6Address(address)

Konstruiert eine IPv6-Adresse. Ein AddressValueError wird ausgelöst, wenn address keine gültige IPv6-Adresse ist.

Folgendes stellt eine gültige IPv6-Adresse dar

  1. Eine Zeichenkette, die aus acht Gruppen von vier Hexadezimalziffern besteht, wobei jede Gruppe 16 Bits darstellt. Die Gruppen sind durch Doppelpunkte getrennt. Dies beschreibt eine *explodierte* (ausgeschriebene) Notation. Die Zeichenkette kann auch auf verschiedene Weise *komprimiert* (Kurzschreibweise) werden. Siehe RFC 4291 für Details. Zum Beispiel kann "0000:0000:0000:0000:0000:0abc:0007:0def" zu "::abc:7:def" komprimiert werden.

    Optional kann die Zeichenkette auch eine Scope-Zonen-ID enthalten, die mit einem Suffix %scope_id ausgedrückt wird. Wenn vorhanden, muss die Scope-ID nicht leer sein und darf kein % enthalten. Siehe RFC 4007 für Details. Zum Beispiel könnte fe80::1234%1 die Adresse fe80::1234 auf dem ersten Link des Knotens identifizieren.

  2. Eine ganze Zahl, die in 128 Bits passt.

  3. Eine ganze Zahl, verpackt in ein bytes-Objekt der Länge 16, Big-Endian.

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

Die Kurzform der Adressdarstellung, bei der führende Nullen in Gruppen weggelassen und die längsten Folgen von Gruppen, die ausschließlich aus Nullen bestehen, zu einer einzelnen leeren Gruppe zusammengefasst werden.

Dies ist auch der Wert, der von str(addr) für IPv6-Adressen zurückgegeben wird.

exploded

Die Langform der Adressdarstellung, bei der alle führenden Nullen und Gruppen, die ausschließlich aus Nullen bestehen, enthalten sind.

Für die folgenden Attribute und Methoden siehe die entsprechende Dokumentation der Klasse IPv4Address

packed
reverse_pointer
version
max_prefixlen
is_multicast
is_private
is_global

Hinzugefügt in Version 3.4.

is_unspecified
is_reserved
is_loopback
is_site_local

True, wenn die Adresse für die Site-Local-Nutzung reserviert ist. Beachten Sie, dass der Site-Local-Adressraum von RFC 3879 als veraltet erklärt wurde. Verwenden Sie is_private, um zu testen, ob sich diese Adresse im Bereich der eindeutigen lokalen Adressen gemäß RFC 4193 befindet.

ipv4_mapped

Für Adressen, die wie IPv4-gemappte Adressen aussehen (beginnend mit ::FFFF/96), gibt diese Eigenschaft die eingebettete IPv4-Adresse zurück. Für jede andere Adresse ist diese Eigenschaft None.

scope_id

Für adressierte Adressen gemäß RFC 4007 identifiziert diese Eigenschaft die spezifische Zone des Adressbereichs, zu dem die Adresse gehört, als Zeichenkette. Wenn keine Scope-Zone angegeben ist, ist diese Eigenschaft None.

sixtofour

Für Adressen, die wie 6to4-Adressen aussehen (beginnend mit 2002::/16) gemäß RFC 3056, gibt diese Eigenschaft die eingebettete IPv4-Adresse zurück. Für jede andere Adresse ist diese Eigenschaft None.

teredo

Für Adressen, die wie Teredo-Adressen aussehen (beginnend mit 2001::/32) gemäß RFC 4380, gibt diese Eigenschaft das eingebettete IP-Adresspaar (server, client) zurück. Für jede andere Adresse ist diese Eigenschaft None.

IPv6Address.__format__(fmt)

Siehe die entsprechende Methodendokumentation in IPv4Address.

Hinzugefügt in Version 3.9.

Konvertierung in Zeichenketten und ganze Zahlen

Um mit Netzwerkschnittstellen wie dem Socket-Modul zu interagieren, müssen Adressen in Zeichenketten oder ganze Zahlen konvertiert werden. Dies wird mit den integrierten Funktionen str() und int() gehandhabt

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

Beachten Sie, dass IPv6-adressierte Adressen ohne Scope-Zonen-ID in ganze Zahlen konvertiert werden.

Operatoren

Adressenobjekte unterstützen einige Operatoren. Sofern nicht anders angegeben, können Operatoren nur zwischen kompatiblen Objekten angewendet werden (d. h. IPv4 mit IPv4, IPv6 mit IPv6).

Vergleichsoperatoren

Adressenobjekte können mit der üblichen Menge an Vergleichsoperatoren verglichen werden. Gleiche IPv6-Adressen mit unterschiedlichen Scope-Zonen-IDs sind nicht gleich. Einige Beispiele

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

Arithmetische Operatoren

Ganze Zahlen können zu Adressobjekten addiert oder von ihnen subtrahiert werden. Einige Beispiele

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

Die Objekte IPv4Network und IPv6Network bieten einen Mechanismus zur Definition und Inspektion von IP-Netzwerkdefinitionen. Eine Netzwerkdefinition besteht aus einer *Maske* und einer *Netzwerkadresse* und definiert somit einen Bereich von IP-Adressen, die beim Maskieren (binäres UND) mit der Maske gleich der Netzwerkadresse sind. Zum Beispiel besteht eine Netzwerkdefinition mit der Maske 255.255.255.0 und der Netzwerkadresse 192.168.1.0 aus IP-Adressen im Bereich von 192.168.1.0 bis 192.168.1.255 (einschließlich).

Präfix, Netzmaske und Hostmaske

Es gibt mehrere gleichwertige Möglichkeiten, IP-Netzmasken anzugeben. Ein *Präfix* / ist eine Notation, die angibt, wie viele High-Order-Bits in der Netzmaske gesetzt sind. Eine *Netzmaske* ist eine IP-Adresse mit einigen High-Order-Bits, die gesetzt sind. Somit entspricht das Präfix /24 der Netzmaske 255.255.255.0 in IPv4 oder ffff:ff00:: in IPv6. Zusätzlich ist eine *Hostmaske* die logische Umkehrung einer *Netzmaske* und wird manchmal (z. B. in Cisco Access Control Lists) verwendet, um eine Netzmaske zu bezeichnen. Die Hostmaske, die /24 in IPv4 entspricht, ist 0.0.0.255.

Netzwerkobjekte

Alle Attribute, die von Adressenobjekten implementiert werden, werden auch von Netzwerkobjekten implementiert. Zusätzlich implementieren Netzwerkobjekte zusätzliche Attribute. Alle diese sind zwischen IPv4Network und IPv6Network gemeinsam, daher werden sie zur Vermeidung von Redundanzen nur für IPv4Network dokumentiert. Netzwerkobjekte sind hashable, sodass sie als Schlüssel in Wörterbüchern verwendet werden können.

class ipaddress.IPv4Network(address, strict=True)

Konstruiert eine IPv4-Netzwerkdefinition. address kann eine der folgenden sein:

  1. Eine Zeichenkette, die aus einer IP-Adresse und einer optionalen Maske besteht, getrennt durch einen Schrägstrich (/). Die IP-Adresse ist die Netzwerkadresse, und die Maske kann entweder eine einzelne Zahl sein, was bedeutet, dass es sich um ein Präfix handelt, oder eine Zeichenkettenrepräsentation einer IPv4-Adresse. Wenn letzteres zutrifft, wird die Maske als Netzmaske interpretiert, wenn sie mit einem Nicht-Null-Feld beginnt, oder als Hostmaske, wenn sie mit einem Nullfeld beginnt, mit der einzigen Ausnahme einer All-Null-Maske, die als Netzmaske behandelt wird. Wenn keine Maske angegeben ist, wird sie als /32 betrachtet.

    Zum Beispiel sind die folgenden address-Spezifikationen äquivalent: 192.168.1.0/24, 192.168.1.0/255.255.255.0 und 192.168.1.0/0.0.0.255.

  2. Eine ganze Zahl, die in 32 Bits passt. Dies entspricht einem einzelnen Adressnetzwerk, wobei die Netzwerkadresse address und die Maske /32 ist.

  3. Eine ganze Zahl, verpackt in ein bytes-Objekt der Länge 4, Big-Endian. Die Interpretation ist ähnlich wie bei einer ganzzahligen Adresse.

  4. Ein Tupel aus einer Adressbeschreibung und einer Netzmaske, wobei die Adressbeschreibung entweder eine Zeichenkette, eine 32-Bit-Ganzzahl, eine 4-Byte-gepackte Ganzzahl oder ein vorhandenes IPv4Address-Objekt ist; und die Netzmaske entweder eine Ganzzahl ist, die die Präfixlänge darstellt (z. B. 24), oder eine Zeichenkette, die die Präfixmaske darstellt (z. B. 255.255.255.0).

Ein AddressValueError wird ausgelöst, wenn address keine gültige IPv4-Adresse ist. Ein NetmaskValueError wird ausgelöst, wenn die Maske für eine IPv4-Adresse ungültig ist.

Wenn strict auf True gesetzt ist und Host-Bits in der angegebenen Adresse gesetzt sind, wird ein ValueError ausgelöst. Andernfalls werden die Host-Bits maskiert, um die entsprechende Netzwerkadresse zu ermitteln.

Sofern nicht anders angegeben, lösen alle Netzwerkmethoden, die andere Netzwerk-/Adressenobjekte akzeptieren, TypeError aus, wenn die IP-Version des Arguments mit self inkompatibel ist.

Geändert in Version 3.5: Die Tupelform für den Konstruktorparameter address wurde hinzugefügt.

version
max_prefixlen

Siehe die entsprechende Attributdokumentation in IPv4Address.

is_multicast
is_private
is_unspecified
is_reserved
is_loopback

Diese Attribute sind für das gesamte Netzwerk wahr, wenn sie sowohl für die Netzwerkadresse als auch für die Broadcast-Adresse wahr sind.

network_address

Die Netzwerkadresse für das Netzwerk. Die Netzwerkadresse und die Präfixlänge definieren eindeutig ein Netzwerk.

broadcast_address

Die Broadcast-Adresse für das Netzwerk. Pakete, die an die Broadcast-Adresse gesendet werden, sollten von jedem Host im Netzwerk empfangen werden.

hostmask

Die Hostmaske als IPv4Address-Objekt.

netmask

Die Netzmaske als IPv4Address-Objekt.

with_prefixlen
compressed
exploded

Eine Zeichenkettenrepräsentation des Netzwerks mit der Maske in Präfixnotation.

with_prefixlen und compressed sind immer gleich wie str(network). exploded verwendet die aufgeblähte Form der Netzwerkadresse.

with_netmask

Eine Zeichenkettenrepräsentation des Netzwerks mit der Maske in Netzmaskennnotation.

with_hostmask

Eine Zeichenkettenrepräsentation des Netzwerks mit der Maske in Hostmaskennnotation.

num_addresses

Die Gesamtzahl der Adressen im Netzwerk.

prefixlen

Länge des Netzwerkpräfixes in Bits.

hosts()

Gibt einen Iterator über die nutzbaren Hosts im Netzwerk zurück. Die nutzbaren Hosts sind alle IP-Adressen, die zum Netzwerk gehören, außer der Netzwerkadresse selbst und der Netzwerk-Broadcast-Adresse. Für Netzwerke mit einer Maskenlänge von 31 sind die Netzwerkadresse und die Netzwerk-Broadcast-Adresse ebenfalls im Ergebnis enthalten. Netzwerke mit einer Maske von 32 geben eine Liste zurück, die die einzelne Host-Adresse enthält.

>>> 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, wenn dieses Netzwerk teilweise oder vollständig in other enthalten ist oder other vollständig in diesem Netzwerk enthalten ist.

address_exclude(network)

Berechnet die Netzwerkdefinitionen, die sich aus dem Entfernen des angegebenen network aus diesem ergeben. Gibt einen Iterator von Netzwerkobjekten zurück. Löst ValueError aus, wenn network nicht vollständig in diesem Netzwerk enthalten ist.

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

Die Teilnetze, die das aktuelle Netzwerk bilden, abhängig von den Argumentwerten. prefixlen_diff ist der Betrag, um den unsere Präfixlänge erhöht werden soll. new_prefix ist das gewünschte neue Präfix der Teilnetze; es muss größer als unser Präfix sein. Nur eines von prefixlen_diff und new_prefix darf gesetzt sein. Gibt einen Iterator von Netzwerkobjekten zurück.

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

Das Supernetz, das diese Netzwerkdefinition enthält, abhängig von den Argumentwerten. prefixlen_diff ist der Betrag, um den unsere Präfixlänge verringert werden soll. new_prefix ist das gewünschte neue Präfix des Supernetzes; es muss kleiner als unser Präfix sein. Nur eines von prefixlen_diff und new_prefix darf gesetzt sein. Gibt ein einzelnes Netzwerkobjekt zurück.

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

Gibt True zurück, wenn dieses Netzwerk ein Teilnetz von other ist.

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

Hinzugefügt in Version 3.7.

supernet_of(other)

Gibt True zurück, wenn dieses Netzwerk ein Supernetz von other ist.

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

Hinzugefügt in Version 3.7.

compare_networks(other)

Vergleicht dieses Netzwerk mit other. Bei diesem Vergleich werden nur die Netzwerkadressen berücksichtigt; Host-Bits nicht. Gibt entweder -1, 0 oder 1 zurück.

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

Veraltet seit Version 3.7: Es verwendet denselben Ordnungs- und Vergleichsalgorithmus wie „<“, „==“ und „>“

class ipaddress.IPv6Network(address, strict=True)

Konstruiert eine IPv6-Netzwerkdefinition. address kann eine der folgenden sein:

  1. Eine Zeichenkette, die aus einer IP-Adresse und einer optionalen Präfixlänge besteht, getrennt durch einen Schrägstrich (/). Die IP-Adresse ist die Netzwerkadresse, und die Präfixlänge muss eine einzelne Zahl sein, das Präfix. Wenn keine Präfixlänge angegeben ist, wird sie als /128 betrachtet.

    Beachten Sie, dass derzeit erweiterte Netzmasken nicht unterstützt werden. Das bedeutet, dass 2001:db00::0/24 ein gültiges Argument ist, während 2001:db00::0/ffff:ff00:: es nicht ist.

  2. Eine ganze Zahl, die in 128 Bits passt. Dies entspricht einem einzelnen Adressnetzwerk, wobei die Netzwerkadresse address und die Maske /128 ist.

  3. Eine ganze Zahl, verpackt in ein bytes-Objekt der Länge 16, Big-Endian. Die Interpretation ist ähnlich wie bei einer ganzzahligen Adresse.

  4. Ein Tupel aus einer Adressbeschreibung und einer Netzmaske, wobei die Adressbeschreibung entweder eine Zeichenkette, eine 128-Bit-Ganzzahl, eine 16-Byte-gepackte Ganzzahl oder ein vorhandenes IPv6Address-Objekt ist; und die Netzmaske eine Ganzzahl ist, die die Präfixlänge darstellt.

Ein AddressValueError wird ausgelöst, wenn address keine gültige IPv6-Adresse ist. Ein NetmaskValueError wird ausgelöst, wenn die Maske für eine IPv6-Adresse ungültig ist.

Wenn strict auf True gesetzt ist und Host-Bits in der angegebenen Adresse gesetzt sind, wird ein ValueError ausgelöst. Andernfalls werden die Host-Bits maskiert, um die entsprechende Netzwerkadresse zu ermitteln.

Geändert in Version 3.5: Die Tupelform für den Konstruktorparameter address wurde hinzugefügt.

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

Gibt einen Iterator über die nutzbaren Hosts im Netzwerk zurück. Die nutzbaren Hosts sind alle IP-Adressen, die zum Netzwerk gehören, außer der Subnet-Router-Anycast-Adresse. Für Netzwerke mit einer Maskenlänge von 127 sind die Subnet-Router-Anycast-Adresse ebenfalls im Ergebnis enthalten. Netzwerke mit einer Maske von 128 geben eine Liste zurück, die die einzelne Host-Adresse enthält.

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)

Siehe die entsprechende Attributdokumentation in IPv4Network.

is_site_local

Dieses Attribut ist für das gesamte Netzwerk wahr, wenn es für die Netzwerkadresse und die Broadcast-Adresse wahr ist.

Operatoren

Netzwerkobjekte unterstützen einige Operatoren. Sofern nicht anders angegeben, können Operatoren nur zwischen kompatiblen Objekten (d. h. IPv4 mit IPv4, IPv6 mit IPv6) angewendet werden.

Logische Operatoren

Netzwerkobjekte können mit dem üblichen Satz von logischen Operatoren verglichen werden. Netzwerkobjekte werden zuerst nach Netzwerkadresse und dann nach Netzmaske geordnet.

Iteration

Netzwerkobjekte können iteriert werden, um alle zum Netzwerk gehörenden Adressen aufzulisten. Für die Iteration werden alle Hosts zurückgegeben, einschließlich unbrauchbarer Hosts (für nutzbare Hosts verwenden Sie die Methode hosts()). Ein Beispiel:

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

Netzwerke als Container für Adressen

Netzwerkobjekte können als Container für Adressen fungieren. Einige Beispiele:

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

Interface-Objekte

Interface-Objekte sind hashable, daher können sie als Schlüssel in Dictionaries verwendet werden.

class ipaddress.IPv4Interface(address)

Konstruiert ein IPv4-Interface. Die Bedeutung von address ist wie im Konstruktor von IPv4Network, außer dass beliebige Host-Adressen immer akzeptiert werden.

IPv4Interface ist eine Unterklasse von IPv4Address und erbt daher alle Attribute dieser Klasse. Zusätzlich sind die folgenden Attribute verfügbar:

ip

Die Adresse (IPv4Address) ohne Netzwerkinformationen.

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

Das Netzwerk (IPv4Network), zu dem dieses Interface gehört.

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

Eine Zeichenkettenrepräsentation des Interfaces mit der Maske in Präfixnotation.

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

Eine Zeichenkettenrepräsentation des Interfaces mit dem Netzwerk als Netzmaske.

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

Eine Zeichenkettenrepräsentation des Interfaces mit dem Netzwerk als Hostmaske.

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

Konstruiert ein IPv6-Interface. Die Bedeutung von address ist wie im Konstruktor von IPv6Network, außer dass beliebige Host-Adressen immer akzeptiert werden.

IPv6Interface ist eine Unterklasse von IPv6Address und erbt daher alle Attribute dieser Klasse. Zusätzlich sind die folgenden Attribute verfügbar:

ip
network
with_prefixlen
with_netmask
with_hostmask

Siehe die entsprechende Attributdokumentation in IPv4Interface.

Operatoren

Interface-Objekte unterstützen einige Operatoren. Sofern nicht anders angegeben, können Operatoren nur zwischen kompatiblen Objekten (d. h. IPv4 mit IPv4, IPv6 mit IPv6) angewendet werden.

Logische Operatoren

Interface-Objekte können mit dem üblichen Satz von logischen Operatoren verglichen werden.

Für den Gleichheitsvergleich (== und !=) müssen sowohl die IP-Adresse als auch das Netzwerk für die Objekte gleich sein, damit sie als gleich gelten. Ein Interface wird nicht mit einem Adress- oder Netzwerkobjekt verglichen.

Für die Reihenfolge (<, >, etc.) gelten andere Regeln. Interface- und Adress-Objekte mit derselben IP-Version können verglichen werden, wobei die Adress-Objekte immer vor den Interface-Objekten sortiert werden. Zwei Interface-Objekte werden zuerst nach ihren Netzwerken und, wenn diese gleich sind, nach ihren IP-Adressen verglichen.

Andere Modul-Funktionen

Das Modul stellt auch die folgenden Modul-Funktionen bereit:

ipaddress.v4_int_to_packed(address)

Stellt eine Adresse als 4 gepackte Bytes in Netzwerk- (Big-Endian) Reihenfolge dar. address ist eine ganzzahlige Darstellung einer IPv4-IP-Adresse. Ein ValueError wird ausgelöst, wenn die Ganzzahl negativ oder zu groß für eine IPv4-IP-Adresse ist.

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

Stellt eine Adresse als 16 gepackte Bytes in Netzwerkreihenfolge (Big-Endian) dar. address ist eine ganzzahlige Darstellung einer IPv6-IP-Adresse. Ein ValueError wird ausgelöst, wenn die Ganzzahl negativ oder zu groß für eine IPv6-IP-Adresse ist.

ipaddress.summarize_address_range(first, last)

Gibt einen Iterator des zusammengefassten Netzwerkbereichs zurück, gegeben die erste und letzte IP-Adresse. first ist die erste IPv4Address oder IPv6Address im Bereich und last ist die letzte IPv4Address oder IPv6Address im Bereich. Ein TypeError wird ausgelöst, wenn first oder last keine IP-Adressen sind oder nicht von derselben Version sind. Ein ValueError wird ausgelöst, wenn last nicht größer als first ist oder wenn die first-Adressversion nicht 4 oder 6 ist.

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

Gibt einen Iterator der zusammengefassten IPv4Network- oder IPv6Network-Objekte zurück. addresses ist ein iterable von IPv4Network- oder IPv6Network-Objekten. Ein TypeError wird ausgelöst, wenn addresses gemischte Versions-Objekte enthält.

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

Gibt einen Schlüssel zurück, der für die Sortierung zwischen Netzwerken und Adressen geeignet ist. Adress- und Netzwerkobjekte sind standardmäßig nicht sortierbar; sie sind grundlegend unterschiedlich, daher ist der Ausdruck

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

nicht sinnvoll. Es gibt jedoch einige Fälle, in denen Sie möglicherweise möchten, dass ipaddress diese trotzdem sortiert. Wenn Sie dies tun müssen, können Sie diese Funktion als key-Argument für sorted() verwenden.

obj ist entweder ein Netzwerk- oder ein Adressobjekt.

Benutzerdefinierte Ausnahmen

Zur Unterstützung spezifischerer Fehlermeldungen von Konstruktoren definiert das Modul die folgenden Ausnahmen

exception ipaddress.AddressValueError(ValueError)

Jeder Wertfehler bezüglich der Adresse.

exception ipaddress.NetmaskValueError(ValueError)

Jeder Wertfehler bezüglich der Netzmaske.