Weitere Datentypen

Weitere Datentypen#

In Python gibt es neben den bisher besprochenen Datentypen (Integer, Float, String, Boolean) noch weitere wichtige Datentypen:

  • Listen (Lists)

  • Tupel (Tuples)

  • Mengen (Sets)

  • Wörterbücher (Dictionaries)

Je nach Anwendungsfall spart man sich sehr viel Arbeit, wenn man einen passenden Datentyp verwendet.

Listen (Lists)#

Listen sind geordnete Sammlungen von Elementen, die veränderbar sind. Sie werden mit eckigen Klammern [] definiert und die Elemente werden durch Kommas getrennt.

my_list = [1, 2, 3, 4, 5]
print("my_list =", my_list)

my_list = [1, 2, 3, 4, 5]

Wichtige Operationen mit Listen#

Listen können Elemente unterschiedlichen Typs enthalten, z.B. Integer, Float, String, etc. und können verschachtelt sein (Listen in Listen). Die leere Liste wird mit [] oder list() erstellt.

  • Listen können addiert (verkettet) werden mit +

  • Listen können mit * vervielfacht werden

  • Elemente können mit in auf Zugehörigkeit geprüft werden

  • Listen können mit len() auf ihre Länge geprüft werden

  • mit dem Indexoperator [] können Elemente gelesen und geschrieben werden (Achtung: Indizes beginnen bei 0 und enden bei len(...)-1)

  • mittels append() können Elemente an das Ende der Liste angehängt werden

  • mittels remove() können Elemente aus der Liste entfernt werden (erstes Vorkommen)

  • mittels sort() können Listen sortiert werden (nur wenn alle Elemente vergleichbar sind)

my_list = [5, 3, 1, 4, 2]
my_list[0] = 10
print("my_list =", my_list, "len(my_list) =", len(my_list))
my_list.append(6)
print("after append:")
print("my_list =", my_list, "len(my_list) =", len(my_list))
my_list.remove(3)
print("after remove:")
print("my_list =", my_list, "len(my_list) =", len(my_list))
my_list.sort()
print("after sort:")
print("my_list =", my_list)

my_list = [10, 3, 1, 4, 2] len(my_list) = 5
after append:
my_list = [10, 3, 1, 4, 2, 6] len(my_list) = 6
after remove:
my_list = [10, 1, 4, 2, 6] len(my_list) = 5
after sort:
my_list = [1, 2, 4, 6, 10]

a = [1, 2, 3]
b = [4, 5, 6]
print("a + b:", a + b)
print("a * 3:", a * 3)
print("Ist 3 in a:", 3 in a)

a + b: [1, 2, 3, 4, 5, 6]
a * 3: [1, 2, 3, 1, 2, 3, 1, 2, 3]
Ist 3 in a: True

Entpacken von Listen#

Listen können auch “entpackt” werden, d.h. die Elemente der Liste werden einzelnen Variablen zugewiesen.

  • Die Anzahl der Variablen muss mit der Anzahl der Elemente in der Liste übereinstimmen.

  • Das “Wildcard”-Zeichen _ kann verwendet werden, um Elemente zu ignorieren.

    • Tatsächlich ist _ nur eine normale Variable, die aber konventionell verwendet wird, um anzuzeigen, dass der Wert ignoriert wird.

my_list = [1,2,3]
a, b, c = my_list
print(a, b, c)
a, _, c = my_list
print(a, c)

1 2 3
1 3

Slicing#

Mit dem Indexoperator [] können auch Bereiche (Slices) von Listen extrahiert werden. Die Syntax dafür ist list[start:stop:step], wobei start der Anfangsindex (inklusive), stop der Endindex (exklusive) und step die Schrittweite ist. Alle drei Parameter sind optional. Das letzte Element kann mit -1 angesprochen werden.

my_list = [1,2,3,4,5,6,7,8,9,10]
print("Jedes zweite Element bis zur fünften Position:", my_list[0:5:2])
print("Letztes Element:", my_list[-1])
print("Ersten drei Elemente:", my_list[:3])
print("Jedes zweite Element:", my_list[::2])
print("Umgekehrte Liste:", my_list[::-1])

Jedes zweite Element bis zur fünften Position: [1, 3, 5]
Letztes Element: 10
Ersten drei Elemente: [1, 2, 3]
Jedes zweite Element: [1, 3, 5, 7, 9]
Umgekehrte Liste: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Listen haben noch viele weitere nützliche Funktionen

  • insert(): Fügt ein Element an einer bestimmten Position ein.

  • pop(i): Entfernt und gibt das i-te Element der Liste zurück (oder das letzte falls der Parameter i weggelassen wird).

  • reverse(): Kehrt die Reihenfolge der Elemente in der Liste um, equivalent zu list[::-1].

  • index(): Gibt den Index des ersten Vorkommens eines Elements zurück.

  • count(): Zählt, wie oft ein Element in der Liste vorkommt.

  • clear(): Entfernt alle Elemente aus der Liste.

  • copy(): Erstellt eine Kopie der Liste.

  • extend(): Fügt die Elemente einer anderen Liste an das Ende der Liste an.

Zusätzlich gibt es die eingebaute Funktionen:

  • min(): Gibt das kleinste Element in der Liste zurück.

  • max(): Gibt das größte Element in der Liste zurück.

  • sum(): Gibt die Summe der Elemente in der Liste zurück (nur für numerische Listen geeignet).

  • sorted(): Gibt eine sortierte Kopie der Liste zurück, ohne die Original-Liste zu verändern.

  • all(): Gibt True zurück, wenn alle Elemente in der Liste wahr sind.

  • any(): Gibt True zurück, wenn mindestens ein Element in der Liste wahr ist.

my_list = [1, 2, 3]
print("Minimalwert:", min(my_list))
print("Maximalwert:", max(my_list))
print("Summe:", sum(my_list))   

Minimalwert: 1
Maximalwert: 3
Summe: 6

Der del Operator#

Der del Operator wird verwendet um Python Objekte zu löschen.

  • del variable löscht die Variable und gibt den Speicherplatz frei.

  • del list[index] löscht das Element an der angegebenen Position in der Liste

  • del list[start:stop] löscht einen Bereich von Elementen in der Liste

my_list = ["Hello", "my", "name", "is", "Python"]
del my_list[1:4]
print(my_list)

['Hello', 'Python']

Der * Operator#

Der * Operator hat in Python mehrere Bedeutungen, abhängig vom Kontext:

  • In mathematischen Ausdrücken wird * als Multiplikationsoperator verwendet, z.B. 3 * 4 ergibt 12.

  • In Listen und Tupeln wird * verwendet, um eine Liste oder ein Tupel (siehe unten) zu “entpacken” und in einzelne Elemente zu zerlegen

    • bei der Zuweisung a, b, c = [1, 2, 3] wird das automatisch gemacht, weiteres Entpacken mit * funktioniert nicht

    • bei Funktionsaufrufen (später) kann eine Liste oder ein Tupel mit * entpackt werden

my_list = [1,2,3]
print(my_list)
print(*my_list)  # Entpacken der Liste in einzelne Argumente

[1, 2, 3]
1 2 3

my_list = [1,2,3]
a, b, c = my_list
print(a, b, c)

1 2 3

Geschachtelte Listen#

Listen können auch andere Listen als Elemente enthalten, was zu geschachtelten Listen führt. Diese können beliebig tief verschachtelt sein. Für die Mathematik sind solche Strukturen z.B. nützlich, um Matrizen zu repräsentieren. Eine Matrix

\[\begin{split} M = \begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{pmatrix} \in \mathbb{R}^{3 \times 3} \end{split}\]

kann in Python als Liste von Listen dargestellt werden:

M = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]

Um auf Elemente in geschachtelten Listen zuzugreifen, verwendet man mehrere Indizes. Der erste Index gibt die äußere Liste an, der zweite Index die innere Liste. Zum Beispiel:

M[0][1] 

M = [[1,2,3],
     [4,5,6], 
     [7,8,9]]
print(M)
print(M[0])
print(M[0][1])

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[1, 2, 3]
2

Listen und Strings#

Strings können ähnlich wie Listen behandelt werden, da sie eine Sequenz von Zeichen sind. Viele der Operationen, die auf Listen angewendet werden können, funktionieren auch auf Strings, z.B. Indexierung, Slicing und die Verwendung von len(). Allerdings sind Strings unveränderlich (immutable), d.h. einmal erstellt, können sie nicht mehr verändert werden. Bei der Bearbeitung von Strings wird immer ein neuer String erzeugt.

Es gibt außerdem noch die nützliche Methode join(), die eine Liste von Strings zu einem einzigen String verbindet, wobei ein bestimmter Trenner verwendet wird. Zum Beispiel:

words = ["Word1", "Word2", "Word3"]
sentence = "-".join(words)

erzeugt den String "Word1-Word2-Word3", wobei "-" der Trenner ist und durch jede beliebige Zeichenkette ersetzt werden kann.

Die Methode split() teilt einen String in eine Liste von Substrings auf, basierend auf einem angegebenen Trenner. Standardmäßig wird an Leerzeichen geteilt. Zum Beispiel:

text = "Hello, World!"
words = text.split(", ")

erzeugt die Liste ["Hello", "World!"], wobei ", " der Trenner ist und durch jede beliebige Zeichenkette ersetzt werden kann.

text = "Hello, World!"
print(text[:5])
print(text[7:])
words = text.split(", ")
print(words)
rejoined = ", ".join(words)
print(rejoined)

Hello
World!
['Hello', 'World!']
Hello, World!

Bereiche (Ranges)#

Bereiche sind eine spezielle Art von Listen, die eine Folge von Zahlen in einem bestimmten Bereich darstellen. Sie werden mit der range()-Funktion erstellt und sind besonders nützlich in Schleifen (später mehr dazu).

range(start, stop, step)

  • start: Anfangswert (inklusive, Standard ist 0)

  • stop: Endwert (exklusive)

  • step: Schrittweite (Standard ist 1)

Man kann ‘start’ und/oder ‘step’ weglassen, um die Standardwerte zu verwenden. Außerhalb von Schleifen (später mehr dazu) werden Ranges oft verwendet um Listen zu erzeugen

print(range(5))
print(list(range(5)))
print(list(range(2, 10)))
print(list(range(2, 10, 2)))

range(0, 5)
[0, 1, 2, 3, 4]
[2, 3, 4, 5, 6, 7, 8, 9]
[2, 4, 6, 8]

List Comprehensions#

Man kann mit Ranges die mathematische Mengendefinition, z.B. \(\{2x+1 \mid x\in \mathbb{N},\, 2\leq x<10\}\), imitieren

my_list = [ 2*i+1 for i in range(2,10)]
print(my_list)

[5, 7, 9, 11, 13, 15, 17, 19]

Das funktioniert auch mit geschachtelten Ranges, z.B. \(\{x+y \mid x\in \mathbb{N},\, 1\leq x<5,\, y\in \mathbb{N},\, 10\leq y<15\}\).

  • Für jedes Element des inneren Ranges wird der gesamte äußere Range durchlaufen.

my_list = [x + y for x in range(1,5) for y in range(10,15,2)]
print(my_list)

[11, 13, 15, 12, 14, 16, 13, 15, 17, 14, 16, 18]

Man kann geschachtelte Ranges auch verwenden, um geschachtelte Listen zu bearbeiten. Beispiel: Umwandlung einer Matrix in einen Vektor, der zeilenweise die Elemente der Matrix enthält.

matrix = [[1,2,3], [4,5,6], [7,8,9]]
row_vector = [elem for row in matrix for elem in row]
print(row_vector)

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Ranges können auch mit if-Bedingungen kombiniert werden, um nur bestimmte Elemente auszuwählen. Beispiel: Alle ungeraden Zahlen in einem Bereich

odd = [x for x in range(20) if x % 2 == 1]
print(odd)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Tupel (Tuples)#

Tupel sind ähnlich wie Listen, aber sie sind unveränderlich (immutable). Sie werden mit runden Klammern () definiert. Einmal erstellt, können die Elemente eines Tupels nicht mehr geändert, hinzugefügt oder entfernt werden. Man sollte Tupel verwenden, wenn man weitere Sicherheit möchte, dass die Daten nicht verändert werden. Das hilft Laufzeitfehler zu vermeiden.

my_tupel = (1, 2, 3)
print(my_tupel)
print("First entry:", my_tupel[0], "Length:", len(my_tupel))

(1, 2, 3)
First entry: 1 Length: 3

my_tupel[1] = 10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[19], line 1
----> 1 my_tupel[1] = 10

TypeError: 'tuple' object does not support item assignment

zip()#

Die Funktion zip() nimmt mehrere iterierbare Objekte (z.B. Listen, Tupel) und kombiniert sie zu einem Iterator von Tupeln, wobei jedes Tupel die Elemente an den gleichen Positionen der Eingabeobjekte enthält.

Aus \((a_1,a_2,\ldots,a_n)\) und \((b_1,b_2,\ldots,b_n)\) wird \(((a_1,b_1),(a_2,b_2),\ldots,(a_n,b_n))\).

a = [1,2,3]
b = (4,5,6)
print(*zip(a,b))

(1, 4) (2, 5) (3, 6)

Mengen (Sets)#

Mengen sind ungeordnete Sammlungen von eindeutigen Elementen (also keine Duplikate). Folgende Datentypen dürfen in Mengen vorkommen:

  • Zahlen (Integer, Float)

  • Strings

  • Tupel (sofern diese nur aus den oben genannten Datentypen bestehen)

Mengen werden mit geschweiften Klammern {} oder der set()-Funktion definiert. Mengen unterstützen mathematische Mengenoperationen wie Vereinigung |, Schnittmenge & und Differenz -. Zur Erinnerung:

\[\begin{align*} A \cup B &= \{x \mid x \in A \text{ oder } x \in B\}\quad\text{... Vereinigung}\\ A \cap B &= \{x \mid x \in A \text{ und } x \in B\}\quad\text{... Schnittmenge}\\ A \setminus B &= \{x \mid x \in A \text{ und } x \notin B\}\quad\text{... Differenz} \end{align*}\]
set_A = {1, 2, 3, 4}
set_B = {3, 4, 5, 6}
print("A u B =", set_A | set_B) 
print("A n B =", set_A & set_B) 
print("A \\ B =", set_A - set_B) 

A u B = {1, 2, 3, 4, 5, 6}
A n B = {3, 4}
A \ B = {1, 2}

Mengen haben keine feste Reihenfolge, daher sind die Elemente nicht mit dem Indexoperator [] zugreifbar. Man kann jedoch mit Schleifen (später) oder Mengenoperationen auf die Elemente zugreifen. Um eine Menge zu verändern, gibt es die Methoden

  • add(): Fügt ein Element zur Menge hinzu.

  • remove(): Entfernt ein Element aus der Menge. Löst einen Fehler aus, wenn das Element nicht vorhanden ist.

  • discard(): Entfernt ein Element aus der Menge, ohne einen Fehler auszulösen, wenn das Element nicht vorhanden ist.

my_set = {1, 2, 3, 4, 5}
my_set.add(6)
my_set.add(1)
print(my_set)
my_set.remove(3)
print(my_set)
my_set.discard(10)

{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}

Beispiel: Set Comprehension und das ‘Chicken McNugget Theorem’#

Computerunterstützte Beweise werden in der Mathematik immer wichtiger.

  • Das bekannteste Beispiel ist der Beweis des Vier-Farben-Satzes.

  • Wir betrachten hier das Chicken McNugget Theorem als einfacheres Beispiel.

Theorem: Die Zahl 43 ist die größte ganze Zahl, die nicht in der Form

\[ n = 6a + 9b + 20c \]

für nicht-negative ganze Zahlen \(a\), \(b\) und \(c\) dargestellt werden kann.

Beweis: Schritt 1: Sei \(M:= \{6a + 9b + 20c \mid a,b,c \in \mathbb{N}_0\}\) die Menge aller darstellbaren Zahlen. Wir nehmen zunächst an, dass es sechs aufeinanderfolgende Zahlen \(n, n+1, n+2, n+3, n+4, n+5 \in M\) gibt. Dann zeigen wir durch Induktion, dass alle Zahlen \(k\geq n\) in \(M\) sind.

Induktionsanfang: Für \(k=n\) bis \(k=n+5\) gilt die Aussage per Annahme.

Induktionsannahme: Es gilt \(j\in M\) für alle \(n \leq j\leq k\).

Induktionsschritt: Sei \(k\geq n+5\), dann müssen wir \(k+1\in M\) zeigen: Unter der Induktionsannahme ist \(j = k-5\geq n\) und daher \(j\in M\). Somit hat \(j\) eine Darstellung der Form

\[ j= k-5 = 6a + 9b + 20c \]

für gewisse nicht-negative ganze Zahlen \(a,b,c\). Damit gilt aber

\[ k+1 = (k-5) + 6 = 6(a+1) + 9b + 20c, \]

also ist auch \(k+1 \in M\). Somit ist die Aussage für alle \(k\geq n\) gezeigt.

Schritt 2: Wir suchen nun die kleinste Zahl \(n\), für die es sechs aufeinanderfolgende Zahlen in \(M\) gibt. Dazu erzeugen wir eine Teilmenge \(M'\subset M\) definiert durch \(M':=\{6a + 9b + 20c \mid 0\leq a,b,c < 8\}\) in Python und suchen darin nach sechs aufeinanderfolgenden Zahlen.

# ein Teil der Menge M
Mprime = {6*a + 9*b + 20*c for a in range(0,8) for b in range(0,8) for c in range(0,8)} 
# alle Zahlen in M', für die n, n+1, ..., n+5 auch in M' sind
consecutive_six = {n for n in Mprime if all((n + i) in Mprime for i in range(6))} 
n = min(consecutive_six)
print("Kleinste Zahl n, so dass n, n+1, ..., n+5 in M' sind:", n)

Kleinste Zahl n, so dass n, n+1, ..., n+5 in M' sind: 44

Da \(M'\subset M\), bleibt die Frage, ob es in \(M\) eine kleinere Zahl \(m<44\) geben kann, für die \(m, m+1, \ldots, m+5\in M\) gilt. Angenommen, es gibt so ein eine Zahl \(m <44\). Dann muss mindestens eine der Zahlen \(k\in \{m, m+1, \ldots, m+5\}\) in \(M\setminus M'\) liegen. Jede Zahl \(k\in M\setminus M'\) hat die Darstellung

\[ k = 6a + 9b + 20c \quad \text{ wobei } \max\{a,b,c\}\geq 8\text{ gilt}. \]

Die kleinste Zahl mit dieser Darstellung ist \(6\cdot 8 = 48\), von der wir schon wissen, dass sie in \(M'\) und daher nicht in \(M\setminus M'\) liegt. Die nächst kleinste Zahl ist \(6\cdot 9 = 54\) (z.B. mit \(a=9,b=0,c=0\)). Die möglichen Zahlen \(k\in \{m, m+1, \ldots, m+5\}\) sind aber alle kleiner gleich \(m+5\leq 48\). Daher kann keine dieser Zahlen in \(M\setminus M'\) liegen, was einen Widerspruch zur Annahme darstellt.

Es kann also in \(M\) keine kleinere Zahl als \(n=44\) geben, die \(n, n+1, \ldots, n+5\in M\) erfüllt. Schritt 1 zeigt, dass dann alle Zahlen \(k\geq 44\) in \(M\) sind. Daher ist \(n-1 = 43\) die größte Zahl, die nicht in \(M\) ist und das Theorem ist bewiesen. \(\Box\)

Bemerkungen zum Beweis:

  • Das Theorem ist ein Spezialfall des Frobenius-Münzproblems

  • Wichtig: Der Induktionsanfang muss \(k=n\) bis \(k=n+5\) abdecken, also sechs aufeinanderfolgende Zahlen umfassen.

    • Andernfalls kann es sein, dass \(k-5\) im Induktionsschritt nicht in \(M\) liegt.

  • Bei computergestützten Beweisen muss man sich Gedanken machen, ob die Berechnung des Computers verlässlich ist (z.B. Rundungsfehler bei Fließkommazahlen).

    • Hier kein Problem, da nur mit ganzen Zahlen gerechnet wird (siehe Kapitel ‘Zahldarstellung im Computer’).

Bemerkungen zum Code: Die Zeile

consecutive_six = {n for n in Mprime if all((n + i) in Mprime for i in range(6))}

nutzt geschachtelte Set und List Comprehensions, um alle Zahlen n in der Menge Mprime zu finden, für die auch die nächsten fünf aufeinanderfolgenden Zahlen (n+1, n+2, n+3, n+4, n+5) ebenfalls in Mprime enthalten sind.

  • (n + i) in Mprime for i in range(6) erzeugt eine Liste von Wahrheitswerten, die angeben, ob jede der Zahlen n, n+1, …, n+5 in Mprime enthalten ist.

  • all(...) überprüft, ob alle Werte in dieser Liste True sind, was bedeutet, dass alle sechs aufeinanderfolgenden Zahlen in Mprime vorhanden sind.

  • n for n in Mprime if ... erstellt schließlich eine Menge aller Zahlen n, die diese Bedingung erfüllen.

n = 25
print("25,...,30 sind in M':",*[(n+i) in Mprime for i in range(6)],"\nAlle sechs sind in M':", all([(n+i) in Mprime for i in range(6)]))
n = 44
print("44,...,49 sind in M':",*[(n+i) in Mprime for i in range(6)],"\nAlle sechs sind in M':", all([(n+i) in Mprime for i in range(6)]))

25,...,30 sind in M': False True True False True True 
Alle sechs sind in M': False
44,...,49 sind in M': True True True True True True 
Alle sechs sind in M': True

Mutability#

Ein wichtiger Unterschied zwischen diesen Datentypen ist, ob sie veränderlich (mutable) oder unveränderlich (immutable) sind. Veränderliche Datentypen können nach ihrer Erstellung geändert werden, während unveränderliche Datentypen nicht geändert werden können.

  • unveränderlich (immutable): Integer, Float, String, Boolean, Tupel

    • 3=4 ist nicht erlaubt, man kann die Zahl 3 nicht in 4 ändern

    • x = (1,2) und x[0]=3 ist nicht erlaubt, da Tupel unveränderlich sind

    • Achtung: a=3 und a=4 ist erlaubt, da hier die Variable a nur auf einen neuen Wert gesetzt wird

  • veränderlich (mutable): Listen, Mengen, Wörterbücher

    • my_list = [1,2,3] und my_list[0]=4 ist erlaubt, da Listen veränderlich sind

Dieser Unterschied wird später noch genauer diskutiert werden.

Wörterbücher (Dictionaries)#

Wörterbücher sind Sammlungen von Schlüssel-Wert-Paaren. Sie werden mit geschweiften Klammern {} definiert, wobei jedes Paar durch einen Doppelpunkt : getrennt ist. Wörterbücher sind veränderlich (mutable) und die Schlüssel müssen unveränderlich sein (z. B . Strings, Zahlen oder Tupel).

my_dict = {'Name': 'Alice', 'Age': 25, 'Gender': 'F'}
print(my_dict)
print(my_dict['Name'])
my_dict['Age'] = 26
print(my_dict)
my_dict['City'] = 'New York'
print(my_dict)

{'Name': 'Alice', 'Age': 25, 'Gender': 'F'}
Alice
{'Name': 'Alice', 'Age': 26, 'Gender': 'F'}
{'Name': 'Alice', 'Age': 26, 'Gender': 'F', 'City': 'New York'}

Mittels des Indexoperators [] können Werte anhand ihrer Schlüssel gelesen und geschrieben werden. Wenn ein Schlüssel nicht existiert, wird ein Fehler ausgelöst. Mit in kann geprüft werden, ob ein Schlüssel im Wörterbuch existiert

if 'Age' in my_dict:
    print("Age ist ein Schlüssel im Wörterbuch")
    print(my_dict['Age'])

Age ist ein Schlüssel im Wörterbuch
26

Mit items() können Schlüssel-Wert-Paare als Tupel ausgegeben werden, mit keys() nur die Schlüssel und mit values() nur die Werte.

pairs = list(my_dict.items())
keys = list(my_dict.keys())
values = list(my_dict.values())
print(pairs)
print(keys)
print(values)

[('Name', 'Alice'), ('Age', 26), ('Gender', 'F'), ('City', 'New York')]
['Name', 'Age', 'Gender', 'City']
['Alice', 26, 'F', 'New York']

Der * Operator bei Dictionaries#

Der * Operator kann auch bei Dictionaries verwendet werden, um alle Schlüssel des Wörterbuchs zu entpacken.

my_dict = {'Name': 'Alice', 'Age': 25, 'Gender': 'F'}
print(*my_dict)  # Entpacken der Schlüssel des Wörterbuchs

Name Age Gender
Contents