Python Listen & Dictionaries

6 Kernkonzepte

Die wichtigsten Datenstrukturen in Python: list · dict · append / extend · Slicing · Comprehensions · Nested Structures Listen und Dictionaries sind die zentralen Datenstrukturen in Python. Sie ermöglichen das Speichern, Verwalten und Verarbeiten von Daten in geordneten Sequenzen und Schlüssel-Wert-Paaren.

Listen – Geordnete Sammlungen

list · [ ] · len() · in

fruits = ["apple", "banana", "cherry"] print(fruits[0]) # "apple" print(len(fruits)) # 3

Listen sind veränderbare, geordnete Sequenzen, die beliebige Datentypen enthalten können. Sie sind die vielseitigste Datenstruktur in Python.

Wichtige Listen-Operationen

Operation	Beschreibung
liste[index]	Zugriff auf Element an Position index (0-basiert)
liste[-1]	Letztes Element
liste[index] = wert	Element überschreiben
len(liste)	Länge der Liste
wert in liste	Prüft, ob Wert enthalten ist
liste + liste2	Listen konkatenieren
liste * 3	Liste wiederholen

Beispiele

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

print(zahlen[0]) # 1

print(zahlen[-1]) # 5

print(len(zahlen)) # 5

print(3 in zahlen) # True

gemischt = [1, "zwei", 3.0, [4, 5]]

print(gemischt[3][0]) # 4 (verschachtelte Liste)

Tipp: Listen sind mutable (veränderbar) – Sie können Elemente hinzufügen, entfernen oder ändern. Das unterscheidet sie von Tupeln.

Dictionaries – Schlüssel-Wert-Paare

dict · { } · keys() · values() · items()

person = {"name": "Anna", "age": 30} print(person["name"]) # "Anna" print(person.get("age")) # 30

Dictionaries speichern Daten in Schlüssel-Wert-Paaren. Sie sind ungeordnet (bis Python 3.7) und erlauben schnellen Zugriff über den Schlüssel.

Wichtige Dict-Operationen

Operation	Beschreibung
dict[key]	Zugriff auf Wert (KeyError bei Fehlen)
dict.get(key, default)	Zugriff mit Default-Wert (kein Fehler)
dict[key] = wert	Wert setzen oder neu anlegen
del dict[key]	Schlüssel-Wert-Paar löschen
dict.keys()	Alle Schlüssel (iterierbar)
dict.values()	Alle Werte (iterierbar)
dict.items()	Schlüssel-Wert-Paare (iterierbar)
key in dict	Prüft, ob Schlüssel existiert

Beispiele

user = {"id": 1, "name": "Max", "active": True}

print(user["name"]) # "Max"

print(user.get("email", "nicht vorhanden")) # "nicht vorhanden"

user["email"] = "max@example.com" # Hinzufügen

# Iteration über Dictionary

for key, value in user.items():

print(f"{key}: {value}")

# Schlüssel prüfen

if "name" in user:

print("Name vorhanden")

Tipp: Verwenden Sie dict.get(key, default) statt dict[key], wenn Sie nicht sicher sind, ob der Schlüssel existiert – das vermeidet KeyError.

Methoden – append, extend, insert, pop, etc.

append() · extend() · insert() · pop() · remove()

liste.append(5) # Element hinzufügen liste.extend([1, 2]) # Liste anhängen liste.pop() # Letztes Element entfernen dict.update({"a": 1}) # Dict aktualisieren

Methoden erweitern die Funktionalität von Listen und Dictionaries – für das Hinzufügen, Entfernen, Suchen und Verwalten von Elementen.

Wichtige Listen-Methoden

Methode	Beschreibung
append(x)	Fügt x am Ende hinzu
extend(iterable)	Fügt alle Elemente von iterable hinzu
insert(i, x)	Fügt x an Position i ein
remove(x)	Entfernt das erste Vorkommen von x
pop([i])	Entfernt und gibt Element an Position i zurück (standardmäßig letztes)
clear()	Entfernt alle Elemente
index(x)	Gibt Position des ersten Vorkommens von x zurück
count(x)	Zählt Vorkommen von x
sort()	Sortiert die Liste (in-place)
reverse()	Kehrt die Reihenfolge um

Wichtige Dict-Methoden

Methode	Beschreibung
get(key, default)	Gibt Wert zurück oder default
update(other)	Aktualisiert mit anderen Schlüssel-Wert-Paaren
pop(key, default)	Entfernt und gibt Wert zurück
popitem()	Entfernt und gibt letztes Paar zurück
clear()	Entfernt alle Einträge
copy()	Erstellt eine flache Kopie
setdefault(key, default)	Gibt Wert zurück oder setzt default

Beispiele

liste = [1, 2, 3]

liste.append(4) # [1, 2, 3, 4]

liste.extend([5, 6]) # [1, 2, 3, 4, 5, 6]

liste.insert(2, 99) # [1, 2, 99, 3, 4, 5, 6]

letztes = liste.pop() # 6 (liste: [1, 2, 99, 3, 4, 5])

liste.sort() # [1, 2, 3, 4, 5, 99]

d = {"a": 1, "b": 2}

d.update({"c": 3, "d": 4}) # {"a": 1, "b": 2, "c": 3, "d": 4}

wert = d.pop("b") # 2 (d: {"a": 1, "c": 3, "d": 4})

Tipp: pop() entfernt und gibt das Element zurück – das ist nützlich, wenn Sie den Wert noch benötigen. remove(x) sucht nach dem Wert x und entfernt das erste Vorkommen.

Slicing – Teillisten extrahieren

list[start:stop:step]

liste = [0, 1, 2, 3, 4, 5] liste[1:4] # [1, 2, 3] liste[:3] # [0, 1, 2] liste[::2] # [0, 2, 4] liste[::-1] # [5, 4, 3, 2, 1, 0]

Slicing ermöglicht das Extrahieren von Teillisten (auch bei Strings und Tupeln). Die Syntax [start:stop:step] ist flexibel und mächtig.

Slicing-Parameter

Parameter	Beschreibung
start	Startindex (inklusive, default 0)
stop	Endindex (exklusive, default Ende)
step	Schrittweite (default 1), negativ für Rückwärts
[:]	Kopie der gesamten Liste
[-3:]	Letzte 3 Elemente
[:-3]	Alle bis auf die letzten 3

Beispiele

daten = [10, 20, 30, 40, 50, 60, 70]

print(daten[1:4]) # [20, 30, 40]

print(daten[:4]) # [10, 20, 30, 40]

print(daten[4:]) # [50, 60, 70]

print(daten[::2]) # [10, 30, 50, 70]

print(daten[::-1]) # [70, 60, 50, 40, 30, 20, 10]

print(daten[-3:]) # [50, 60, 70]

kopie = daten[:] # Kopie (nicht Referenz!)

Tipp: liste[:] erstellt eine flache Kopie der gesamten Liste – nützlich, wenn Sie eine unabhängige Kopie benötigen und nicht nur eine Referenz.

Comprehensions – Kompakt generieren

[expr for x in iterable if condition]

[x**2 for x in range(5)] # [0, 1, 4, 9, 16] {x: x**2 for x in range(3)} # {0: 0, 1: 1, 2: 4} {x for x in "hallo"} # {'h', 'a', 'l', 'o'}

Comprehensions ermöglichen die kompakte Erstellung von Listen, Dictionaries, Sets und Generatoren – oft lesbarer und schneller als manuelle Schleifen.

Beispiele

# Liste: Quadratzahlen

quadrate = [x**2 for x in range(5)]

# Liste mit Bedingung (nur gerade)

gerade = [x for x in range(10) if x % 2 == 0]

# Dictionary Comprehension

quadrat_dict = {x: x**2 for x in range(3)}

# Set Comprehension

unique = {c for c in "mississippi"}

# Verschachtelt

paare = [(a, b) for a in range(2) for b in range(2)]

Ausgaben:
quadrate = [0, 1, 4, 9, 16]
gerade = [0, 2, 4, 6, 8]
quadrat_dict = {0: 0, 1: 1, 2: 4}
unique = {'m', 'i', 's', 'p'}
paare = [(0, 0), (0, 1), (1, 0), (1, 1)]

Tipp: Comprehensions sind oft schneller als for-Schleifen mit append(). Sie machen den Code zudem kompakter und lesbarer.

Verschachtelte Strukturen – Listen in Listen, Dict in Dict

matrix · list of dicts · dict of lists

matrix = [[1, 2], [3, 4]] matrix[0][1] # 2 personen = [{"name": "Anna"}, {"name": "Ben"}] personen[0]["name"] # "Anna"

Verschachtelte Strukturen erlauben das Speichern komplexer Daten – wie Tabellen (Matrix), Listen von Objekten oder tief geschachtelte Konfigurationen.

Beispiele

# Matrix (2x3)

matrix = [

[1, 2, 3],

[4, 5, 6]

]

print(matrix[1][2]) # 6

# Liste von Dictionaries

users = [

{"id": 1, "name": "Anna"},

{"id": 2, "name": "Ben"}

]

for user in users:

print(user["name"])

# Dictionary mit Listen

daten = {

"zahlen": [1, 2, 3],

"namen": ["Anna", "Ben"]

}

print(daten["zahlen"][1]) # 2

# Tief verschachtelt

config = {

"server": {

"host": "localhost",

"port": 8080

}

print(config["server"]["host"]) # "localhost"

Tipp: Bei tief verschachtelten Strukturen hilft die Methode dict.get() oder der try/except-Block, um KeyError zu vermeiden.

Python Datenstrukturen im Überblick

list Geordnete, veränderbare Sequenz
[1, 2, 3]

dict Schlüssel-Wert-Paare
{"a": 1, "b": 2}

tuple Geordnete, unveränderbare Sequenz
(1, 2, 3)

set Ungeordnete, eindeutige Elemente
{1, 2, 3}

Slicing Teilsequenzen extrahieren
list[1:5:2]

Comprehension Kompakt generieren
[x**2 for x in range(5)]

Quick Summary

list

Geordnete Sammlung

dict

Schlüssel-Wert-Paare

append()

Element hinzufügen

[:]

Teillisten

[...]

Comprehensions

[[...]]

Verschachtelt

list.append(x) · dict.get(key, default) · [x for x in range(5)]