Demo 2023-12-13: zip

Demo 2023-12-13: zip#

zahlen = [1, 2, 3]
aussprache = ["one", "two", "three"]

ziffern = ["1", "2", "3"]

# za ... zahlen aussprache
za = zip(zahlen, aussprache)
za

<zip at 0x7c4555f02100>

Das zip-Objekt kann man als Liste ausgeben:

list(za)

[(1, 'one'), (2, 'two'), (3, 'three')]

Ein Zip-Objekt ist ein Generator, man kann es nur einmal benutzen. Wenn man es nochmal benutzt, ist es “aufgebraucht” und liefert keine Werte mehr:

list(za)

[]

Sichern der Werte in einer Liste erzeugt n-Tupel:

za_list_3 = list(zip(zahlen, aussprache, ziffern))
za_list_3

[(1, 'one', '1'), (2, 'two', '2'), (3, 'three', '3')]

Oder ein Dict:

za_dict = dict(zip(zahlen, aussprache))
za_dict

{1: 'one', 2: 'two', 3: 'three'}

inverse Funktion von zip: gibt es unzip?#

gegeben:

za_list = list(zip(zahlen, aussprache))
za_list

[(1, 'one'), (2, 'two'), (3, 'three')]

gesucht: Die Ausgangs-Listen, die zu dieser Liste von Tupeln geführt haben – mithin als so etwas wie die inverse Funktion von zip().

Hinführung. Gegeben seien drei Tupel:

# per Hand so:
a = (1, 'one')
b = (2, 'two')
c = (3, 'three')

print(a, b, c)

(1, 'one') (2, 'two') (3, 'three')

# oder eleganter:
[ a, b, c ] = list(zip(zahlen, aussprache))

print(a, b, c)

(1, 'one') (2, 'two') (3, 'three')

Wir suchen nach einer Funktion, die beliebig viele Parameter entgegen nimmt. Eine solche kennen wir schon, nämlich print()!

za_list = list(zip(zahlen, aussprache))
print(za_list)

[(1, 'one'), (2, 'two'), (3, 'three')]

Ein großer Unterschied:

  • za_list ist eine Liste mit (hier) 3 Tupeln.

  • *za_list ist diese Liste ausgepackt, also (hier) drei Tupel.

Im folgenden übergeben wir

  • nicht eine Liste mit (hier) 3 Tupeln (also 1 Objekt)

  • sondern drei Tupel (also 3 Objekte)

an print():

# entspricht:
# print(a, b, c)
# print((1, 'one'), (2, 'two'), (3, 'three'))

print(*za_list)

(1, 'one') (2, 'two') (3, 'three')

Nochmal das gleiche noch einfacher:

  Cell In[12], line 1
    Nochmal das gleiche noch einfacher:
            ^
SyntaxError: invalid syntax

# ein einziges Objekt, hier: eine einzige Liste
print( ["Hallo", "Welt", "!"], sep="--", end="$\n" )

# drei Objekte, hier: drei Strings
print( *["Hallo", "Welt", "!"], sep="--", end="$\n"  )

['Hallo', 'Welt', '!']$
Hallo--Welt--!$

Unsere 3 Tupel a, bund c kann man zippen. Was kommt dabei heraus?

list(zip( a, b, c))

[(1, 2, 3), ('one', 'two', 'three')]

Wir haben oben gesehen, wie man die drei Objekte a, b, c aus za_list erzeugen kann. Also können wir auch schreiben:

list(zip(*za_list))

[(1, 2, 3), ('one', 'two', 'three')]

za_list haben wir ja erzeugt mit zip(zahlen, aussprache). Also geht auch das:

list(zip(*zip(zahlen, aussprache)))

[(1, 2, 3), ('one', 'two', 'three')]

Das passiert hier:

  • Wenn wir zwei Listen der (gleichen) Länge n mit zip zusammenführen, erhalten wir eine Liste von n Zweitupeln.

  • Wenn wir dann diese Liste von n mit Stern auspacken, erhalten wir n Zweitupel.

  • Diese n Zweitupel können wir dann wieder mit zip zusammenführen.

  • Als Ergebnis erhalten wir wieder eine Liste unserer ursprünglichen zwei Listen!

Wir sehen: zip mit Stern (“auspacken”) entspricht der Invers-Funktion von zip (“zusammenführen”).

Contents