Python, Verwendung der Funktion zip(): Die Elemente mehrerer Listen auf einmal erhalten

Geschäft

Pythons eingebaute Funktion zip() kombiniert die Elemente mehrerer iterierbarer Objekte (Listen, Tupel usw.) und wird verwendet, um die Elemente mehrerer Listen in einer for-Schleife abzurufen.

Dieser Abschnitt beschreibt die folgende Verwendung der Funktion zip().

  • Abrufen der Elemente mehrerer Listen in einer for-Schleife.
  • Umgang mit unterschiedlicher Anzahl von Elementen
    • zip():Die Funktion ignoriert die Elemente, die zu viel sind.
    • itertools.zip_longest():Mit dieser Funktion werden die fehlenden Elemente ergänzt.
  • Abrufen einer Liste von Tupeln von Elementen mehrerer Iterables.

Abrufen der Elemente mehrerer Listen in einer for-Schleife.

Wenn Sie die Elemente mehrerer iterabler Objekte (Listen, Tupel usw.) gleichzeitig in einer for-Schleife abrufen und verwenden wollen, geben Sie sie als Argumente für die Funktion zip() an.

names = ['Alice', 'Bob', 'Charlie']
ages = [24, 50, 18]

for name, age in zip(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18

Nicht nur zwei, sondern auch drei oder mehr.

points = [100, 85, 90]

for name, age, point in zip(names, ages, points):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 90

Umgang mit unterschiedlicher Anzahl von Elementen

Die Funktion zip() ignoriert eine große Anzahl von Elementen.

Bei der Funktion zip() wird, wenn die Anzahl der Elemente in den beiden Listen unterschiedlich ist, die kleinere (kürzere) Anzahl von Elementen zurückgegeben und die größere Anzahl ignoriert.

names = ['Alice', 'Bob', 'Charlie', 'Dave']
ages = [24, 50, 18]

for name, age in zip(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18

Die Funktion itertools.zip_longest() füllt die fehlenden Elemente aus.

Mit zip_longest() in der Standardbibliothek des itertools-Moduls ist es möglich, die fehlenden Elemente mit beliebigen Werten aufzufüllen, wenn die Anzahl der Elemente in jeder Liste unterschiedlich ist.

Standardmäßig ist es mit None gefüllt.

from itertools import zip_longest

names = ['Alice', 'Bob', 'Charlie', 'Dave']
ages = [24, 50, 18]

for name, age in zip_longest(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18
# Dave None

Wenn das Argument fillvalue angegeben ist, wird es mit diesem Wert gefüllt.

for name, age in zip_longest(names, ages, fillvalue=20):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18
# Dave 20

Auch wenn es mehrere Listen mit fehlenden Elementen gibt, ist der zu füllende Wert einheitlich. Es ist nicht möglich, unterschiedliche Werte anzugeben.

points = [100, 85]

for name, age, point in zip_longest(names, ages, points, fillvalue=20):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 20
# Dave 20 20

Es ist möglich, einen anderen Wert anzugeben, indem man zip_longest() innerhalb von zip_longest() verwendet, aber es ist nicht praktisch, weil man im Voraus wissen muss, welche Elemente der Liste fehlen.

Wenn Sie mehrere Listen mit einer unbekannten Anzahl von Elementen füllen wollen, die jeweils einen anderen Wert haben, können Sie folgendes Verfahren in Betracht ziehen.

  1. Definieren Sie Werte, die für alle Listen ausgefüllt werden sollen.
  2. Ermitteln der maximalen Anzahl von Elementen
  3. Füllen Sie alle Listen bis zur maximalen Anzahl von Elementen
  4. Verwendung der Funktion zip()
fill_name = 'XXX'
fill_age = 20
fill_point = 50

len_names = len(names)
len_ages = len(ages)
len_points = len(points)

max_len = max(len_names, len_ages, len_points)

names = names + [fill_name] * (max_len - len_names)
ages = ages + [fill_age] * (max_len - len_ages)
points = points + [fill_point] * (max_len - len_points)

print(names)
print(ages)
print(points)
# ['Alice', 'Bob', 'Charlie', 'Dave']
# [24, 50, 18, 20]
# [100, 85, 50, 50]

for name, age, point in zip(names, ages, points):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 50
# Dave 20 50

Bei der Auffüllung bis zur größten Anzahl von Elementen gehen wir wie folgt vor.

  • Initialisierung einer Liste mit einem beliebigen Wert und einer beliebigen Anzahl von Elementen
  • + Operator zum Verbinden von Listen

Wenn wir dies in eine Funktion umwandeln, sieht sie wie folgt aus. Die ursprüngliche Liste und die Werte, die die Liste füllen, werden als iterierbare Argumente (Liste oder Tupel) angegeben.

def my_zip_longest(iterables, fillvalues):
    max_len = max(len(i) for i in iterables)
    return zip(*[list(i) + [v] * (max_len - len(i)) for i, v in zip(iterables, fillvalues)])

for name, age, point in my_zip_longest((names, ages, points), ('XXX', 20, 50)):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 50
# Dave 20 50

Sie verwendet die Notation des Listenverständnisses und die Listenerweiterung durch *.

Abrufen einer Liste von Tupeln von Elementen mehrerer Iterables.

Die Funktion zip() gibt einen Iterator (zip-Objekt) zurück, der ein Tupel von Elementen mehrerer iterierbarer Objekte ist.
Sie kann auch außerhalb der for-Schleife verwendet werden, und das Ziel ist nicht auf Listen beschränkt.

names = ['Alice', 'Bob', 'Charlie']
ages = (24, 50, 18)

z = zip(names, ages)
print(z)
print(type(z))
# <zip object at 0x10b57b888>
# <class 'zip'>

Wenn Sie eine Liste der Elemente mehrerer iterabler Objekte als Tupel erhalten möchten, verwenden Sie list(), um eine Liste zu erstellen.

l = list(zip(names, ages))
print(l)
print(type(l))
print(type(l[0]))
# [('Alice', 24), ('Bob', 50), ('Charlie', 18)]
# <class 'list'>
# <class 'tuple'>
Copied title and URL