39. Wichtige Standardbibliotheks-Module

Pythons Standardbibliothek (standard library) ist eine Sammlung von Modulen, die mit Python mitgeliefert werden—Sie müssen nichts zusätzlich installieren, um sie zu verwenden. Diese Module bieten leistungsstarke Werkzeuge für häufige Programmieraufgaben: zufällige Zahlen erzeugen, mit Datumsangaben und Zeiten arbeiten, Daten mit anderen Programmen austauschen und spezialisierte Datenstrukturen verwenden, die über grundlegende Listen und Dictionaries hinausgehen.

In diesem Kapitel erkunden wir fünf wichtige Module der Standardbibliothek, die Sie in der Praxis beim Programmieren mit Python häufig verwenden werden.

39.1) Zufall erzeugen mit random

Das Modul random stellt Funktionen bereit, um Zufallszahlen zu erzeugen und zufällige Auswahlen zu treffen. Das ist nützlich für Simulationen, Spiele, Tests, Stichproben aus Daten und jede Situation, in der Sie unvorhersehbares Verhalten benötigen.

39.1.1) Zufällige ganze Zahlen mit randint() erzeugen

Die Funktion randint() erzeugt eine zufällige ganze Zahl zwischen zwei Werten, einschließlich beider Enden:

python

import random
 
# Das Würfeln eines sechsseitigen Würfels simulieren
die_roll = random.randint(1, 6)
print(f"You rolled: {die_roll}")  # Output: You rolled: 4 (varies each run)
 
# Ein zufälliges Alter zwischen 18 und 65 erzeugen
age = random.randint(18, 65)
print(f"Random age: {age}")  # Output: Random age: 42 (varies)

Beachten Sie, dass sowohl der Start- als auch der Endwert in den möglichen Ergebnissen enthalten ist. randint(1, 6) kann 1, 2, 3, 4, 5 oder 6 zurückgeben—alle sechs Werte sind möglich.

Hier ist ein praktisches Beispiel, das mehrere Würfe simuliert:

python

import random
 
# Das Werfen von zwei Würfeln simulieren und ihre Summe berechnen
die1 = random.randint(1, 6)
die2 = random.randint(1, 6)
total = die1 + die2
 
print(f"Die 1: {die1}")  # Output: Die 1: 3 (varies)
print(f"Die 2: {die2}")  # Output: Die 2: 5 (varies)
print(f"Total: {total}")  # Output: Total: 8 (varies)
 
if total == 7:
    print("Lucky seven!")
elif total == 2 or total == 12:
    print("Snake eyes or boxcars!")

Warum beide Enden inklusive sind: Das macht randint() für typische Anwendungsfälle intuitiv. Wenn Sie eine Zahl von 1 bis 6 (wie bei einem Würfel) wollen, schreiben Sie randint(1, 6) und sowohl 1 als auch 6 sind mögliche Ergebnisse.

39.1.2) Zufällige Fließkommazahlen erzeugen

Für zufällige Dezimalzahlen verwenden Sie random() (gibt eine Fließkommazahl zwischen 0.0 und 1.0 zurück) oder uniform() (gibt eine Fließkommazahl zwischen zwei angegebenen Werten zurück):

python

import random
 
# Eine zufällige Fließkommazahl zwischen 0.0 und 1.0 erzeugen (0.0 inklusive, 1.0 exklusive)
probability = random.random()
print(f"Random probability: {probability:.4f}")  # Output: Random probability: 0.7284 (varies)
 
# Eine zufällige Temperatur zwischen 15.0 und 30.0 Grad erzeugen
temperature = random.uniform(15.0, 30.0)
print(f"Temperature: {temperature:.2f}°C")  # Output: Temperature: 23.47°C (varies)
 
# Einen zufälligen Preis zwischen $10.00 und $99.99 erzeugen
price = random.uniform(10.0, 99.99)
print(f"Price: ${price:.2f}")  # Output: Price: $45.67 (varies)

Die Funktion random() ist nützlich, wenn Sie einen Wahrscheinlichkeitswert oder einen Prozentsatz benötigen. Die Funktion uniform() ist besser, wenn Sie eine zufällige Dezimalzahl in einem bestimmten Bereich benötigen.

39.1.3) Zufällige Auswahlen mit choice() treffen

Die Funktion choice() wählt zufällig ein Element aus einer Sequenz (Liste, Tupel oder String) aus:

python

import random
 
# Zufällig eine Farbe auswählen
colors = ["red", "blue", "green", "yellow", "purple"]
selected_color = random.choice(colors)
print(f"Selected color: {selected_color}")  # Output: Selected color: green (varies)
 
# Zufällig einen Gewinner aus Teilnehmern auswählen
participants = ["Alice", "Bob", "Charlie", "Diana"]
winner = random.choice(participants)
print(f"The winner is: {winner}")  # Output: The winner is: Bob (varies)
 
# Zufällig ein Zeichen aus einem String auswählen
vowels = "aeiou"
random_vowel = random.choice(vowels)
print(f"Random vowel: {random_vowel}")  # Output: Random vowel: i (varies)

Das ist besonders nützlich für Spiele, zufällige Stichproben oder das Auswählen zufälliger Testdaten. Jedes Element in der Sequenz hat die gleiche Wahrscheinlichkeit, gewählt zu werden.

Hier ist ein komplexeres Beispiel, das ein einfaches Quizspiel simuliert:

python

import random
 
# Quizfragen mit ihren Antworten
questions = [
    ("What is 2 + 2?", "4"),
    ("What is the capital of France?", "Paris"),
    ("What color is the sky?", "blue")
]
 
# Zufällig eine Frage auswählen
question, correct_answer = random.choice(questions)
print(f"Question: {question}")
 
user_answer = input("Your answer: ")
if user_answer.lower() == correct_answer.lower():
    print("Correct!")
else:
    print(f"Wrong! The answer was: {correct_answer}")

39.1.4) Mehrere zufällige Elemente mit sample() auswählen

Wenn Sie mehrere eindeutige Elemente aus einer Sequenz auswählen müssen, verwenden Sie sample(). Das ist wie Karten aus einem Deck ziehen ohne Zurücklegen—sobald ein Element ausgewählt wurde, wird es nicht noch einmal ausgewählt:

python

import random
 
# 3 zufällige Schüler für ein Gruppenprojekt auswählen
students = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank"]
group = random.sample(students, 3)
print(f"Group members: {group}")  # Output: Group members: ['Diana', 'Alice', 'Frank'] (varies)
 
# 5 Lottozahlen von 1 bis 50 ziehen (keine Duplikate)
lottery_numbers = random.sample(range(1, 51), 5)
lottery_numbers.sort()  # Sort for display
print(f"Lottery numbers: {lottery_numbers}")  # Output: Lottery numbers: [7, 15, 23, 38, 49] (varies)

Das zweite Argument von sample() gibt an, wie viele Elemente ausgewählt werden sollen. Die Zahl muss kleiner oder gleich der Länge der Sequenz sein—Sie können nicht mehr Elemente auswählen, als verfügbar sind.

39.1.5) Sequenzen mit shuffle() mischen

Die Funktion shuffle() ordnet die Elemente einer Liste zufällig neu in place (und verändert dabei die ursprüngliche Liste):

python

import random
 
# Ein Kartendeck mischen
cards = ["A♠", "K♠", "Q♠", "J♠", "10♠", "9♠", "8♠", "7♠"]
print(f"Original: {cards}")
random.shuffle(cards)
print(f"Shuffled: {cards}")  # Output: Shuffled: ['Q♠', '7♠', 'A♠', '10♠', '9♠', 'J♠', 'K♠', '8♠'] (varies)
 
# Quizfragen für eine zufällige Reihenfolge mischen
questions = ["Question 1", "Question 2", "Question 3", "Question 4"]
random.shuffle(questions)
print(f"Randomized order: {questions}")  # Output: Randomized order: ['Question 3', 'Question 1', 'Question 4', 'Question 2'] (varies)

39.2) Mit Datumsangaben und Zeiten arbeiten

Das Modul datetime stellt Klassen bereit, um mit Datumsangaben, Zeiten und Zeitintervallen zu arbeiten. Das ist essenziell für Terminplanung, Logging, das Berechnen von Dauern und jede Anwendung, die nachvollziehen muss, wann Dinge passieren.

39.2.1) Aktuelles Datum und aktuelle Uhrzeit abrufen

Die Klasse datetime repräsentiert einen konkreten Zeitpunkt mit Datums- und Zeitkomponenten:

python

from datetime import datetime
 
# Das aktuelle Datum und die aktuelle Uhrzeit abrufen
now = datetime.now()
print(f"Current datetime: {now}")
# Output: Current datetime: 2026-01-02 14:30:45.123456
 
# Auf einzelne Komponenten zugreifen
print(f"Year: {now.year}")      # Output: Year: 2026
print(f"Month: {now.month}")    # Output: Month: 1
print(f"Day: {now.day}")        # Output: Day: 2
print(f"Hour: {now.hour}")      # Output: Hour: 14
print(f"Minute: {now.minute}")  # Output: Minute: 30
print(f"Second: {now.second}")  # Output: Second: 45

Für nur das Datum (ohne Uhrzeit) verwenden Sie die Klasse date:

python

from datetime import date
 
# Das heutige Datum abrufen
today = date.today()
print(f"Today: {today}")  # Output: Today: 2026-01-02
 
print(f"Year: {today.year}")    # Output: Year: 2026
print(f"Month: {today.month}")  # Output: Month: 1
print(f"Day: {today.day}")      # Output: Day: 2

39.2.2) Bestimmte Datumsangaben und Zeiten erstellen

Sie können datetime- und date-Objekte für bestimmte Zeitpunkte erstellen:

python

from datetime import datetime, date
 
# Ein bestimmtes Datum erstellen
birthday = date(1995, 7, 15)
print(f"Birthday: {birthday}")  # Output: Birthday: 1995-07-15
 
# Ein bestimmtes datetime erstellen
meeting = datetime(2026, 3, 15, 14, 30)  # 15. März 2026 um 14:30 Uhr
print(f"Meeting: {meeting}")  # Output: Meeting: 2026-03-15 14:30:00

Das ist nützlich, um Deadlines, Termine, historische Daten oder jeden festen Zeitpunkt zu repräsentieren:

python

from datetime import date
 
# Wichtige Daten in einem Projekt
project_start = date(2026, 1, 15)
project_end = date(2026, 6, 30)
 
print(f"Project duration: {project_start} to {project_end}")
# Output: Project duration: 2026-01-15 to 2026-06-30

39.2.3) Zeitdifferenzen mit timedelta berechnen

Die Klasse timedelta repräsentiert eine Dauer—die Differenz zwischen zwei Datumsangaben oder Zeiten. Sie können sie verwenden, um zu berechnen, wie viel Zeit vergangen ist, oder um Zeit zu Datumsangaben hinzuzufügen/abzuziehen:

python

from datetime import date, timedelta
 
# Alter berechnen
birth_date = date(1995, 7, 15)
today = date(2026, 1, 2)
age_delta = today - birth_date
 
print(f"Days since birth: {age_delta.days}")  # Output: Days since birth: 11128
print(f"Years (approximate): {age_delta.days // 365}")  # Output: Years (approximate): 30

Wenn Sie ein Datum von einem anderen abziehen, erhalten Sie ein timedelta-Objekt. Das Attribut days sagt Ihnen, wie viele Tage diese Dauer umfasst.

Sie können timedelta-Objekte auch direkt erstellen, um bestimmte Dauern zu repräsentieren:

python

from datetime import date, timedelta
 
# Tage zu einem Datum hinzufügen
today = date(2026, 1, 2)
one_week = timedelta(days=7)
next_week = today + one_week
 
print(f"Today: {today}")        # Output: Today: 2026-01-02
print(f"Next week: {next_week}")  # Output: Next week: 2026-01-09
 
# Tage von einem Datum abziehen
thirty_days_ago = today - timedelta(days=30)
print(f"30 days ago: {thirty_days_ago}")  # Output: 30 days ago: 2025-12-03

timedelta kann Tage, Sekunden, Mikrosekunden, Millisekunden, Minuten, Stunden und Wochen darstellen:

python

from datetime import datetime, timedelta
 
# Eine Deadline berechnen
now = datetime(2026, 1, 2, 14, 30)
deadline = now + timedelta(hours=48, minutes=30)
 
print(f"Current time: {now}")    # Output: Current time: 2026-01-02 14:30:00
print(f"Deadline: {deadline}")   # Output: Deadline: 2026-01-04 15:00:00
 
# Verbleibende Zeit berechnen
time_left = deadline - now
print(f"Hours remaining: {time_left.total_seconds() / 3600}")  # Output: Hours remaining: 48.5

Die Methode total_seconds() wandelt die gesamte Dauer in Sekunden um, die Sie dann in Stunden, Minuten oder jede andere Einheit umrechnen können.

Hier ist ein praktisches Beispiel, das Projektmeilensteine berechnet:

python

from datetime import date, timedelta
 
# Projektplanung
project_start = date(2026, 1, 15)
sprint_duration = timedelta(weeks=2)
 
sprint_1_end = project_start + sprint_duration
sprint_2_end = sprint_1_end + sprint_duration
sprint_3_end = sprint_2_end + sprint_duration
 
print(f"Sprint 1: {project_start} to {sprint_1_end}")
# Output: Sprint 1: 2026-01-15 to 2026-01-29
print(f"Sprint 2: {sprint_1_end} to {sprint_2_end}")
# Output: Sprint 2: 2026-01-29 to 2026-02-12
print(f"Sprint 3: {sprint_2_end} to {sprint_3_end}")
# Output: Sprint 3: 2026-02-12 to 2026-02-26

39.2.4) Datumsangaben und Zeiten vergleichen

Date- und datetime-Objekte können mit den üblichen Vergleichsoperatoren verglichen werden:

python

from datetime import date
 
# Datumsangaben vergleichen
date1 = date(2026, 1, 15)
date2 = date(2026, 2, 20)
date3 = date(2026, 1, 15)
 
print(date1 < date2)   # Output: True
print(date1 == date3)  # Output: True
print(date2 > date1)   # Output: True

Das ist nützlich, um Deadlines zu prüfen, Datumsbereiche zu validieren und Datumsangaben zu sortieren:

python

from datetime import date
 
# Prüfen, ob ein Datum in der Vergangenheit liegt
event_date = date(2025, 12, 25)
today = date(2026, 1, 2)
 
if event_date < today:
    print("This event has already passed")  # Output: This event has already passed
else:
    print("This event is upcoming")
 
# Eine Liste von Datumsangaben sortieren
important_dates = [
    date(2026, 3, 15),
    date(2026, 1, 10),
    date(2026, 2, 28)
]
 
important_dates.sort()
print("Dates in order:")  # Output: Dates in order:
for d in important_dates:
    print(f"  {d}")
# Output:
#   2026-01-10
#   2026-02-28
#   2026-03-15

39.2.5) Datumsangaben und Zeiten mit strftime() formatieren

Die Methode strftime() (string format time) wandelt Datumsangaben und Zeiten in formatierte Strings um. Sie geben das Format mit speziellen Codes an:

python

from datetime import datetime
 
now = datetime(2026, 1, 2, 14, 30, 45)
 
# Häufige Datumsformate
print(now.strftime("%Y-%m-%d"))           # Output: 2026-01-02
print(now.strftime("%m/%d/%Y"))           # Output: 01/02/2026
print(now.strftime("%B %d, %Y"))          # Output: January 02, 2026
print(now.strftime("%A, %B %d, %Y"))      # Output: Friday, January 02, 2026
 
# Häufige Zeitformate
print(now.strftime("%H:%M:%S"))           # Output: 14:30:45
print(now.strftime("%I:%M %p"))           # Output: 02:30 PM
 
# Kombinierte Formate
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # Output: 2026-01-02 14:30:45
print(now.strftime("%B %d, %Y at %I:%M %p"))  # Output: January 02, 2026 at 02:30 PM

Häufige Format-Codes:

Code	Beschreibung	Beispiel
`%Y`	Jahr mit Jahrhundert	2026
`%m`	Monat als nullgefüllte Zahl (01-12)	01
`%d`	Tag als nullgefüllte Zahl (01-31)	02
`%B`	Vollständiger Monatsname	January
`%b`	Kurzer Monatsname	Jan
`%A`	Vollständiger Wochentagsname	Friday
`%a`	Kurzer Wochentagsname	Fri
`%H`	Stunde im 24-Stunden-Format (00-23)	14
`%I`	Stunde im 12-Stunden-Format (01-12)	02
`%M`	Minute (00-59)	30
`%S`	Sekunde (00-59)	45
`%p`	AM/PM	PM

Hier ist ein praktisches Beispiel, das einen Log-Eintrag erstellt:

python

from datetime import datetime
 
def log_event(message):
    """Ein Ereignis mit Zeitstempel protokollieren"""
    now = datetime.now()
    timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
    print(f"[{timestamp}] {message}")
 
log_event("User logged in")
# Output: [2026-01-02 14:30:45] User logged in
 
log_event("File uploaded successfully")
# Output: [2026-01-02 14:30:45] File uploaded successfully

39.2.6) Datumsangaben aus Strings mit strptime() parsen

Die Funktion strptime() (string parse time) wandelt formatierte Strings zurück in datetime-Objekte. Sie geben dieselben Format-Codes an, um Python zu sagen, wie der String zu interpretieren ist:

python

from datetime import datetime
 
# Verschiedene Datumsformate parsen
date_str1 = "2026-01-15"
date1 = datetime.strptime(date_str1, "%Y-%m-%d")
print(f"Parsed: {date1}")  # Output: Parsed: 2026-01-15 00:00:00
 
date_str2 = "January 15, 2026"
date2 = datetime.strptime(date_str2, "%B %d, %Y")
print(f"Parsed: {date2}")  # Output: Parsed: 2026-01-15 00:00:00
 
# Datetime mit Uhrzeit parsen
datetime_str = "2026-01-15 14:30:00"
dt = datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
print(f"Parsed: {dt}")  # Output: Parsed: 2026-01-15 14:30:00

Das ist essenziell, wenn Sie Datumsangaben aus Dateien, Benutzereingaben oder externen Datenquellen lesen:

python

from datetime import datetime
 
# Benutzereingabe parsen
user_input = "03/15/2026"
try:
    event_date = datetime.strptime(user_input, "%m/%d/%Y")
    print(f"Event scheduled for: {event_date.strftime('%B %d, %Y')}")
    # Output: Event scheduled for: March 15, 2026
except ValueError:
    print("Invalid date format. Please use MM/DD/YYYY")

Wichtig: Der Format-String muss exakt zum Eingabe-String passen, sonst erhalten Sie einen ValueError:

python

from datetime import datetime
 
# Das wird fehlschlagen - das Format passt nicht
try:
    datetime.strptime("2026-01-15", "%m/%d/%Y")  # Wrong format
except ValueError as e:
    print(f"Error: {e}")
    # Output: Error: time data '2026-01-15' does not match format '%m/%d/%Y'

39.3) JSON-Daten lesen und schreiben

JSON (JavaScript Object Notation) ist ein Textformat zum Speichern und Austauschen strukturierter Daten. Es ist das gängigste Format für Web-APIs, Konfigurationsdateien und Datenaustausch zwischen Programmen. Pythons Modul json macht es einfach, zwischen Python-Datenstrukturen und JSON-Text zu konvertieren.

39.3.1) Die JSON-Struktur verstehen

JSON sieht Python-Dictionaries und -Listen ähnlich, aber mit einigen Unterschieden:

JSON unterstützt diese Datentypen:

Objekte (wie Python-Dictionaries): {"name": "Alice", "age": 30}
Arrays (wie Python-Listen): [1, 2, 3, 4]
Strings: "hello" (müssen doppelte Anführungszeichen verwenden)
Zahlen: 42, 3.14
Booleans: true, false (kleingeschrieben)
Null: null (wie Pythons None)

Wichtige Unterschiede zu Python:

JSON verwendet true/false/null statt Pythons True/False/None
JSON-Strings müssen doppelte Anführungszeichen ("text") verwenden, nicht einfache
JSON unterstützt keine Tupel, Sets oder benutzerdefinierte Objekte direkt

So sehen JSON-Daten aus:

json

{
    "name": "Alice Johnson",
    "age": 30,
    "email": "alice@example.com",
    "is_active": true,
    "scores": [85, 92, 78, 95],
    "address": {
        "street": "123 Main St",
        "city": "Springfield",
        "zip": "12345"
    }
}

Hinweis: Das ist reiner JSON-Text, kein Python-Code. Beachten Sie das kleingeschriebene true und die Verwendung doppelter Anführungszeichen.

39.3.2) Python-Daten mit dumps() in JSON konvertieren

Die Funktion dumps() (dump string) konvertiert Python-Datenstrukturen in JSON-formatierte Strings:

python

import json
 
student = {
    "name": "Alice Johnson",
    "age": 30,
    "email": "alice@example.com",
    "is_active": True,
    "scores": [85, 92, 78, 95]
}
 
# Ein Dictionary in JSON konvertieren
json_string = json.dumps(student)
print(json_string)
# Output: {"name": "Alice Johnson", "age": 30, "email": "alice@example.com", "is_active": true, "scores": [85, 92, 78, 95]}
 
print(type(json_string))  # Output: <class 'str'>

Beachten Sie, wie Pythons True in der Ausgabe zu JSONs true wurde. Die Funktion dumps() übernimmt diese Konvertierungen automatisch.

Für besser lesbare Ausgabe verwenden Sie den Parameter indent:

python

import json
 
student = {
    "name": "Alice Johnson",
    "age": 30,
    "scores": [85, 92, 78, 95]
}
 
# Pretty-Print mit Einrückung
json_string = json.dumps(student, indent=2)
print(json_string)
# Output:
# {
#   "name": "Alice Johnson",
#   "age": 30,
#   "scores": [
#     85,
#     92,
#     78,
#     95
#   ]
# }

Der Parameter indent gibt an, wie viele Leerzeichen für jede Einrückungsebene verwendet werden sollen. Das macht JSON deutlich leichter lesbar, insbesondere bei komplexen verschachtelten Strukturen.

39.3.3) JSON mit loads() in Python-Daten konvertieren

Die Funktion loads() (load string) konvertiert JSON-formatierte Strings zurück in Python-Datenstrukturen:

python

import json
 
# JSON-String (wie Sie ihn z. B. von einer Web-API erhalten könnten)
json_string = '{"name": "Bob Smith", "age": 25, "scores": [90, 88, 92]}'
 
# In ein Python-Dictionary konvertieren
student = json.loads(json_string)
print(student)  # Output: {'name': 'Bob Smith', 'age': 25, 'scores': [90, 88, 92]}
print(type(student))  # Output: <class 'dict'>
 
# Auf die Daten wie auf jedes Python-Dictionary zugreifen
print(f"Name: {student['name']}")  # Output: Name: Bob Smith
print(f"Average score: {sum(student['scores']) / len(student['scores'])}")
# Output: Average score: 90.0

JSONs true, false und null werden automatisch zu Pythons True, False und None konvertiert:

python

import json
 
json_string = '{"active": true, "verified": false, "middle_name": null}'
data = json.loads(json_string)
 
print(data)  # Output: {'active': True, 'verified': False, 'middle_name': None}
print(type(data["active"]))  # Output: <class 'bool'>
print(type(data["middle_name"]))  # Output: <class 'NoneType'>

39.3.4) JSON mit dump() in Dateien schreiben

Die Funktion dump() schreibt Python-Daten direkt in eine Datei im JSON-Format:

python

import json
 
# Schülerdatensätze
students = [
    {"name": "Alice", "age": 20, "gpa": 3.8},
    {"name": "Bob", "age": 22, "gpa": 3.5},
    {"name": "Charlie", "age": 21, "gpa": 3.9}
]
 
# In eine JSON-Datei schreiben
with open("students.json", "w") as file:
    json.dump(students, file, indent=2)
 
print("Data written to students.json")
# Output: Data written to students.json

Nach dem Ausführen dieses Codes enthält die Datei students.json:

json

[
  {
    "name": "Alice",
    "age": 20,
    "gpa": 3.8
  },
  {
    "name": "Bob",
    "age": 22,
    "gpa": 3.5
  },
  {
    "name": "Charlie",
    "age": 21,
    "gpa": 3.9
  }
]

Warum dump() statt dumps() verwenden? Die Funktion dump() schreibt direkt in eine Datei, was effizienter ist, als zuerst in einen String zu konvertieren und dann den String zu schreiben. Verwenden Sie dump() für Dateien und dumps(), wenn Sie das JSON als String brauchen (zum Beispiel, um es über ein Netzwerk zu senden).

39.3.5) JSON mit load() aus Dateien lesen

Die Funktion load() liest JSON-Daten aus einer Datei und konvertiert sie in Python-Datenstrukturen:

python

import json
 
# Aus der JSON-Datei lesen, die wir zuvor erstellt haben
with open("students.json", "r") as file:
    students = json.load(file)
 
print(f"Loaded {len(students)} students")  # Output: Loaded 3 students
 
# Mit den Daten arbeiten
for student in students:
    print(f"{student['name']}: GPA {student['gpa']}")
# Output:
# Alice: GPA 3.8
# Bob: GPA 3.5
# Charlie: GPA 3.9

39.3.6) JSON-Fehler behandeln

Wenn Sie mit JSON arbeiten, können Ihnen ungültige Daten begegnen. Behandeln Sie mögliche Fehler immer:

python

import json
 
# Ungültiges JSON - schließendes Anführungszeichen fehlt
invalid_json = '{"name": "Alice", "age": 30'
 
try:
    data = json.loads(invalid_json)
except json.JSONDecodeError as e:
    print(f"Invalid JSON: {e}")
    # Output: Invalid JSON: Expecting ',' delimiter: line 1 column 28 (char 27)

Das ist besonders wichtig, wenn Sie JSON aus externen Quellen (Dateien, Web-APIs, Benutzereingaben) lesen, wo Sie nicht garantieren können, dass die Daten gültig sind:

python

import json
 
def load_config(filename):
    """Konfiguration aus einer JSON-Datei mit Fehlerbehandlung laden"""
    try:
        with open(filename, "r") as file:
            config = json.load(file)
            return config
    except FileNotFoundError:
        print(f"Config file '{filename}' not found")
        return None
    except json.JSONDecodeError as e:
        print(f"Invalid JSON in '{filename}': {e}")
        return None
 
# Versuchen, die Konfiguration zu laden
config = load_config("config.json")
if config:
    print(f"Configuration loaded: {config}")
else:
    print("Using default configuration")

39.3.7) Praktisches JSON-Beispiel: Anwendungszustand speichern und laden

Hier ist ein vollständiges Beispiel, das zeigt, wie Sie Anwendungsdaten speichern und laden:

python

import json
 
def save_game_state(filename, player_data):
    """Spielstand in einer JSON-Datei speichern"""
    with open(filename, "w") as file:
        json.dump(player_data, file, indent=2)
    print(f"Game saved to {filename}")
 
def load_game_state(filename):
    """Spielstand aus einer JSON-Datei laden"""
    try:
        with open(filename, "r") as file:
            player_data = json.load(file)
        print(f"Game loaded from {filename}")
        return player_data
    except FileNotFoundError:
        print("No saved game found")
        return None
 
# Spieldaten
player = {
    "name": "Hero",
    "level": 5,
    "health": 85,
    "inventory": ["sword", "shield", "potion"],
    "position": {"x": 10, "y": 20}
}
 
# Das Spiel speichern
save_game_state("savegame.json", player)
# Output: Game saved to savegame.json
 
# Später das Spiel laden
loaded_player = load_game_state("savegame.json")
# Output: Game loaded from savegame.json
 
if loaded_player:
    print(f"Welcome back, {loaded_player['name']}!")
    print(f"Level: {loaded_player['level']}, Health: {loaded_player['health']}")
    # Output:
    # Welcome back, Hero!
    # Level: 5, Health: 85

39.4) Praktische Container in collections

Das Modul collections stellt spezialisierte Container-Typen bereit, die Pythons eingebaute Container (Listen, Dictionaries, Sets) um zusätzliche Funktionalität erweitern. Diese Container lösen häufige Probleme eleganter, als wenn man grundlegende Datenstrukturen verwendet.

39.4.1) Elemente zählen mit Counter

Die Klasse Counter ist dafür gedacht, hashbare Objekte zu zählen. Sie ist eine Dictionary-Unterklasse, die Elemente als Keys und ihre Zählwerte als Values speichert.

Was Counter als Eingabe akzeptiert:

Jedes Iterierbare(iterable) (Liste, String, Tupel usw.)
Ein anderes Dictionary mit Zählwerten
Keyword-Argumente mit Zählwerten

Was Counter speichert:

Ein Dictionary, bei dem die Keys die Elemente sind und die Values ihre Zählwerte
Beispiel: Counter(['a', 'b', 'a']) speichert {'a': 2, 'b': 1}

Wichtiger Vorteil gegenüber normalen Dictionaries:

Gibt 0 für fehlende Keys zurück, statt KeyError auszulösen
Bietet zählspezifische Methoden wie most_common()
Unterstützt arithmetische Operationen zwischen Countern

Grundlegende Verwendung

python

from collections import Counter
 
# Buchstaben in einem Wort zählen
word = "mississippi"
letter_counts = Counter(word)
print(letter_counts)
# Output: Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})
 
# Auf Zählwerte wie bei einem Dictionary zugreifen
print(f"Number of 'i's: {letter_counts['i']}")
# Output: Number of 'i's: 4
 
print(f"Number of 'z's: {letter_counts['z']}")
# Output: Number of 'z's: 0 (returns 0 for missing keys, no KeyError!)

Counter aus unterschiedlichen Quellen erstellen

python

from collections import Counter
 
# Aus einer Liste
votes = ["Alice", "Bob", "Alice", "Charlie", "Alice", "Bob", "Alice"]
vote_counts = Counter(votes)
print(vote_counts)
# Output: Counter({'Alice': 4, 'Bob': 2, 'Charlie': 1})
 
# Aus einem String (zählt jedes Zeichen)
letter_counts = Counter("hello")
print(letter_counts)
# Output: Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
 
# Aus einem Dictionary
existing_counts = {'apple': 3, 'banana': 2}
fruit_counts = Counter(existing_counts)
print(fruit_counts)
# Output: Counter({'apple': 3, 'banana': 2})
 
# Aus Keyword-Argumenten
color_counts = Counter(red=5, blue=3, green=2)
print(color_counts)
# Output: Counter({'red': 5, 'blue': 3, 'green': 2})

Häufigste Elemente mit most_common() finden

Methodensignatur: most_common(n=None)

Parameter:

n (optional): Anzahl der zurückzugebenden häufigsten Elemente
Wenn n weggelassen wird oder None ist, werden alle Elemente zurückgegeben

Gibt zurück:

Eine Liste von (item, count)-Tupeln
Sortiert nach Zählwert, höchster zuerst
Wenn Zählwerte gleich sind, stehen die Elemente in der Reihenfolge, in der sie zuerst vorkamen

python

from collections import Counter
 
# Worthäufigkeit in einem Text analysieren
text = "the quick brown fox jumps over the lazy dog the fox"
words = text.split()
word_counts = Counter(words)
 
# Die 3 häufigsten Wörter holen
top_3 = word_counts.most_common(3)
print(top_3)
# Output: [('the', 3), ('fox', 2), ('quick', 1)]

Arithmetische Operationen mit Countern

Sie können Counter-Objekte addieren, subtrahieren und weitere Operationen durchführen:

python

from collections import Counter
 
# Elemente in zwei Gruppen zählen
group1 = Counter(["apple", "banana", "apple", "orange"])
print(group1)
# Output: Counter({'apple': 2, 'banana': 1, 'orange': 1})
 
group2 = Counter(["banana", "banana", "grape", "apple"])
print(group2)
# Output: Counter({'banana': 2, 'grape': 1, 'apple': 1})
 
# Zählwerte zusammenaddieren
combined = group1 + group2
print(combined)
# Output: Counter({'apple': 3, 'banana': 3, 'orange': 1, 'grape': 1})
 
# Zählwerte subtrahieren (behält nur positive Ergebnisse)
difference = group1 - group2
print(difference)
# Output: Counter({'apple': 1, 'orange': 1})
# banana: 1 - 2 = -1 (negative, so excluded)
# grape: not in group1, so excluded

Praktisches Beispiel: Schülernoten analysieren

python

from collections import Counter
 
# Notenverteilung
grades = ["A", "B", "A", "C", "B", "A", "B", "D", "A", "B", "C", "A"]
grade_counts = Counter(grades)
 
print(f"Total students: {len(grades)}")
# Output: Total students: 12
 
print("\nGrade Distribution:")
for grade, count in grade_counts.most_common():
    percentage = (count / len(grades)) * 100
    bar = "█" * count
    print(f"  {grade}: {count} students ({percentage:4.1f}%) {bar}")
# Output:
# Grade Distribution:
#   A: 5 students (41.7%) █████
#   B: 4 students (33.3%) ████
#   C: 2 students (16.7%) ██
#   D: 1 students ( 8.3%) █

39.4.2) Dictionaries mit Standardwerten mithilfe von defaultdict

Die Klasse defaultdict ist eine Dictionary-Unterklasse, die automatisch Einträge mit einem Standardwert erstellt, wenn Sie auf einen fehlenden Key zugreifen. Das macht es unnötig zu prüfen, ob Keys existieren, bevor Sie sie verwenden.

Was defaultdict als Eingabe akzeptiert:

Eine Default-Factory(default factory)-Funktion (erforderlich): Ein Callable, das den Standardwert für fehlende Keys zurückgibt
Alle Argumente, die ein normales dict akzeptiert (Key-Value-Paare, ein anderes Dictionary, Keyword-Argumente)

Wichtiger Vorteil gegenüber normalen Dictionaries:

Kein Prüfen nötig, ob ein Key existiert, bevor Sie ihn verwenden
Initialisiert fehlende Keys automatisch mit einem Standardwert
Saubererer, besser lesbarer Code für Gruppieren, Zählen und Akkumulieren

Die Default-Factory verstehen

Wenn Sie ein defaultdict erstellen, müssen Sie eine Default-Factory(default factory) angeben—ein Callable (Funktion), das keine Argumente nimmt und den Standardwert zurückgibt. Häufige Default-Factories:

int - gibt 0 zurück (nützlich zum Zählen)
list - gibt [] zurück (nützlich zum Gruppieren von Elementen)
set - gibt set() zurück (nützlich zum Sammeln eindeutiger Elemente)
str - gibt '' zurück (nützlich für String-Konkatenation)
lambda: value - gibt einen benutzerdefinierten Standardwert zurück

python

from collections import defaultdict
 
# Unterschiedliche Default-Factories
counts = defaultdict(int)        # Fehlende Keys geben 0 zurück
groups = defaultdict(list)       # Fehlende Keys geben [] zurück
unique = defaultdict(set)        # Fehlende Keys geben set() zurück
custom = defaultdict(lambda: "N/A")  # Fehlende Keys geben "N/A" zurück
 
# Mit fehlenden Keys testen
print(counts['missing'])     # Output: 0
print(groups['missing'])     # Output: []
print(unique['missing'])     # Output: set()
print(custom['missing'])     # Output: N/A

Grundlegende Verwendung: Zählen mit defaultdict

Vergleichen Sie ein normales Dictionary mit defaultdict zum Zählen:

python

from collections import defaultdict
 
word = "mississippi"
 
# Normales Dictionary - man muss prüfen, ob der Key existiert
regular_dict = {}
for letter in word:
    if letter not in regular_dict:
        regular_dict[letter] = 0
    regular_dict[letter] += 1
 
print(regular_dict)
# Output: {'m': 1, 'i': 4, 's': 4, 'p': 2}
 
# defaultdict - erstellt automatisch Einträge mit Standardwert
letter_counts = defaultdict(int)  # int() returns 0
for letter in word:
    letter_counts[letter] += 1  # Kein Prüfen nötig, ob der Key existiert!
 
print(dict(letter_counts))
# Output: {'m': 1, 'i': 4, 's': 4, 'p': 2}

So funktioniert es:

Wenn Sie letter_counts[letter] für einen neuen Buchstaben aufrufen, ruft defaultdict int() auf, was 0 zurückgibt
Der Key wird mit dem Wert 0 erstellt, dann macht += 1 daraus 1
Für vorhandene Keys verhält es sich wie ein normales Dictionary

Elemente mit defaultdict(list) gruppieren

Ein häufiger Anwendungsfall ist das Gruppieren von Elementen in Kategorien:

python

from collections import defaultdict
 
students = [
    ("Alice", "A"),
    ("Bob", "B"),
    ("Charlie", "A"),
    ("Diana", "C"),
    ("Eve", "B"),
    ("Frank", "A")
]
 
# Schüler nach Note gruppieren
# Mit defaultdict - sauber und einfach
students_by_grade = defaultdict(list)
for name, grade in students:
    students_by_grade[grade].append(name)
 
print(dict(students_by_grade))
# Output: {'A': ['Alice', 'Charlie', 'Frank'], 'B': ['Bob', 'Eve'], 'C': ['Diana']}
 
# Auf eine Note zugreifen, die es noch nicht gibt
print(students_by_grade["D"])  # Output: [] (empty list, not KeyError!)

So funktioniert es:

Wenn Sie students_by_grade[grade] für eine neue Note aufrufen, ruft defaultdict list() auf, was [] zurückgibt
Der Key wird mit einer leeren Liste erstellt, dann fügt .append(name) den ersten Schüler hinzu
Für vorhandene Noten wird einfach an die bestehende Liste angehängt

defaultdict aus einem vorhandenen Dictionary erstellen

Sie können ein defaultdict mit vorhandenen Daten initialisieren:

python

from collections import defaultdict
 
# Mit vorhandenen Zählwerten starten
existing_data = {'apple': 5, 'banana': 3}
 
# defaultdict aus vorhandenem Dictionary erstellen
fruit_counts = defaultdict(int, existing_data)
 
# Weitere Zählwerte hinzufügen
fruit_counts['apple'] += 2     # 5 + 2 = 7
fruit_counts['orange'] += 1    # 0 + 1 = 1 (new key, starts at 0)
 
print(dict(fruit_counts))
# Output: {'apple': 7, 'banana': 3, 'orange': 1}

Benutzerdefinierte Default-Factory

Sie können jedes Callable als Default-Factory angeben:

python

from collections import defaultdict
 
# lambda für benutzerdefinierte Standardwerte verwenden
page_views = defaultdict(lambda: {'views': 0, 'unique': 0})
 
page_views['home']['views'] = 100
page_views['home']['unique'] = 75
 
print(page_views['home'])
# Output: {'views': 100, 'unique': 75}
 
print(page_views['about'])  # New key gets default dictionary
# Output: {'views': 0, 'unique': 0}

Wichtige Hinweise

Zugriff vs. Prüfen auf Keys:

python

from collections import defaultdict
 
counts = defaultdict(int)
 
# Auf einen fehlenden Key zugreifen ERSTELLT ihn
value = counts['missing']  # Creates 'missing' with value 0
print('missing' in counts)  # Output: True
 
# Um zu prüfen, ohne zu erstellen, verwenden Sie 'in' oder .get()
counts2 = defaultdict(int)
print('missing' in counts2)      # Output: False (doesn't create key)
print(counts2.get('missing'))    # Output: None (doesn't create key)

39.5) (Optional) Nützliche Iterationswerkzeuge

Das Modul itertools stellt Funktionen bereit, um effiziente Iteratoren zu erstellen. Diese Werkzeuge helfen Ihnen, auf leistungsfähige Weise mit Sequenzen zu arbeiten, ohne große Zwischenlisten zu erstellen.

39.5.1) Iterierbare mit chain() verketten

Die Funktion chain() kombiniert mehrere Iterierbare zu einem einzelnen Iterator, der Elemente aus jedem Iterierbaren der Reihe nach liefert.

Was chain() akzeptiert:

Mehrere Iterierbare (Listen, Tupel, Strings usw.) als separate Argumente

Was chain() zurückgibt:

Einen Iterator, der alle Elemente des ersten Iterierbaren liefert, dann alle Elemente des zweiten und so weiter

Wichtiger Vorteil:

Speichereffizienter als das Verketten mit + (erstellt keine Zwischenlisten)
Funktioniert mit jedem Iterierbaren, nicht nur mit Listen

python

from itertools import chain
 
# Mehrere Listen kombinieren
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]
 
combined = chain(list1, list2, list3)
print(list(combined))  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Das ist speichereffizienter als das Verketten von Listen mit +, insbesondere bei großen Sequenzen:

python

from itertools import chain
 
# Mehrere Datenquellen verarbeiten, ohne eine große kombinierte Liste zu erstellen
students_class_a = ["Alice", "Bob", "Charlie"]
students_class_b = ["Diana", "Eve", "Frank"]
students_class_c = ["Grace", "Henry", "Iris"]
 
# Über alle Schüler iterieren, ohne eine kombinierte Liste zu erstellen
for student in chain(students_class_a, students_class_b, students_class_c):
    print(f"Processing: {student}")
# Output:
# Processing: Alice
# Processing: Bob
# Processing: Charlie
# Processing: Diana
# Processing: Eve
# Processing: Frank
# Processing: Grace
# Processing: Henry
# Processing: Iris

Sie können unterschiedliche Typen von Iterierbaren verketten:

python

from itertools import chain
 
# Listen, Tupel und Strings verketten
numbers = [1, 2, 3]
letters = ("a", "b", "c")
word = "xyz"
 
combined = chain(numbers, letters, word)
print(list(combined))  # Output: [1, 2, 3, 'a', 'b', 'c', 'x', 'y', 'z']

39.5.2) Elemente mit cycle() wiederholen

Die Funktion cycle() erstellt einen unendlichen Iterator, der wiederholt durch die Elemente eines Iterierbaren rotiert.

Was cycle() akzeptiert:

Ein einzelnes Iterierbares (Liste, Tupel, String usw.)

Was cycle() zurückgibt:

Einen unendlichen Iterator, der die Elemente des Iterierbaren wiederholt liefert
Nach dem Ende beginnt er wieder am Anfang

Wichtige Eigenschaften:

Erstellt einen unendlichen Iterator – stoppt nicht von selbst
Muss mit einer Abbruchbedingung verwendet werden (Zähler, break oder zip())
Speichereffizient: erstellt keine Kopien der Daten

python

from itertools import cycle
 
# Einen unendlichen Zyklus von Farben erstellen
colors = cycle(["red", "green", "blue"])
 
# Die ersten 10 Farben nehmen
for i, color in enumerate(colors):
    if i >= 10:
        break
    print(f"Item {i}: {color}")
# Output:
# Item 0: red
# Item 1: green
# Item 2: blue
# Item 3: red
# Item 4: green
# Item 5: blue
# Item 6: red
# Item 7: green
# Item 8: blue
# Item 9: red

Warnung: cycle() erzeugt einen unendlichen Iterator. Verwenden Sie es immer mit einer Abbruchbedingung (wie einem Zähler oder einer break-Anweisung), sonst erzeugen Sie eine Endlosschleife.

Ein praktischer Anwendungsfall ist das Wechseln zwischen Werten:

python

from itertools import cycle
 
# Zwischen zwei Hintergrundfarben für Tabellenzeilen alternieren
row_colors = cycle(["white", "lightgray"])
 
rows = ["Row 1", "Row 2", "Row 3", "Row 4", "Row 5"]
for row, color in zip(rows, row_colors):
    print(f"{row}: background-color: {color}")
# Output:
# Row 1: background-color: white
# Row 2: background-color: lightgray
# Row 3: background-color: white
# Row 4: background-color: lightgray
# Row 5: background-color: white

Hier verwenden wir zip() (das wir in Kapitel 37 kennengelernt haben), um jede Zeile mit einer Farbe zu paaren. Der cycle()-Iterator wiederholt die Farben automatisch nach Bedarf.

39.5.3) chain() und cycle() kombinieren

Sie können itertools-Funktionen für komplexere Muster kombinieren:

python

from itertools import chain, cycle
 
# Ein Muster erstellen, das durch mehrere Sequenzen rotiert
pattern1 = [1, 2, 3]
pattern2 = [10, 20]
 
# Die Muster verketten und dann das Ergebnis zyklisch wiederholen
combined_pattern = cycle(chain(pattern1, pattern2))
 
# Die ersten 12 Werte nehmen
for i, value in enumerate(combined_pattern):
    if i >= 12:
        break
    print(value, end=" ")
# Output: 1 2 3 10 20 1 2 3 10 20 1 2
 
print()  # Output: Newline

Das erzeugt ein wiederholendes Muster: 1, 2, 3, 10, 20, 1, 2, 3, 10, 20, ...

Hier ist ein praktisches Beispiel, das einen rotierenden Plan erstellt:

python

from itertools import cycle
 
# Einen rotierenden Plan für Teammitglieder erstellen
team_members = ["Alice", "Bob", "Charlie"]
schedule = cycle(team_members)
 
# Aufgaben rotierend Teammitgliedern zuweisen
tasks = [
    "Review code",
    "Write tests",
    "Update documentation",
    "Fix bug #123",
    "Implement feature X",
    "Deploy to staging"
]
 
print("Task Assignments:")
for task, assignee in zip(tasks, schedule):
    print(f"  {assignee}: {task}")
# Output:
# Task Assignments:
#   Alice: Review code
#   Bob: Write tests
#   Charlie: Update documentation
#   Alice: Fix bug #123
#   Bob: Implement feature X
#   Charlie: Deploy to staging

In diesem Kapitel haben wir fünf wichtige Module der Standardbibliothek erkundet, die Pythons Möglichkeiten erweitern:

random: Zufallszahlen erzeugen, zufällige Auswahlen treffen und Sequenzen mischen—unverzichtbar für Simulationen, Spiele und Tests
datetime: Mit Datumsangaben, Zeiten und Dauern arbeiten—Alter berechnen, Ereignisse planen und Zeitstempel formatieren
json: Daten mit anderen Programmen über das universelle JSON-Format austauschen—Anwendungszustand speichern, mit Web-APIs arbeiten und Konfiguration speichern
collections: Spezialisierte Container wie Counter zum Zählen und defaultdict zum automatischen Erstellen von Keys verwenden
itertools: Effiziente Iteratoren erstellen, mit chain() zum Kombinieren von Sequenzen und cycle() zum Wiederholen von Mustern

Diese Module sind Teil von Pythons Standardbibliothek—sie sind immer verfügbar, gut getestet und lösen gängige Programmierprobleme elegant. Wenn Sie komplexere Programme entwickeln, werden Sie häufig zu diesen Werkzeugen greifen. Sie repräsentieren Pythons Philosophie „batteries included“—leistungsstarke, sofort einsetzbare Lösungen für alltägliche Programmieraufgaben.