ipaddress — Bibliothek zum Umgang mit IPv4 und IPv6

Quellcode: Lib/ipaddress.py

ipaddress bietet die Möglichkeit, IPv4- und IPv6-Adressen sowie -Netzwerke zu erzeugen, zu bearbeiten und mit ihnen zu arbeiten.

Die Funktionen und Klassen dieses Moduls machen verschiedene Aufgaben rund um IP-Adressen einfach: zu prüfen, ob zwei Hosts im selben Subnetz liegen, über alle Hosts eines bestimmten Subnetzes zu iterieren, zu prüfen, 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.

Added in version 3.3.

Bequeme Factory-Funktionen

Das Modul ipaddress bietet Factory-Funktionen, mit denen sich IP-Adressen, Netzwerke und Schnittstellen bequem erzeugen lassen:

ipaddress.ip_address(address)

Gibt je nach der als Argument übergebenen IP-Adresse ein IPv4Address- oder IPv6Address-Objekt zurück. Zulässig sind IPv4- und IPv6-Adressen. Ganze Zahlen kleiner als 2**32 gelten voreingestellt als IPv4. Stellt address keine gültige IPv4- oder IPv6-Adresse dar, wird ValueError ausgelöst.

>>> 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 je nach der als Argument übergebenen IP-Adresse ein IPv4Network- oder IPv6Network-Objekt zurück. address ist eine Zeichenkette oder eine ganze Zahl, die das IP-Netzwerk darstellt. Zulässig sind IPv4- und IPv6-Netzwerke. Ganze Zahlen kleiner als 2**32 gelten voreingestellt als IPv4. strict wird an den Konstruktor von IPv4Network oder IPv6Network weitergegeben. ValueError wird ausgelöst, wenn address keine gültige IPv4- oder IPv6-Adresse darstellt oder wenn im Netzwerk Host-Bits gesetzt sind.

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

Gibt je nach der als Argument übergebenen IP-Adresse ein IPv4Interface- oder IPv6Interface-Objekt zurück. address ist eine Zeichenkette oder eine ganze Zahl, die die IP-Adresse darstellt. Zulässig sind IPv4- und IPv6-Adressen. Ganze Zahlen kleiner als 2**32 gelten voreingestellt als IPv4. Stellt address keine gültige IPv4- oder IPv6-Adresse dar, wird ValueError ausgelöst.

Ein Nachteil dieser bequemen Funktionen ist, dass sie beide Formate behandeln müssen und ihre Fehlermeldungen deshalb nur wenig über den genauen Fehler verraten – sie wissen ja nicht, ob IPv4 oder IPv6 gemeint war. Genauere Fehlermeldungen bekommst du, indem du die Konstruktoren der jeweiligen versionsspezifischen Klasse direkt aufrufst.

IP-Adressen

Adressobjekte

Die Objekte IPv4Address und IPv6Address haben viele Attribute gemeinsam. Einige Attribute, die nur bei IPv6-Adressen sinnvoll sind, setzen auch IPv4Address-Objekte um, damit sich Code leichter schreiben lässt, der beide IP-Versionen richtig behandelt. Adressobjekte sind hashbar und lassen sich deshalb als Schlüssel in Dictionarys verwenden.

class ipaddress.IPv4Address(address)

Erzeugt eine IPv4-Adresse. Ist address keine gültige IPv4-Adresse, wird AddressValueError ausgelöst.

Als gültige IPv4-Adresse gilt Folgendes:

  1. Eine Zeichenkette in Dezimalpunktschreibweise aus vier Dezimalzahlen im Bereich 0–255 einschließlich, durch Punkte getrennt (z. B. 192.168.0.1). Jede Zahl steht für ein Oktett (Byte) der Adresse. Führende Nullen sind nicht erlaubt, um Verwechslungen mit der Oktalschreibweise zu vermeiden.

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

  3. Eine ganze Zahl, gepackt 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 sind erlaubt, selbst in zweideutigen Fällen, die wie Oktalschreibweise aussehen.

Geändert in Version 3.9.5: Führende Nullen sind nicht mehr erlaubt und gelten als Fehler. Zeichenketten mit IPv4-Adressen werden jetzt so streng geparst wie von inet_pton() in der glibc.

version

Die passende 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 dieser Version: 32 für IPv4, 128 für IPv6.

Das Präfix legt fest, wie viele führende Bits einer Adresse verglichen werden, um zu bestimmen, ob eine Adresse zu einem Netzwerk gehört.

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

compressed
exploded

Die Zeichenkettendarstellung in Dezimalpunktschreibweise. Führende Nullen erscheinen darin niemals.

Da IPv4 keine Kurzschreibweise für Adressen mit auf Null gesetzten Oktetten kennt, entsprechen diese beiden Attribute bei IPv4-Adressen immer str(addr). Dass sie dennoch vorhanden sind, erleichtert es, Anzeigecode zu schreiben, der mit IPv4- und IPv6-Adressen umgehen kann.

packed

Die Binärdarstellung dieser Adresse – ein bytes-Objekt passender Länge, höchstwertiges Oktett zuerst. Das sind 4 Bytes bei IPv4 und 16 Bytes bei IPv6.

reverse_pointer

Der Name des Reverse-DNS-PTR-Eintrags für die IP-Adresse, zum Beispiel:

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

Das ist der Name, mit dem sich eine PTR-Abfrage durchführen ließe, nicht der aufgelöste Hostname selbst.

Added in version 3.5.

is_multicast

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

is_private

True, wenn die Adresse laut iana-ipv4-special-registry (für IPv4) oder iana-ipv6-special-registry (für IPv6) als nicht global erreichbar festgelegt ist, mit den folgenden Ausnahmen:

  • is_private ist False für den gemeinsam genutzten Adressraum (100.64.0.0/10)

  • Bei IPv6-Adressen mit abgebildeter IPv4-Adresse ergibt sich der Wert von is_private aus der Bedeutung der zugrunde liegenden IPv4-Adresse, und es gilt die folgende Bedingung (siehe IPv6Address.ipv4_mapped):

    address.is_private == address.ipv4_mapped.is_private

is_private hat den entgegengesetzten Wert zu is_global, außer beim gemeinsam genutzten Adressraum (Bereich 100.64.0.0/10), wo beide False sind.

Geändert in Version 3.13: Einige falsch positive und falsch negative Ergebnisse behoben.

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

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

  • 2002::/16 gilt als privat.

  • Innerhalb von 2001::/23, das ansonsten als privat gilt, gibt es Ausnahmen: 2001:1::1/128, 2001:1::2/128, 2001:3::/32, 2001:4:112::/48, 2001:20::/28, 2001:30::/28. Diese Ausnahmen gelten nicht als privat.

is_global

True, wenn die Adresse laut iana-ipv4-special-registry (für IPv4) oder iana-ipv6-special-registry (für IPv6) als global erreichbar festgelegt ist, mit der folgenden Ausnahme:

Bei IPv6-Adressen mit abgebildeter IPv4-Adresse ergibt sich der Wert von is_private aus der Bedeutung der zugrunde liegenden IPv4-Adresse, und es gilt die folgende Bedingung (siehe IPv6Address.ipv4_mapped):

address.is_global == address.ipv4_mapped.is_global

is_global hat den entgegengesetzten Wert zu is_private, außer beim gemeinsam genutzten Adressraum (Bereich 100.64.0.0/10), wo beide False sind.

Added in version 3.4.

Geändert in Version 3.13: Einige falsch positive und falsch negative Ergebnisse behoben, Einzelheiten unter is_private.

is_unspecified

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

is_reserved

True, wenn die Adresse von der IETF als reserviert vermerkt ist. Bei IPv4 ist das nur 240.0.0.0/4, der Adressblock Reserved. Bei IPv6 sind es alle Adressen, die als Reserved by IETF für die künftige Verwendung zugewiesen sind.

Bemerkung

Bei IPv4 hat is_reserved nichts mit dem Adressblockwert der Spalte Reserved-by-Protocol in iana-ipv4-special-registry zu tun.

Vorsicht

Bei IPv6 ist fec0::/10, ein früheres Adresspräfix mit dem Gültigkeitsbereich Site-Local, derzeit von dieser Liste ausgenommen (siehe is_site_local und 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-lokale Verwendung reserviert ist. Siehe RFC 3927.

ipv6_mapped

IPv6Address-Objekt, das die IPv6-Adresse mit abgebildeter IPv4-Adresse darstellt. Siehe RFC 4291.

Added in version 3.13.

IPv4Address.__format__(fmt)

Gibt eine Zeichenkettendarstellung der IP-Adresse zurück, gesteuert über eine ausdrückliche Formatangabe. fmt kann eines der Folgenden sein: 's', die Voreinstellung, entspricht str(); 'b' für eine mit Nullen aufgefüllte Binärzeichenkette; 'X' oder 'x' für eine hexadezimale Darstellung in Groß- oder Kleinbuchstaben; oder 'n', was bei IPv4-Adressen 'b' und bei IPv6 'x' entspricht. Für die binäre und die hexadezimale Darstellung stehen der Formatbezeichner '#' und die Gruppierungsoption '_' zur Verfügung. __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'

Added in version 3.9.

class ipaddress.IPv6Address(address)

Erzeugt eine IPv6-Adresse. Ist address keine gültige IPv6-Adresse, wird AddressValueError ausgelöst.

Als gültige IPv6-Adresse gilt Folgendes:

  1. Eine Zeichenkette aus acht Gruppen von je vier Hexadezimalziffern, wobei jede Gruppe 16 Bit darstellt. Die Gruppen sind durch Doppelpunkte getrennt. Das ist die ausgeschriebene Langschreibweise. Die Zeichenkette lässt sich auf verschiedene Weise auch verkürzt schreiben. Einzelheiten dazu in RFC 4291. So lässt sich zum Beispiel "0000:0000:0000:0000:0000:0abc:0007:0def" zu "::abc:7:def" verkürzen.

    Wahlweise kann die Zeichenkette zusätzlich eine Scope-Zone-ID tragen, angehängt als %scope_id. Ist sie vorhanden, darf sie nicht leer sein und kein % enthalten. Einzelheiten dazu in RFC 4007. So könnte fe80::1234%1 zum Beispiel die Adresse fe80::1234 auf der ersten Verbindung des Knotens bezeichnen.

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

  3. Eine ganze Zahl, gepackt 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: führende Nullen in den Gruppen weggelassen und die längste Folge von Gruppen, die nur aus Nullen bestehen, zu einer einzigen leeren Gruppe zusammengezogen.

Das ist auch der Wert, den str(addr) bei IPv6-Adressen zurückgibt.

exploded

Die Langform der Adressdarstellung, mit allen führenden Nullen und allen Gruppen, die nur aus Nullen bestehen.

Zu den folgenden Attributen und Methoden siehe die entsprechende Dokumentation der Klasse IPv4Address:

packed
reverse_pointer
version
max_prefixlen
is_multicast
is_private
is_global

Added in version 3.4.

is_unspecified
is_reserved
is_loopback
is_site_local

True, wenn die Adresse für die Verwendung innerhalb eines Standorts (site-local) reserviert ist. Beachte, dass RFC 3879 diesen Adressraum für veraltet erklärt hat. Verwende is_private, um zu prüfen, ob diese Adresse im Raum der eindeutigen lokalen Adressen nach RFC 4193 liegt.

ipv4_mapped

Bei Adressen, die wie abgebildete IPv4-Adressen im Bereich ::FFFF:0:0/96 nach RFC 4291 aussehen, nennt diese Eigenschaft die eingebettete IPv4-Adresse. Bei jeder anderen Adresse ist sie None.

scope_id

Bei Adressen mit Gültigkeitsbereich nach RFC 4007 nennt diese Eigenschaft als Zeichenkette die Zone des Gültigkeitsbereichs, zu der die Adresse gehört. Ist keine Scope-Zone angegeben, ist sie None.

sixtofour

Bei Adressen, die wie 6to4-Adressen nach RFC 3056 aussehen, also mit 2002::/16 beginnen, nennt diese Eigenschaft die eingebettete IPv4-Adresse. Bei jeder anderen Adresse ist sie None.

teredo

Bei Adressen, die wie Teredo-Adressen nach RFC 4380 aussehen, also mit 2001::/32 beginnen, nennt diese Eigenschaft das eingebettete IP-Adresspaar (server, client). Bei jeder anderen Adresse ist sie None.

IPv6Address.__format__(fmt)

Siehe die entsprechende Methodenbeschreibung in IPv4Address.

Added in version 3.9.

Umwandlung in Zeichenketten und ganze Zahlen

Um mit Netzwerkschnittstellen wie dem Modul socket zusammenzuarbeiten, müssen Adressen in Zeichenketten oder ganze Zahlen umgewandelt werden. Das übernehmen die integrierten Funktionen str() und 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

Beachte, dass IPv6-Adressen mit Gültigkeitsbereich ohne Scope-Zone-ID in ganze Zahlen umgewandelt werden.

Operatoren

Adressobjekte unterstützen einige Operatoren. Sofern nichts anderes angegeben ist, lassen sich Operatoren nur zwischen zueinander passenden Objekten anwenden, also IPv4 mit IPv4 und IPv6 mit IPv6.

Vergleichsoperatoren

Adressobjekte lassen sich mit den üblichen Vergleichsoperatoren vergleichen. Gleiche IPv6-Adressen mit unterschiedlichen Scope-Zone-IDs sind nicht gleich. Ein paar 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

Zu Adressobjekten lassen sich ganze Zahlen addieren und von ihnen subtrahieren. Ein paar 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

Definitionen von IP-Netzwerken

Die Objekte IPv4Network und IPv6Network bieten einen Weg, Netzwerkdefinitionen festzulegen und zu untersuchen. Eine Netzwerkdefinition besteht aus einer Maske und einer Netzwerkadresse. Damit legt sie einen Bereich von IP-Adressen fest, die der Netzwerkadresse entsprechen, wenn man sie mit der Maske verknüpft (binäres UND). Eine Netzwerkdefinition mit der Maske 255.255.255.0 und der Netzwerkadresse 192.168.1.0 umfasst zum Beispiel die IP-Adressen im Bereich 192.168.1.0 bis 192.168.1.255 einschließlich.

Präfix, Netzmaske und Hostmaske

Netzmasken lassen sich auf mehrere gleichwertige Weisen angeben. Ein Präfix /<nbits> ist eine Schreibweise dafür, wie viele der höchstwertigen Bits in der Netzmaske gesetzt sind. Eine Netzmaske ist eine IP-Adresse, bei der eine Anzahl höchstwertiger Bits gesetzt ist. Das Präfix /24 entspricht damit der Netzmaske 255.255.255.0 bei IPv4 beziehungsweise ffff:ff00:: bei IPv6. Eine Hostmaske schließlich ist die logische Umkehrung einer Netzmaske und wird gelegentlich verwendet, um eine Netzmaske anzugeben, etwa in Zugriffslisten von Cisco. Die Hostmaske, die /24 bei IPv4 entspricht, ist 0.0.0.255.

Netzwerkobjekte

Netzwerkobjekte setzen alle Attribute der Adressobjekte um und darüber hinaus weitere. Diese haben IPv4Network und IPv6Network alle gemeinsam, deshalb sind sie nur bei IPv4Network beschrieben. Netzwerkobjekte sind hashbar und lassen sich deshalb als Schlüssel in Dictionarys verwenden.

class ipaddress.IPv4Network(address, strict=True)

Erzeugt eine IPv4-Netzwerkdefinition. address kann eines der Folgenden sein:

  1. Eine Zeichenkette aus einer IP-Adresse und einer optionalen Maske, getrennt durch einen Schrägstrich (/). Die IP-Adresse ist die Netzwerkadresse. Die Maske ist entweder eine einzelne Zahl, dann ist sie ein Präfix, oder die Zeichenkettendarstellung einer IPv4-Adresse. Im zweiten Fall gilt sie als Netzmaske, wenn sie mit einem Feld ungleich Null beginnt, und als Hostmaske, wenn sie mit einem Nullfeld beginnt. Die einzige Ausnahme ist eine Maske aus lauter Nullen, die als Netzmaske behandelt wird. Fehlt die Maske, gilt /32.

    Die folgenden Angaben für address sind zum Beispiel gleichwertig: 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 Bit passt. Das entspricht einem Netzwerk mit einer einzigen Adresse, wobei address die Netzwerkadresse und /32 die Maske ist.

  3. Eine ganze Zahl, gepackt in ein bytes-Objekt der Länge 4, Big-Endian. Sie wird ähnlich gedeutet wie ein address als ganze Zahl.

  4. Ein Zweiertupel aus einer Adressangabe und einer Netzmaske. Die Adressangabe ist entweder eine Zeichenkette, eine ganze Zahl mit 32 Bit, eine gepackte ganze Zahl mit 4 Bytes oder ein vorhandenes IPv4Address-Objekt. Die Netzmaske ist entweder eine ganze Zahl, die die Präfixlänge angibt (z. B. 24), oder eine Zeichenkette, die die Präfixmaske angibt (z. B. 255.255.255.0).

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

Ist strict True und sind in der übergebenen Adresse Host-Bits gesetzt, wird ValueError ausgelöst. Andernfalls werden die Host-Bits ausmaskiert, um die passende Netzwerkadresse zu bestimmen.

Sofern nichts anderes angegeben ist, lösen alle Netzwerkmethoden, die andere Netzwerk- oder Adressobjekte annehmen, TypeError aus, wenn die IP-Version des Arguments nicht zu self passt.

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

version
max_prefixlen

Siehe die entsprechende Attributbeschreibung in IPv4Address.

is_multicast
is_private
is_unspecified
is_reserved
is_loopback

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

network_address

Die Netzwerkadresse des Netzwerks. Netzwerkadresse und Präfixlänge zusammen bestimmen ein Netzwerk eindeutig.

broadcast_address

Die Broadcast-Adresse des Netzwerks. Pakete an die Broadcast-Adresse 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 Zeichenkettendarstellung des Netzwerks, mit der Maske in Präfixschreibweise.

with_prefixlen und compressed entsprechen immer str(network). exploded verwendet die ausgeschriebene Form der Netzwerkadresse.

with_netmask

Eine Zeichenkettendarstellung des Netzwerks, mit der Maske in Netzmaskenschreibweise.

with_hostmask

Eine Zeichenkettendarstellung des Netzwerks, mit der Maske in Hostmaskenschreibweise.

num_addresses

Die Gesamtzahl der Adressen im Netzwerk.

prefixlen

Länge des Netzwerkpräfixes in Bit.

hosts()

Gibt einen Iterator über die nutzbaren Hosts des Netzwerks zurück. Nutzbar sind alle IP-Adressen des Netzwerks außer der Netzwerkadresse selbst und der Broadcast-Adresse. Bei Netzwerken mit einer Maskenlänge von 31 sind Netzwerkadresse und Broadcast-Adresse im Ergebnis enthalten. Netzwerke mit der Maske 32 geben eine Liste mit der einen Hostadresse zurück.

>>> 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 liegt oder other vollständig in diesem Netzwerk liegt.

address_exclude(network)

Berechnet die Netzwerkdefinitionen, die entstehen, wenn man das angegebene network aus diesem entfernt. Gibt einen Iterator über Netzwerkobjekte zurück. Löst ValueError aus, wenn network nicht vollständig in diesem Netzwerk liegt.

>>> 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 Subnetze, die zusammen die aktuelle Netzwerkdefinition ergeben, je nach den übergebenen Werten. 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 Subnetze und muss größer sein als unser Präfix. Genau eines von prefixlen_diff und new_prefix muss gesetzt sein. Gibt einen Iterator über Netzwerkobjekte 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, je nach den übergebenen Werten. 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 und muss kleiner sein als unser Präfix. Genau eines von prefixlen_diff und new_prefix muss 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 Subnetz von other ist.

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

Added 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

Added in version 3.7.

compare_networks(other)

Vergleicht dieses Netzwerk mit other. Dabei zählen nur die Netzwerkadressen, die Host-Bits nicht. Gibt -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 ab Version 3.7: Es verwendet dieselbe Sortier- und Vergleichslogik wie „<“, „==“ und „>“

class ipaddress.IPv6Network(address, strict=True)

Erzeugt eine IPv6-Netzwerkdefinition. address kann eines der Folgenden sein:

  1. Eine Zeichenkette aus einer IP-Adresse und einer optionalen Präfixlänge, getrennt durch einen Schrägstrich (/). Die IP-Adresse ist die Netzwerkadresse, und die Präfixlänge muss eine einzelne Zahl sein, das Präfix. Fehlt die Präfixlänge, gilt /128.

    Beachte, dass ausgeschriebene Netzmasken derzeit nicht unterstützt werden. 2001:db00::0/24 ist also ein gültiges Argument, 2001:db00::0/ffff:ff00:: dagegen nicht.

  2. Eine ganze Zahl, die in 128 Bit passt. Das entspricht einem Netzwerk mit einer einzigen Adresse, wobei address die Netzwerkadresse und /128 die Maske ist.

  3. Eine ganze Zahl, gepackt in ein bytes-Objekt der Länge 16, Big-Endian. Sie wird ähnlich gedeutet wie ein address als ganze Zahl.

  4. Ein Zweiertupel aus einer Adressangabe und einer Netzmaske. Die Adressangabe ist entweder eine Zeichenkette, eine ganze Zahl mit 128 Bit, eine gepackte ganze Zahl mit 16 Bytes oder ein vorhandenes IPv6Address-Objekt. Die Netzmaske ist eine ganze Zahl, die die Präfixlänge angibt.

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

Ist strict True und sind in der übergebenen Adresse Host-Bits gesetzt, wird ValueError ausgelöst. Andernfalls werden die Host-Bits ausmaskiert, um die passende Netzwerkadresse zu bestimmen.

Geändert in Version 3.5: Die Zweiertupel-Form 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 des Netzwerks zurück. Nutzbar sind alle IP-Adressen des Netzwerks außer der Subnet-Router-Anycast-Adresse. Bei Netzwerken mit einer Maskenlänge von 127 ist die Subnet-Router-Anycast-Adresse im Ergebnis enthalten. Netzwerke mit der Maske 128 geben eine Liste mit der einen Hostadresse zurück.

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 Attributbeschreibung in IPv4Network.

is_site_local

Dieses Attribut ist für das Netzwerk als Ganzes wahr, wenn es sowohl für die Netzwerkadresse als auch für die Broadcast-Adresse wahr ist.

Operatoren

Netzwerkobjekte unterstützen einige Operatoren. Sofern nichts anderes angegeben ist, lassen sich Operatoren nur zwischen zueinander passenden Objekten anwenden, also IPv4 mit IPv4 und IPv6 mit IPv6.

Logische Operatoren

Netzwerkobjekte lassen sich mit den üblichen logischen Operatoren vergleichen. Sie sind zuerst nach Netzwerkadresse und dann nach Netzmaske geordnet.

Iteration

Über Netzwerkobjekte lässt sich iterieren, um alle Adressen des Netzwerks aufzulisten. Dabei werden alle Hosts zurückgegeben, auch die nicht nutzbaren – für die nutzbaren gibt es 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 von Adressen

Netzwerkobjekte können als Container von Adressen auftreten. Ein paar 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

Schnittstellenobjekte

Schnittstellenobjekte sind hashbar und lassen sich deshalb als Schlüssel in Dictionarys verwenden.

class ipaddress.IPv4Interface(address)

Erzeugt eine IPv4-Schnittstelle. address bedeutet dasselbe wie im Konstruktor von IPv4Network, nur dass beliebige Hostadressen immer angenommen werden.

IPv4Interface ist eine Unterklasse von IPv4Address und erbt daher alle Attribute dieser Klasse. Zusätzlich stehen die folgenden Attribute zur Verfügung:

ip

Die Adresse (IPv4Address) ohne Netzwerkangaben.

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

Das Netzwerk (IPv4Network), zu dem diese Schnittstelle gehört.

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

Eine Zeichenkettendarstellung der Schnittstelle mit der Maske in Präfixschreibweise.

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

Eine Zeichenkettendarstellung der Schnittstelle 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 Zeichenkettendarstellung der Schnittstelle 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)

Erzeugt eine IPv6-Schnittstelle. address bedeutet dasselbe wie im Konstruktor von IPv6Network, nur dass beliebige Hostadressen immer angenommen werden.

IPv6Interface ist eine Unterklasse von IPv6Address und erbt daher alle Attribute dieser Klasse. Zusätzlich stehen die folgenden Attribute zur Verfügung:

ip
network
with_prefixlen
with_netmask
with_hostmask

Siehe die entsprechende Attributbeschreibung in IPv4Interface.

Operatoren

Schnittstellenobjekte unterstützen einige Operatoren. Sofern nichts anderes angegeben ist, lassen sich Operatoren nur zwischen zueinander passenden Objekten anwenden, also IPv4 mit IPv4 und IPv6 mit IPv6.

Logische Operatoren

Schnittstellenobjekte lassen sich mit den üblichen logischen Operatoren vergleichen.

Beim Gleichheitsvergleich (== und !=) müssen IP-Adresse und Netzwerk übereinstimmen, damit die Objekte gleich sind. Eine Schnittstelle ist niemals gleich einem Adress- oder Netzwerkobjekt.

Beim Sortieren (<, > und so weiter) gelten andere Regeln. Schnittstellen- und Adressobjekte derselben IP-Version lassen sich vergleichen, wobei die Adressobjekte immer vor den Schnittstellenobjekten einsortiert werden. Zwei Schnittstellenobjekte werden zuerst nach ihren Netzwerken verglichen und, wenn diese gleich sind, nach ihren IP-Adressen.

Weitere Funktionen auf Modulebene

Das Modul bietet außerdem die folgenden Funktionen auf Modulebene:

ipaddress.v4_int_to_packed(address)

Stellt eine Adresse als 4 gepackte Bytes in Netzwerkreihenfolge (Big-Endian) dar. address ist eine IPv4-Adresse als ganze Zahl. ValueError wird ausgelöst, wenn die Zahl negativ oder für eine IPv4-Adresse zu groß 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 IPv6-Adresse als ganze Zahl. ValueError wird ausgelöst, wenn die Zahl negativ oder für eine IPv6-Adresse zu groß ist.

ipaddress.summarize_address_range(first, last)

Gibt einen Iterator über den zusammengefassten Netzwerkbereich zwischen der ersten und der letzten IP-Adresse zurück. first ist die erste IPv4Address oder IPv6Address des Bereichs, last die letzte IPv4Address oder IPv6Address des Bereichs. TypeError wird ausgelöst, wenn first oder last keine IP-Adressen sind oder nicht dieselbe Version haben. ValueError wird ausgelöst, wenn last nicht größer ist als first oder wenn die Adressversion von first 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 über die zusammengefassten IPv4Network- oder IPv6Network-Objekte zurück. addresses ist ein Iterable aus IPv4Network- oder IPv6Network-Objekten. TypeError wird ausgelöst, wenn addresses Objekte verschiedener Versionen 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, mit dem sich Netzwerke und Adressen gemeinsam sortieren lassen. Adress- und Netzwerkobjekte sind voreingestellt nicht sortierbar, denn sie sind grundlegend verschieden. Der Ausdruck:

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

ist also sinnlos. Es gibt aber Fälle, in denen ipaddress sie trotzdem sortieren soll. Dann kannst du diese Funktion als Argument key an sorted() übergeben.

obj ist entweder ein Netzwerk- oder ein Adressobjekt.

Eigene Ausnahmen

Damit die Konstruktoren der Klassen genauer über Fehler berichten können, definiert das Modul die folgenden Ausnahmen:

exception ipaddress.AddressValueError(ValueError)

Jeder Wertefehler, der die Adresse betrifft.

exception ipaddress.NetmaskValueError(ValueError)

Jeder Wertefehler, der die Netzmaske betrifft.