10. Bibliotheken und Pakete

Bibliotheken und Pakete

Kein ernsthaftes Programm wird vollständig selbst geschrieben. Für Zufallszahlen, Datumsarithmetik, Bildbearbeitung oder Diagramme existieren fertige, getestete Bibliotheken, und ihre Verwendung ist keine Abkürzung, sondern professioneller Standard: Eine Bibliothek, die von tausenden Projekten eingesetzt wird, ist besser getestet, als es eigener Code je sein wird. Der Lehrplan formuliert entsprechend: geeignete Werkzeuge und umfangreiche Programmbibliotheken für gängige Aufgaben einsetzen.

Dieses Kapitel behandelt die drei Ebenen des Themas: die Standardbibliothek, die mit Python mitgeliefert wird; Drittanbieter-Pakete, die mit pip installiert werden, samt der dafür nötigen virtuellen Umgebungen; und eigene Module, also die Aufteilung des eigenen Codes auf mehrere Dateien.

Die Standardbibliothek

Python wird mit einer umfangreichen Standardbibliothek ausgeliefert (“batteries included”). Einige Module sind bereits im Einsatz gewesen: re (Kapitel 3), abc (Kapitel 6), csv und json (Kapitel 9). Ein Rundgang durch vier weitere, die in fast jedem Projekt auftauchen:

import random

random.randint(1, 6)                # random integer from 1 to 6
random.choice(["red", "green", "blue"])
random.shuffle(playlist)            # shuffle a list in place

from datetime import date, timedelta

today = date.today()
deadline = date(2027, 2, 1)
remaining = deadline - today        # a timedelta object
print(f"{remaining.days} days left")

from pathlib import Path

project = Path("renders")
for entry in project.glob("*.mp4"):        # all MP4 files in the folder
    print(entry.name, entry.stat().st_size)
(project / "archive").mkdir(exist_ok=True) # paths combine with /

from collections import Counter

extensions = Counter(path.suffix for path in Path("footage").iterdir())
print(extensions.most_common(3))
# [('.mp4', 412), ('.wav', 87), ('.jpg', 31)]

pathlib ersetzt dabei die fehleranfällige Bastelei mit Pfad-Strings (folder + "/" + name) durch Pfadobjekte mit Methoden und ist der moderne Standard für alles, was mit Dateien und Ordnern zu tun hat.

Batteries included: die Breite der Standardbibliothek

Der Ausdruck “batteries included” ist keine Werbephrase, sondern eine ausdrückliche Design-Entscheidung der Python-Entwickler: Die Sprache soll für die häufigsten Aufgaben ohne eine einzige Installation einsatzfähig sein. Die Standardbibliothek umfasst dadurch mehrere hundert Module, und ihr Umfang überrascht regelmäßig auch erfahrene Umsteiger. Ein Querschnitt, vom Alltäglichen bis zum Exotischen:

Bereich	Module	Was sie leisten
Alltag	math, random, datetime, pathlib, collections, itertools	Rechnen, Zufall, Zeit, Dateien, Datenstrukturen, Kombinatorik
Text und Formate	re, json, csv, textwrap, difflib	Muster, Austauschformate, Textumbruch, Datei-Vergleiche wie ein Diff-Tool
Datenbanken	sqlite3, dbm, shelve	eine vollwertige SQL-Datenbank in einer Datei, ohne Server und ohne Installation; einfache Schlüssel-Wert-Speicher
Kryptografie und Sicherheit	hashlib, secrets, hmac, ssl	Hashwerte (SHA-256 und Co., etwa für Datei-Integrität und Passwort-Hashing), kryptografisch sichere Zufallswerte und Tokens, signierte Nachrichten, verschlüsselte Verbindungen
Netz und Web	urllib, http.server, smtplib, email, socket	Webseiten abrufen, ein Miniatur-Webserver (python -m http.server), Mails senden und bauen, rohe Netzwerkverbindungen
Archive und Kompression	zipfile, tarfile, gzip, lzma	Archive lesen und schreiben, ohne externes Werkzeug
Nebenläufigkeit	threading, multiprocessing, asyncio	mehrere Dinge gleichzeitig, vom Thread bis zur asynchronen Ein-/Ausgabe
Exotisches	turtle, wave, zoneinfo, uuid, statistics, webbrowser	Schildkröten-Grafik, WAV-Dateien roh lesen, Zeitzonen, weltweit eindeutige IDs, Statistik, den Browser öffnen

Zwei Einträge verdienen für dieses Schuljahr besondere Betonung. sqlite3 bedeutet: Wer strukturierte Daten per SQL verwalten will, braucht dafür keinerlei Fremdsoftware; die Datenbank ist eine gewöhnliche Datei, und dasselbe Format steckt in unzähligen Anwendungen von Browsern bis zu Smartphone-Apps. Und hashlib/secrets bedeuten: Prüfsummen für Dateien, sichere Zufalls-Tokens und Passwort-Hashes sind Bordmittel; wer Sicherheitselemente selbst bastelt statt diese geprüften Bausteine zu verwenden, macht es fast sicher falsch.

Der Rundgang ist bewusst knapp; sein Zweck ist nicht Vollständigkeit, sondern ein Reflex: Vor dem Selbstschreiben in der Standardbibliothek nachsehen. Die zwei Anlaufstellen dafür: die offizielle Python-Dokumentation unter docs.python.org/3 (Tutorial, Sprachreferenz, HowTos) und darin insbesondere der Bibliotheksindex unter docs.python.org/3/library, der jedes Modul mit Beispielen dokumentiert. Die Wahrscheinlichkeit, dass ein Alltagsproblem dort bereits gelöst ist, ist hoch.

Eigene Module: Code auf Dateien aufteilen

Ab einigen hundert Zeilen wird eine einzelne Datei unübersichtlich. Python-Code lässt sich auf mehrere Dateien (Module) aufteilen; jede .py-Datei ist automatisch ein Modul, das importiert werden kann. Ein Projekt könnte so aussehen:

media_tool/
├── main.py          # entry point, ties everything together
├── assets.py        # MediaAsset class hierarchy
├── storage.py       # loading and saving (JSON, CSV)
└── test_assets.py   # tests for assets.py

main.py

from assets import ImageAsset, VideoAsset
import storage

library = storage.load_library("library.json")
library.append(ImageAsset("sunset.jpg", 4_200_000, 6000, 4000))
storage.save_library("library.json", library)

Beide Import-Formen sind gebräuchlich: import storage hält den Modulnamen sichtbar (storage.load_library(...), gut für Übersicht), from assets import ImageAsset importiert einzelne Namen direkt (gut bei häufiger Verwendung). Zu vermeiden ist from assets import *: Es kippt unkontrolliert alle Namen eines Moduls in den eigenen Namensraum, und niemand kann mehr nachvollziehen, woher ein Name stammt.

Die Aufteilung folgt dabei der Verantwortung: Datenklassen, Speicherlogik und Programmsteuerung sind getrennte Anliegen und damit getrennte Dateien. Das zahlt direkt auf Wartbarkeit und Testbarkeit ein (die Tests aus Kapitel 11 importieren assets.py, ohne dass main.py läuft) und bereitet die Architektur des Abschlussprojekts vor.

Der Doppelnutzen: Modul und Programm zugleich

Beim Import eines Moduls führt Python dessen Code aus. Damit ein Modul sowohl importierbar als auch direkt startbar ist, ohne beim Import unerwünscht loszulaufen, gibt es ein Standardidiom:

storage.py

def load_library(path):
    ...

if __name__ == "__main__":
    # runs only when executed directly: python storage.py
    # not when imported from main.py
    library = load_library("library.json")
    print(f"{len(library)} assets loaded")

Die Variable __name__ enthält beim direkten Start "__main__", beim Import den Modulnamen. Der Block dient typischerweise für Schnelltests und Demonstrationen des Moduls.

Drittanbieter-Pakete: pip und der PyPI

Jenseits der Standardbibliothek liegt der Python Package Index (pypi.org), das zentrale Verzeichnis mit hunderttausenden frei verfügbaren Paketen. Installiert wird mit dem mitgelieferten Werkzeug pip:

pip install pillow

Danach steht das Paket wie ein Standardmodul zur Verfügung. Damit stellt sich sofort ein Verwaltungsproblem, und dessen Lösung gehört zum Handwerk.

Virtuelle Umgebungen

Ohne weitere Maßnahmen installiert pip Pakete global, also für den ganzen Rechner. Das rächt sich mit dem zweiten Projekt: Projekt A braucht Version 9 einer Bibliothek, Projekt B Version 11; global kann nur eine existieren. Dazu kommt, dass niemand mehr weiß, welche der global angesammelten Pakete ein bestimmtes Projekt tatsächlich braucht.

Die Lösung sind virtuelle Umgebungen: pro Projekt ein eigener, isolierter Paketbestand in einem Unterordner des Projekts.

1. Umgebung anlegen (einmalig pro Projekt, im Projektordner):

   python -m venv .venv

2. Umgebung aktivieren (in jeder neuen Terminal-Sitzung):

   source .venv/bin/activate      # Linux, macOS
   .venv\Scripts\activate         # Windows

   Der Prompt zeigt danach (.venv) an; pip install wirkt jetzt nur noch auf dieses Projekt. VS Code erkennt die Umgebung und verwendet sie automatisch für Ausführen und Debuggen.

3. Abhängigkeiten dokumentieren. Die Datei requirements.txt im Projektordner listet, was das Projekt braucht:

   pillow==11.1.0
   pytest==8.3.4

   Sie wird von Hand gepflegt oder mit pip freeze > requirements.txt erzeugt. Wer das Projekt übernimmt (oder auf einem zweiten Rechner klont), stellt die Umgebung mit einem Kommando her:

   pip install -r requirements.txt

Damit schließt sich der Kreis zu Git (Kapitel 8): Der Ordner .venv/ gehört in die .gitignore (er ist erzeugbar und plattformabhängig), die requirements.txt gehört ins Repository. Repository plus requirements.txt ergibt eine reproduzierbare Umgebung: Jeder Rechner kommt mit drei Kommandos (git clone, python -m venv, pip install -r) zum identischen Stand. “Bei mir funktioniert es” ist damit kein Argument mehr, sondern ein Konfigurationsfehler.

Eine umfangreiche Bibliothek anhand ihrer Dokumentation einsetzen

Die eigentliche Kompetenz dieses Kapitels ist nicht das Installieren, sondern das Erarbeiten einer fremden Bibliothek aus ihrer Dokumentation. Bibliotheken lernt man nicht auswendig; man lernt, ihre Dokumentation zu lesen: das Tutorial für den Einstieg, die API-Referenz für die Details.

Als Beispiel dient Pillow, die Standardbibliothek für Bildbearbeitung, mit einer Aufgabe aus der Medienpraxis: Für einen Ordner voller Fotos sollen Vorschaubilder mit maximal 400 Pixel Kantenlänge erzeugt werden.

from pathlib import Path
from PIL import Image

source = Path("photos")
target = Path("thumbnails")
target.mkdir(exist_ok=True)

for path in source.glob("*.jpg"):
    with Image.open(path) as image:
        image.thumbnail((400, 400))         # shrink in place, keeps aspect ratio
        image.save(target / path.name)
        print(f"{path.name}: {image.size[0]}x{image.size[1]} px")

Der Weg zu diesem Programm ist wichtiger als das Programm: Die Startseite der Pillow-Dokumentation verweist auf ein Tutorial, dessen erste Abschnitte Image.open, save und thumbnail vorstellen; die Referenz beantwortet die Detailfrage, ob thumbnail das Seitenverhältnis erhält (ja) und ob es ein neues Bild liefert oder das bestehende verändert (es verändert). Mit denselben Mitteln findet man image.rotate(90), image.convert("L") für Graustufen oder ImageDraw zum Beschriften, etwa für ein Wasserzeichen.

Für die Auswahl einer Bibliothek bei mehreren Kandidaten drei Kriterien: Dokumentation (gibt es Tutorial und Referenz, sind sie aktuell?), Pflege (wann war die letzte Version, werden Fehler bearbeitet?) und Verbreitung (findet sich zu Fehlermeldungen etwas, gibt es die Bibliothek in fünf Jahren noch?). Ein Blick auf die Projektseite auf PyPI und das zugehörige Repository beantwortet alle drei in wenigen Minuten.

Weitere Kandidaten für eigene Projekte

Je nach Projektidee lohnt ein Blick auf: matplotlib (Diagramme), requests (HTTP-Abfragen, etwa für Web-APIs), pygame (2D-Spiele und Multimedia), openpyxl (Excel-Dateien), rich (formatierte Terminalausgabe). Für das Abschlussprojekt ist der Einsatz mindestens einer externen Bibliothek ausdrücklich erwünscht; die Auswahl ist anhand der drei Kriterien zu begründen.

Lernergebnisse: Was Sie nach diesem Kapitel können sollten

Nach Abschluss dieses Kapitels sollten Schülerinnen und Schüler in der Lage sein:

• Anwenden: Module der Standardbibliothek (random, datetime, pathlib, collections) für Alltagsaufgaben einsetzen und in der offiziellen Referenz nachschlagen.
• Anwenden: eigenen Code auf Module aufteilen, korrekt importieren und das __name__ == "__main__"-Idiom verwenden.
• Anwenden: virtuelle Umgebungen anlegen und aktivieren, Pakete mit pip installieren und Abhängigkeiten in requirements.txt dokumentieren.
• Erklären: warum Projekte isolierte, reproduzierbare Umgebungen brauchen und wie venv, requirements.txt und Git dabei zusammenspielen.
• Anwenden: eine unbekannte Bibliothek anhand ihrer Dokumentation erarbeiten und für eine konkrete Aufgabe einsetzen.
• Beurteilen: Bibliotheken nach Dokumentation, Pflege und Verbreitung bewerten und eine Auswahl begründen.

Passende Übungen

• Aufgabe 17 (Vertiefung) und Projektvorbereitung