Sammlungen in Python

Mehrere Werte in einem Objekt speichern

Wähle die Sammlung danach aus, wie das Programm $auf die Daten zugreifen und sie verändern$ soll.

Einige Sammlungen können Objekte verschiedener Typen enthalten. Für jeden Sammlungstyp gelten jedoch eigene Regeln. Schlüssel eines Dictionaries und Elemente eines Sets müssen zum Beispiel unverändert hashbar bleiben, solange sie in der Sammlung liegen. Der Sammlungstyp bestimmt außerdem, ob sich sein Inhalt nach der Erstellung ändern lässt.

Python stellt fünf häufig verwendete eingebaute Sammlungen bereit:

$String$ : unveränderliche Textsequenz
$Liste$ : veränderliche, indexierbare Sequenz
$Tupel$ : unveränderliche Sequenz
$Dictionary$ : Zuordnung von Schlüsseln zu Werten
$Set$ : Sammlung eindeutiger Elemente ohne Indizes

Listen in Python

Eine Liste bewahrt die $Reihenfolge ihrer Elemente$ und ihr Inhalt lässt sich verändern. Eine Liste darf Werte verschiedener Typen enthalten, eine einheitliche Elementform ist jedoch meist leichter zu verarbeiten.

Anders als ein niedrigstufiges Array fester Größe kann eine Python-Liste wachsen und schrumpfen. Sie speichert Verweise auf Python-Objekte. Eine Änderung an einem verschachtelten Objekt kann deshalb über jeden Verweis auf dieses Objekt sichtbar sein.

Eigenschaften von Listen

Achte auf $Reihenfolge, gemischte Typen und Veränderlichkeit$ . Geordnet bedeutet, dass jedes Element eine Position hat. Die Werte sind deshalb nicht automatisch der Größe nach sortiert.

Eigenschaft	Erklärung	Beispiel
Geordnet	Elemente haben eine feste Reihenfolge	`[1, 2, 3]` ist nicht dasselbe wie `[3, 2, 1]`
Heterogen	Kann verschiedene Datentypen enthalten	`[1, 'text', 3.14, True]`
Veränderlich	Inhalte können nach der Erstellung geändert werden	Kann Elemente hinzufügen, entfernen oder ändern

Listen schreiben

Ein Listenliteral verwendet $eckige Klammern$ und trennt die Elemente durch Kommas. Eine Liste kann Werte unterschiedlicher Typen oder weitere Listen enthalten.

list_creation.py

# Verschiedene Listen nach Datentyp
a = [True, False, True]              # Wert: [True, False, True]
b = [1, 2, 3]                        # Wert: [1, 2, 3]
c = [1.5, 2.5, 3.5]                  # Wert: [1.5, 2.5, 3.5]
d = ['red', 'green', 'blue']         # Wert: ['red', 'green', 'blue']

# Leere Listen
empty1 = []                          # Wert: []
empty2 = list()                      # Wert: []

# Heterogene Liste (gemischte Datentypen)
mixed = [False, 2, 3.5, 'blue']      # Wert: [False, 2, 3.5, 'blue']

# Verschachtelte Liste
nested = [1, [2.5, False, 'red'], 3.5, 'blue']  # Wert: [1, [2.5, False, 'red'], 3.5, 'blue']

Listenindizierung

Die Indizierung greift über seine Position auf ein einzelnes Listenelement zu. Python zählt ab $0$ , daher hat das erste Element den Index $0$ .

Für Listenindizes gelten diese Regeln:

$Positive Indizes$ beginnen bei $0$ für das erste Element
$Negative Indizes$ beginnen bei $-1$ für das letzte Element
$Ein Index außerhalb des gültigen Bereichs$ löst IndexError aus

list_indexing.py

# Beispiel für die Indizierung verschachtelter Listen
nested = [1, [2.5, False, 'red'], 3.5, 'blue']

print('nested =', nested)                    # Ausgabe: nested = [1, [2.5, False, 'red'], 3.5, 'blue']

# Indizierung der Hauptelemente
print('nested[0] =', nested[0])              # Ausgabe: nested[0] = 1
print('nested[-1] =', nested[-1])            # Ausgabe: nested[-1] = blue
print('nested[1] =', nested[1])              # Ausgabe: nested[1] = [2.5, False, 'red']

# Indizierung von Elementen in verschachtelten Listen
print('nested[1][2] =', nested[1][2])        # Ausgabe: nested[1][2] = red

# Zeichen in Strings indizieren (doppelte Indizierung)
print('nested[1][2][1] =', nested[1][2][1])  # Ausgabe: nested[1][2][1] = e

Slicing mit Schrittweite

Mit Slicing wird ein Teil einer Liste ausgewählt. Die Schrittweite legt den $Abstand zwischen den ausgewählten Elementen$ fest.

Die vollständige Syntax lautet list[start:stop:step]:

start ist der erste enthaltene Index
stop ist der erste nicht mehr enthaltene Index
step ist der Abstand zwischen den ausgewählten Indizes

list_slicing.py

# Liste mit Slicing-Beispielen
x = [0, 1, 2, 3, 4, 5]
print('x =', x)                              # Ausgabe: x = [0, 1, 2, 3, 4, 5]

# Grundlegendes Slicing
print('x[1:4] =', x[1:4])                    # Ausgabe: x[1:4] = [1, 2, 3]

# Slicing vom negativen Index bis zum Ende
print('x[-3:] =', x[-3:])                    # Ausgabe: x[-3:] = [3, 4, 5]

# Slicing mit Schrittweite
print('x[1:4:2] =', x[1:4:2])                # Ausgabe: x[1:4:2] = [1, 3]

# Liste mit negativer Schrittweite umkehren
print('x[::-1] =', x[::-1])                  # Ausgabe: x[::-1] = [5, 4, 3, 2, 1, 0]

Beim Slicing wählt man einen zusammenhängenden oder regelmäßig übersprungenen Teil einer Liste aus. Für x = [0, 1, 2, 3, 4, 5] liefert x[1:4] die Elemente an den Indizes $1$ , $2$ und $3$ . Der Endindex $4$ gehört nicht mehr zum Ergebnis. Der Ausdruck x[1:4:2] verwendet die Schrittweite $2$ und wählt deshalb die Indizes $1$ und $3$ aus.

Listen und Strings

Listen stellen Operationen zum Lesen und Verändern von Daten bereit. Für den Elementzugriff verwenden sie $dieselbe Indizierungs- und Slicing-Syntax$ wie Strings.

list_output.py

# Verschiedene Möglichkeiten, Listen anzuzeigen
nested = [1, [2.5, False, 'red'], 3.5, 'blue']

# Anzeige mit Zuordnung
print('nested =', nested)
# Ausgabe: nested = [1, [2.5, False, 'red'], 3.5, 'blue']

# Anzeige ohne Zuordnung
print(nested)
# Ausgabe: [1, [2.5, False, 'red'], 3.5, 'blue']

# Ausgabe mit der print-Funktion
print('Listeninhalt:', nested)
# Ausgabe: Listeninhalt: [1, [2.5, False, 'red'], 3.5, 'blue']

Listen und Strings unterstützen beide Indizierung und Slicing.

Operation	Zeichenfolge	Liste
$Indizierung$	Einzelnes Zeichen lesen	Einzelnes Element lesen
$Slicing mit Schrittweite$	Teilstring bilden	Teilliste bilden

Der Hauptunterschied liegt in der Veränderlichkeit. Ein String kann nach seiner Erstellung nicht geändert werden, eine Liste dagegen schon. Listenmethoden können daher Elemente hinzufügen, entfernen, ersetzen oder neu anordnen.

Häufige Listenmethoden

Methode	Beschreibung	Anwendungsbeispiel
`append(element)`	Element am Ende der Liste hinzufügen	Neues Element hinzufügen
`extend(list2)`	Mit Elementen aus einer anderen Liste zusammenführen	Zwei Listen kombinieren
`insert(index, element)`	Element an bestimmter Position einfügen	In der Mitte der Liste hinzufügen
`index(element)`	Ersten Index eines Elements finden	Position eines Elements bestimmen
`pop()`	Letztes Element entfernen und zurückgeben	Letztes Element nehmen
`reverse()`	Listenreihenfolge direkt umkehren	Reihenfolge umkehren
`remove(element)`	Erstes Vorkommen des Elements entfernen	Bestimmtes Element entfernen
`sort()`	Liste direkt sortieren	Daten sortieren
`copy()`	Flache Kopie erstellen	Liste kopieren, ohne verschachtelte Objekte zu kopieren
`count(element)`	Vorkommen eines Elements zählen	Häufigkeit bestimmen

list_methods.py

# Demonstration verschiedener Listenmethoden
my_list = [1, 2, 3]
print('Original list:', my_list)            # Ausgabe: Original list: [1, 2, 3]

# Adding elements
my_list.append(4)
print('After append(4):', my_list)          # Ausgabe: After append(4): [1, 2, 3, 4]

my_list.extend([5, 6])
print('After extend([5, 6]):', my_list)     # Ausgabe: After extend([5, 6]): [1, 2, 3, 4, 5, 6]

my_list.insert(0, 0)
print('After insert(0, 0):', my_list)       # Ausgabe: After insert(0, 0): [0, 1, 2, 3, 4, 5, 6]

# Searching elements
idx = my_list.index(3)
print('Index of 3:', idx)                   # Ausgabe: Index of 3: 3

my_list.append(3)
count = my_list.count(3)
print('Count of 3:', count)                 # Ausgabe: Count of 3: 2

# Removing elements
my_list.remove(3)
print('After remove(3):', my_list)          # Ausgabe: After remove(3): [0, 1, 2, 4, 5, 6, 3]

popped = my_list.pop()
print('Popped element:', popped)            # Ausgabe: Popped element: 3
print('After pop():', my_list)              # Ausgabe: After pop(): [0, 1, 2, 4, 5, 6]

# Organizing elements
my_list.reverse()
print('After reverse():', my_list)          # Ausgabe: After reverse(): [6, 5, 4, 2, 1, 0]

my_list.sort()
print('After sort():', my_list)             # Ausgabe: After sort(): [0, 1, 2, 4, 5, 6]

copied = my_list.copy()
print('Copied list:', copied)               # Ausgabe: Copied list: [0, 1, 2, 4, 5, 6]

Die Methode copy() erzeugt eine $neue äußere Liste$ , während verschachtelte Objekte gemeinsam genutzt werden. Eine Änderung an salinan[0][0] erscheint in beiden Listen. Eine angehängte Zeile verändert dagegen nur die äußere Liste salinan.

shallow_copy.py

original = [[1, 2], [3, 4]]
salinan = original.copy()
salinan[0][0] = 99
print(original)  # Output: [[99, 2], [3, 4]]
print(salinan)   # Output: [[99, 2], [3, 4]]

salinan.append([5, 6])
print(len(original), len(salinan))  # Output: 2 3

Häufige Listenformen

Eine Liste kann leer sein, gemischte Typen enthalten oder weitere Listen enthalten:

$Leere Listen$

Sowohl [] als auch list() erzeugen eine leere Liste, die später gefüllt werden kann.
$Heterogene Listen$

Eine Liste kann zum Beispiel einen Namen, ein Alter und einen booleschen Wert enthalten. Gemischte Typen sind sinnvoll, wenn jede Position eine klar festgelegte Bedeutung hat.
$Verschachtelte Listen$

Eine verschachtelte Liste enthält weitere Listen als Elemente. Innere Listen gleicher Länge können die Zeilen einer Matrix oder Tabelle darstellen.

special_lists.py

# Leere Listen - zwei Erstellungsmethoden
a = []                                       # Wert: []
b = list()                                   # Wert: []

# Heterogene Liste - verschiedene Datentypen
mixed = [False, 2, 3.5, 'blue']             # Wert: [False, 2, 3.5, 'blue']

# Verschachtelte Liste - Liste innerhalb der Liste
nested = [1, [2.5, False, 'red'], 3.5, 'blue']  # Wert: [1, [2.5, False, 'red'], 3.5, 'blue']

print('Empty list 1:', a)
print('Empty list 2:', b)
print('Mixed types:', mixed)
print('Nested structure:', nested)

Verschachtelte Listen können Zeilen, Bäume oder kleine tabellenartige Strukturen darstellen. Sie bilden nicht automatisch eine rechteckige Matrix. Mehrere Elemente können außerdem auf dieselbe innere Liste verweisen. Eine verkettete Indizierung wie nested[1][2] wählt auf jeder Ebene ein Element aus.

Weitere Sammlungen

Drei weitere häufig verwendete Sammlungen haben unterschiedliche Regeln für Reihenfolge, Duplikate und nachträgliche Änderungen. Ein Tupel legt seine Positionen fest, ein Dictionary ordnet jedem eindeutigen Schlüssel genau einen Wert zu, und ein Set speichert $nur eindeutige Elemente$ , ohne eine Reihenfolge zuzusichern.

Tupel

Ein Tupel ähnelt einer Liste, aber seine $Positionen können nach der Erstellung nicht ersetzt werden$ . Mehrere Werte lassen sich in einem Tupel zusammenfassen und später wieder auf einzelne Variablen verteilen.

Ein Tupel kann seine eigenen Elemente nicht ersetzen. Ein Element darf jedoch auf ein veränderliches Objekt verweisen, dessen Inhalt sich weiterhin ändern lässt.

Aspekt	Tupel	Liste
$Veränderlichkeit$	Unveränderlich	Veränderlich
$Syntax$	`()` oder ohne Klammern	`[]`
$Nutzung$	Daten mit festen Positionen, etwa Koordinaten	Daten, die ergänzt oder geändert werden

tuple_operations.py

# Tupelsyntax - zwei Erstellungsmethoden
t1 = (0, 1, 2)                               # Wert: t1 = (0, 1, 2)
t2 = 3, 4, 5                                 # Wert: t2 = (3, 4, 5)
print('t1 =', t1)
print('t2 =', t2)

# Tupel-Entpacken - Werte trennen
a, b, c = t2
print('a, b, c =', a, b, c)                  # Ausgabe: a, b, c = 3 4 5

# Fehlerbehandlung beim Auspacken
try:
  a, b = (0, 1, 2)                         # Zu viele Werte
except ValueError as e:
  print('ValueError:', e)                  # Ausgabe: ValueError: too many values to unpack (expected 2)

try:
  a, b, c, d = 0, 1, 2                     # Nicht genügend Werte
except ValueError as e:
  print('ValueError:', e)                  # Ausgabe: ValueError: not enough values to unpack (expected 4, got 3)

# Tupel mit veränderlichen Objekten
t = (0, [1, 2, 3], 4)
print('Ursprüngliches t =', t)              # Ausgabe: Ursprüngliches t = (0, [1, 2, 3], 4)
t[1][0] = 'x'                               # Listeninhalte im Tupel ändern
print('Nach dem Ändern der inneren Liste:', t) # Ausgabe: Nach dem Ändern der inneren Liste: (0, ['x', 2, 3], 4)

# Tupel unveränderlich, aber Objekte darin können veränderbar sein
# t[1] = [9, 8, 7] # Fehler: Referenz kann nicht geändert werden
# t[1][0] = 'y' # OK: kann veränderbare Objektinhalte ändern

Dictionary

Ein Dictionary speichert $Schlüssel-Wert-Paare$ . Jeder Schlüssel muss eindeutig sein und unverändert hashbar bleiben, solange er im Dictionary liegt. Werte dürfen mehrfach vorkommen und auf veränderliche Objekte verweisen. Ein Dictionary-Literal verwendet {} mit einem Doppelpunkt zwischen Schlüssel und Wert.

dictionary_examples.py

# Wörterbuch erstellen
kontakte = {'Alice': 'alice@example.com', 'Bob': 'bob@example.com'}
print('kontakte =', kontakte)
# Ausgabe: kontakte = {'Alice': 'alice@example.com', 'Bob': 'bob@example.com'}

# Zugriff auf Werte per Schlüssel
print("kontakte['Alice'] =", kontakte['Alice'])  # Ausgabe: kontakte['Alice'] = alice@example.com

# Neue Schlüssel-Wert-Paare hinzufügen
kontakte['David'] = 'david@example.com'
print('Nach dem Hinzufügen von David:', kontakte)
# Ausgabe: Nach dem Hinzufügen von David: {'Alice': 'alice@example.com', 'Bob': 'bob@example.com', 'David': 'david@example.com'}

Mengen in Python

Ein Set speichert eindeutige, hashbare Elemente und unterstützt mathematische Mengenoperationen. Es bietet keine Elementindizes und $garantiert keine Iterationsreihenfolge$ . Nichtleere Set-Literale verwenden {}. Ein leeres Set entsteht mit set(), weil {} ein leeres Dictionary erzeugt.

set_examples.py

# Set erstellen
zahlen = {1, 2, 3, 4, 5}
print('zahlen =', sorted(zahlen))            # Ausgabe: zahlen = [1, 2, 3, 4, 5]

# Elemente zum Set hinzufügen
zahlen.add(6)
print('Nach dem Hinzufügen von 6:', sorted(zahlen))
# Ausgabe: Nach dem Hinzufügen von 6: [1, 2, 3, 4, 5, 6]

# Set-Operationen
gerade = {2, 4, 6, 8}
ungerade = {1, 3, 5, 7}

# Union (Kombination)
print('gerade | ungerade =', sorted(gerade | ungerade))
# Ausgabe: gerade | ungerade = [1, 2, 3, 4, 5, 6, 7, 8]

# Überschneidung
print('gerade & ungerade =', gerade & ungerade) # Ausgabe: gerade & ungerade = set()

Vergleich der Sammlungstypen

Die vier eingebauten Sammlungstypen unterscheiden sich in $Reihenfolge, Veränderbarkeit und Umgang mit doppelten Werten$ . Die Tabelle stellt sie gegenüber, damit du den passenden Typ aus der Aufgabe auswählst.

Sammlung	Syntax	Geordnet	Veränderlich	Duplikate	Hauptverwendung
$Liste$	`[1, 2, 3]`	Ja	Ja	Ja	Daten, die geändert werden müssen
$Tupel$	`(1, 2, 3)`	Ja	Nein	Ja	Feste Daten, Koordinaten
$Wörterbuch$	`{'a': 1}`	Ja*	Ja	Nein (Schlüssel)	Schlüsselwertzuordnung
$Set$	`{1, 2, 3}`	Nein	Ja	Nein	Eindeutige Elemente, Mengenoperationen

Seit Python 3.7 folgt die Iteration eines Dictionaries garantiert der Einfügereihenfolge der Schlüssel. Das Aktualisieren eines Schlüssels ändert seine Position nicht. Wird ein Schlüssel gelöscht und erneut eingefügt, steht er anschließend am Ende.