Die zip()-Funktion in Python

In Python und allen Programmiersprachen können wir for- und while-Schleifen verwenden, um über Arrays zu iterieren. Das Iterieren über ein einzelnes Array ist sehr einfach. Wenn es jedoch darum geht, über mehrere Arrays zusammen zu iterieren, werden die Dinge komplex. Wenn die Größe aller Arrays gleich ist, dann ist es eine einfache Aufgabe. Aber wenn Array-Größen unterschiedlich sind, müssen wir sicherstellen, dass wir nur die Länge des kleinsten Arrays berücksichtigen, um Fehler und Ausnahmen zu vermeiden.

Python macht diese Aufgabe viel einfacher. Anstatt manuell Logik zum Iterieren über Arrays unterschiedlicher Größe zu schreiben, können wir ein eingebautes Dienstprogramm verwenden, genauer gesagt eine Funktion, die von Python bereitgestellt wird. Diese Funktion ist die zip()-Funktion.

Dieser Artikel stellt die Funktion zip() und ihre Verwendung vor.

Die Funktion zip() in Python

Die Funktion zip() akzeptiert iterierbare Objekte wie Listen, Strings und Tupel als Argumente und gibt ein einzelnes Iterable zurück.

Das zurückgegebene iterierbare Objekt hat die Länge des kleinsten iterierbaren Objekts. Wenn beispielsweise zwei Listen der Größe 5 und 10 an die Funktion zip() übergeben werden, hat das zurückgegebene iterierbare Objekt eine Länge von 5. Das bedeutet, dass nur die ersten 5 Elemente der zweiten Liste Teil des iterierbaren Objekts sind. Wenn dieser Funktion ein leeres iterierbares oder kein iterierbares Objekt übergeben wird, gibt sie auch ein leeres iterierbares Objekt zurück.

Nun, da wir mit der Theorie fertig sind, wollen wir sehen, wie man diese Funktion verwendet. Sehen Sie sich die folgenden Beispiele an, um seine Verwendung zu verstehen.

Kein iterierbares Objekt

Im folgenden Python-Code wird kein iterierbares Objekt an die Funktion zip() übergeben.

result = zip()

for x in result:
    print(x)

Nichts wird auf der Konsole gedruckt, wenn wir den obigen Code ausführen. Der Grund dafür ist einfach; Wenn kein iterierbares Objekt bereitgestellt würde, hätten wir nichts zu iterieren. Daher wird ein leeres iterierbares Objekt zurückgegeben.

Iterierbare Objekte gleicher Länge

Im folgenden Python-Code werden ein Tupel aus ganzen Zahlen, eine Liste mit Gleitkommawerten, eine Liste mit Klassenobjekten und ein gleich langer String an die Funktion zip() übergeben.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33, 44, 55)
b = [1.1, 2.2, 3.3, 4.4, 5.5]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "Hello"
result = zip(a, b, c, d)

for x in result:
    print(x)

Ausgabe:

(11, 1.1, Number(1), 'H')
(22, 2.2, Number(23), 'e')
(33, 3.3, Number(44.44), 'l')
(44, 4.4, Number(0), 'l')
(55, 5.5, Number(-9), 'o')

Wie wir sehen können, speichert die Funktion zip() Werte über alle iterierbaren Objekte hinweg zusammen in Tupeln. Die Reihenfolge der Werte innerhalb der Tupel ist dieselbe wie die Reihenfolge, in der ihre iterierbaren Objekte der Funktion zip() bereitgestellt wurden.

Wir können diese Werte innerhalb der for-Schleife für einen einfachen Zugriff destrukturieren oder entpacken. Siehe dazu den folgenden Code.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33, 44, 55)
b = [1.1, 2.2, 3.3, 4.4, 5.5]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "Hello"
result = zip(a, b, c, d)

for p, q, r, s in result:
    print("A:", p)
    print("B:", q)
    print("C:", r)
    print("D:", s)

Ausgabe:

A: 11
B: 1.1
C: Number(1)
D: H
A: 22
B: 2.2
C: Number(23)
D: e
A: 33
B: 3.3
C: Number(44.44)
D: l
A: 44
B: 4.4
C: Number(0)
D: l
A: 55
B: 5.5
C: Number(-9)
D: o

Anstatt for-Schleifen zu verwenden, können wir auch mit einer while-Schleife über ein iterierbares Objekt iterieren. Bei while-Schleifen würden wir zwei zusätzliche Dinge benötigen, die next()-Funktion und einen try-except-Block. Die Funktion next() wird verwendet, um Werte aus dem iterierbaren Objekt abzurufen, das von der Funktion zip() zurückgegeben wird, und der Block try...except wird verwendet, um die Iteration zu stoppen. Siehe dazu den folgenden Python-Code.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33, 44, 55)
b = [1.1, 2.2, 3.3, 4.4, 5.5]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "Hello"
result = zip(a, b, c, d)

while True:
    try:
        p, q, r, s = next(result)
        print("A:", p)
        print("B:", q)
        print("C:", r)
        print("D:", s)
    except StopIteration:
        break

Ausgabe:

A: 11
B: 1.1
C: Number(1)
D: H
A: 22
B: 2.2
C: Number(23)
D: e
A: 33
B: 3.3
C: Number(44.44)
D: l
A: 44
B: 4.4
C: Number(0)
D: l
A: 55
B: 5.5
C: Number(-9)
D: o

Wenn innerhalb eines Iterators keine Werte verfügbar sind, wird eine StopIteration-Ausnahme ausgelöst. Mit einem try-except-Block fangen wir diese Ausnahme ab und verlassen die while-Endlosschleife.

Iterierbare Objekte unterschiedlicher Länge

Im folgenden Python-Code wird der Funktion zip() ein Tupel aus ganzen Zahlen, eine Liste mit Gleitkommawerten, eine Liste mit Klassenobjekten und ein String unterschiedlicher Länge übergeben.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33)
b = [1.1, 2.2, 3.3, 4.4]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "HelloWorld"
result = zip(a, b, c, d)

for p, q, r, s in result:
    print("A:", p)
    print("B:", q)
    print("C:", r)
    print("D:", s)

Ausgabe:

A: 11
B: 1.1
C: Number(1)
D: H
A: 22
B: 2.2
C: Number(23)
D: e
A: 33
B: 3.3
C: Number(44.44)
D: l

Alle iterierbaren Objekte haben unterschiedliche Längen. Das erste iterierbare Objekt oder Tupel von ganzen Zahlen hat die kleinste Länge, 3. Daher gibt die Ausgabe nur die ersten 3 Werte von allen iterierbaren Objekten aus.

Erstellen eines Wörterbuchs

Mit Hilfe der Funktion zip() können wir ein Dictionary von Schlüssel-Wert-Paaren erstellen. Die Idee besteht darin, einen Iterator aus zwei Arrays gleicher Länge zu erstellen, die Schlüssel und ihre jeweiligen Werte enthalten, und sie in einem Dictionary einander zuzuordnen, während das zurückgegebene iterierbare Objekt durchlaufen wird. Siehe dazu den folgenden Code.

import json

a = ["W", "O", "R", "L", "D"]
b = [1.1, True, "Hello", None, 5]
result = zip(a, b)
mapping = {x: y for x, y in result}
print(json.dumps(mapping, indent=4))

Ausgabe:

{
    "W": 1.1,
    "O": true,
    "R": "Hello",
    "L": null,
    "D": 5
}

Der obige Code verwendet nur das json-Modul, um die Ausgabe des Wörterbuchs zu verschönern. Beachten Sie, dass die Verwendung völlig optional ist.

Verwenden der Funktion zip() zusammen mit der Funktion enumerate()

Die Funktion enumerate() wird verwendet, um den Index und den Wert gleichzeitig zu erhalten, während über ein iterierbares Objekt iteriert wird. Da die Funktion zip() einen Iterator zurückgibt, können wir die beiden Funktionen zusammenlegen und haben Zugriff auf die Indizes und die Werte. Siehe dazu den folgenden Python-Code.

class Number:
    def __init__(self, number):
        self.number = number

    def square(self):
        return number ** 2

    def __repr__(self):
        return f"Number({self.number})"


a = (11, 22, 33)
b = [1.1, 2.2, 3.3, 4.4]
c = [Number(1), Number(23), Number(44.44), Number(0), Number(-9)]
d = "HelloWorld"
result = zip(a, b, c, d)

for i, (p, q, r, s) in enumerate(result):
    print(f"A{i + 1}:", p)
    print(f"B{i + 1}:", q)
    print(f"C{i + 1}:", r)
    print(f"D{i + 1}:", s)

Ausgabe:

A1: 11
B1: 1.1
C1: Number(1)
D1: H
A2: 22
B2: 2.2
C2: Number(23)
D2: e
A3: 33
B3: 3.3
C3: Number(44.44)
D3: l

Im obigen Python-Code entpackt innerhalb der for-Schleife i, (p, q, r, s) die von der Funktion enumerate() zurückgegebenen Werte und (p, q, r, s) Entpacken Sie die von der Funktion zip() zurückgegebenen Werte.

Die von der Funktion enumerate() zurückgegebenen Werte haben das folgende Format.

(0, (11, 1.1, Number(1), "H"))
(1, (22, 2.2, Number(23), "e"))
(2, (33, 3.3, Number(44.44), "l"))

Es verdeutlicht, warum i, (p, q, r, s) verwendet wurde, um alle Werte zu entpacken.