Die Python-Standardbibliothek

Was ist die Standardbibliothek?

Python wird oft mit dem Slogan “Batteries included” beschrieben. Das bedeutet: Python bringt eine riesige Sammlung von Modulen mit, die du ohne Installation sofort nutzen kannst — die Standardbibliothek.

# All das funktioniert ohne pip install:
import os
import datetime
import json
import math
import random
import re
import collections
import pathlib
import sys
import argparse

Die Standardbibliothek deckt fast alles ab: Dateiverwaltung, Netzwerk, Mathematik, Textverarbeitung, Datenbankzugriff, Multithreading und vieles mehr. In diesem Tutorial lernst du die wichtigsten Module kennen.

os und os.path — Betriebssystem-Interaktion

Das os-Modul ist deine Schnittstelle zum Betriebssystem. Damit kannst du Dateien verwalten, Umgebungsvariablen lesen und Systembefehle ausfuehren.

Verzeichnisse und Dateien

import os

# Aktuelles Arbeitsverzeichnis
print(os.getcwd())  # z.B. /home/user/projekte

# Verzeichnis wechseln
os.chdir("/tmp")

# Dateien und Ordner auflisten
inhalt = os.listdir(".")
print(inhalt)  # ['datei1.txt', 'ordner1', ...]

# Verzeichnis erstellen
os.mkdir("neuer_ordner")

# Verschachtelte Verzeichnisse erstellen
os.makedirs("ordner/unter_ordner/tief", exist_ok=True)

# Datei loeschen
os.remove("alte_datei.txt")

# Leeren Ordner loeschen
os.rmdir("leerer_ordner")

# Datei/Ordner umbenennen
os.rename("alter_name.txt", "neuer_name.txt")

Umgebungsvariablen

import os

# Umgebungsvariable lesen
home = os.environ.get("HOME", "Nicht gesetzt")
path = os.environ.get("PATH", "")

print(f"Home-Verzeichnis: {home}")

# Umgebungsvariable setzen (nur fuer diesen Prozess)
os.environ["MEINE_VARIABLE"] = "Hallo"

os.path — Pfadoperationen (klassisch)

import os.path

pfad = "/home/user/dokumente/bericht.pdf"

print(os.path.basename(pfad))   # bericht.pdf
print(os.path.dirname(pfad))    # /home/user/dokumente
print(os.path.splitext(pfad))   # ('/home/user/dokumente/bericht', '.pdf')
print(os.path.exists(pfad))     # True oder False
print(os.path.isfile(pfad))     # True oder False
print(os.path.isdir(pfad))      # True oder False

# Pfade plattformunabhaengig zusammensetzen
neuer_pfad = os.path.join("ordner", "unter_ordner", "datei.txt")
print(neuer_pfad)  # ordner/unter_ordner/datei.txt (Linux)
                    # ordner\unter_ordner\datei.txt (Windows)

Verzeichnisbaum durchlaufen

import os

# Alle Dateien in einem Verzeichnisbaum finden
for ordner, unterordner, dateien in os.walk("."):
    for datei in dateien:
        if datei.endswith(".py"):
            pfad = os.path.join(ordner, datei)
            print(pfad)

pathlib — Moderne Pfadoperationen

pathlib ist der moderne Ersatz fuer os.path. Es arbeitet objektorientiert und ist deutlich eleganter.

from pathlib import Path

# Pfad erstellen
pfad = Path("/home/user/dokumente/bericht.pdf")

# Eigenschaften
print(pfad.name)       # bericht.pdf
print(pfad.stem)       # bericht
print(pfad.suffix)     # .pdf
print(pfad.parent)     # /home/user/dokumente
print(pfad.parts)      # ('/', 'home', 'user', 'dokumente', 'bericht.pdf')

# Pruefen
print(pfad.exists())   # True/False
print(pfad.is_file())  # True/False
print(pfad.is_dir())   # True/False

Pfade zusammensetzen mit /

from pathlib import Path

# Elegant mit dem /-Operator
projekt = Path("mein_projekt")
config = projekt / "config" / "settings.json"
print(config)  # mein_projekt/config/settings.json

Dateien und Ordner verwalten

from pathlib import Path

# Ordner erstellen
ordner = Path("daten/backup")
ordner.mkdir(parents=True, exist_ok=True)

# Datei schreiben und lesen
datei = Path("notiz.txt")
datei.write_text("Hallo Welt!", encoding="utf-8")
print(datei.read_text(encoding="utf-8"))

# Dateien finden
for py_datei in Path(".").rglob("*.py"):
    groesse = py_datei.stat().st_size
    print(f"  {py_datei} ({groesse} Bytes)")

Aktuelles Verzeichnis und Home

from pathlib import Path

# Aktuelles Verzeichnis
aktuell = Path.cwd()
print(aktuell)

# Home-Verzeichnis des Benutzers
home = Path.home()
print(home)

# Downloads-Ordner (plattformunabhaengig)
downloads = Path.home() / "Downloads"
print(downloads)

datetime — Datum und Zeit

Das datetime-Modul ist dein Werkzeug fuer alles rund um Datum und Uhrzeit.

Aktuelles Datum und Zeit

from datetime import datetime, date, time, timedelta

# Jetzt
jetzt = datetime.now()
print(jetzt)  # 2026-02-10 14:30:45.123456

# Nur Datum
heute = date.today()
print(heute)  # 2026-02-10

# Einzelne Bestandteile
print(f"Jahr: {jetzt.year}")
print(f"Monat: {jetzt.month}")
print(f"Tag: {jetzt.day}")
print(f"Stunde: {jetzt.hour}")
print(f"Minute: {jetzt.minute}")
print(f"Wochentag: {jetzt.weekday()}")  # 0=Montag, 6=Sonntag

Datum erstellen

from datetime import datetime, date

# Bestimmtes Datum erstellen
geburtstag = date(1995, 3, 15)
print(geburtstag)  # 1995-03-15

# Datum mit Uhrzeit
termin = datetime(2026, 6, 15, 14, 30, 0)
print(termin)  # 2026-06-15 14:30:00

Formatierung mit strftime()

from datetime import datetime

jetzt = datetime.now()

# Deutsches Format
print(jetzt.strftime("%d.%m.%Y"))          # 10.02.2026
print(jetzt.strftime("%d.%m.%Y %H:%M"))    # 10.02.2026 14:30
print(jetzt.strftime("%A, %d. %B %Y"))     # Monday, 10. February 2026

# Nuetzliche Formate
print(jetzt.strftime("%Y-%m-%d"))           # 2026-02-10 (ISO-Format)
print(jetzt.strftime("%H:%M:%S"))           # 14:30:45

Wichtige Platzhalter:

String zu Datum parsen mit strptime()

from datetime import datetime

# Text -> Datum
text = "15.03.2026 14:30"
datum = datetime.strptime(text, "%d.%m.%Y %H:%M")
print(datum)       # 2026-03-15 14:30:00
print(type(datum)) # <class 'datetime.datetime'>

Rechnen mit timedelta

from datetime import datetime, timedelta

jetzt = datetime.now()

# In die Zukunft
morgen = jetzt + timedelta(days=1)
naechste_woche = jetzt + timedelta(weeks=1)
in_zwei_stunden = jetzt + timedelta(hours=2)

print(f"Morgen: {morgen.strftime('%d.%m.%Y')}")
print(f"Naechste Woche: {naechste_woche.strftime('%d.%m.%Y')}")

# In die Vergangenheit
gestern = jetzt - timedelta(days=1)

# Differenz zwischen zwei Daten
geburtstag = datetime(1995, 3, 15)
alter = jetzt - geburtstag
print(f"Tage seit Geburt: {alter.days}")
print(f"Jahre (ca.): {alter.days // 365}")

random — Zufallszahlen

Das random-Modul erzeugt Pseudozufallszahlen — perfekt fuer Spiele, Simulationen und Tests.

import random

# Zufaellige Ganzzahl (inklusive beider Grenzen)
zahl = random.randint(1, 6)
print(f"Wuerfel: {zahl}")

# Zufaellige Fliesskommazahl zwischen 0 und 1
zufall = random.random()
print(f"Zufall: {zufall}")

# Zufaellige Fliesskommazahl in einem Bereich
temperatur = random.uniform(18.0, 25.0)
print(f"Temperatur: {temperatur:.1f}°C")

Zufaellige Auswahl

import random

fruechte = ["Apfel", "Birne", "Kirsche", "Mango", "Banane"]

# Ein zufaelliges Element
print(random.choice(fruechte))

# Mehrere zufaellige Elemente (ohne Zuruecklegen)
print(random.sample(fruechte, 3))

# Mehrere zufaellige Elemente (mit Zuruecklegen)
print(random.choices(fruechte, k=3))

# Liste mischen
random.shuffle(fruechte)
print(fruechte)

Reproduzierbare Zufallszahlen

import random

# Seed setzen fuer reproduzierbare Ergebnisse
random.seed(42)
print(random.randint(1, 100))  # Immer 82
print(random.randint(1, 100))  # Immer 15

# Gleicher Seed = gleiche Ergebnisse
random.seed(42)
print(random.randint(1, 100))  # Wieder 82
print(random.randint(1, 100))  # Wieder 15

math — Mathematik

import math

# Konstanten
print(math.pi)    # 3.141592653589793
print(math.e)     # 2.718281828459045
print(math.inf)   # Unendlich
print(math.nan)   # Not a Number

# Grundfunktionen
print(math.sqrt(144))    # 12.0 (Quadratwurzel)
print(math.pow(2, 10))   # 1024.0 (Potenz)
print(math.log(100, 10)) # 2.0 (Logarithmus zur Basis 10)
print(math.log2(256))    # 8.0 (Logarithmus zur Basis 2)

# Runden
print(math.ceil(4.1))    # 5 (aufrunden)
print(math.floor(4.9))   # 4 (abrunden)

# Trigonometrie
print(math.sin(math.pi / 2))  # 1.0
print(math.cos(0))             # 1.0

# Weitere nuetzliche Funktionen
print(math.factorial(5))  # 120 (5!)
print(math.gcd(12, 8))    # 4 (groesster gemeinsamer Teiler)
print(math.isclose(0.1 + 0.2, 0.3))  # True (Fliesskommavergleich!)

math.isclose() ist besonders nuetzlich: Wegen Fliesskomma-Ungenauigkeiten ist 0.1 + 0.2 == 0.3 in Python False! Mit isclose() pruefst du “nah genug”.

json — JSON verarbeiten

JSON ist das Datenformat im Web. Python macht den Umgang damit kinderleicht.

import json

# Python-Dict -> JSON-String
daten = {
    "name": "Anna Mueller",
    "alter": 28,
    "sprachen": ["Python", "JavaScript"],
    "aktiv": True
}

json_string = json.dumps(daten, indent=2, ensure_ascii=False)
print(json_string)

# JSON-String -> Python-Dict
zurueck = json.loads(json_string)
print(zurueck["name"])      # Anna Mueller
print(zurueck["sprachen"])  # ['Python', 'JavaScript']

JSON mit Dateien

import json

# In Datei schreiben
with open("daten.json", "w", encoding="utf-8") as datei:
    json.dump(daten, datei, indent=2, ensure_ascii=False)

# Aus Datei lesen
with open("daten.json", "r", encoding="utf-8") as datei:
    geladen = json.load(datei)

Typumwandlung Python <-> JSON

re — Regulaere Ausdruecke (Grundlagen)

Regulaere Ausdruecke (Regex) sind musterbasierte Textsuche. Maechtig, aber am Anfang etwas gewoehnungsbeduerftig.

Grundlegende Suche

import re

text = "Meine Telefonnummer ist 0170-1234567 und meine Postleitzahl ist 80331."

# Alle Zahlenfolgen finden
zahlen = re.findall(r"\d+", text)
print(zahlen)  # ['0170', '1234567', '80331']

# Telefonnummer finden
telefon = re.search(r"\d{4}-\d{7}", text)
if telefon:
    print(f"Telefon: {telefon.group()}")  # 0170-1234567

# PLZ finden (5 Ziffern)
plz = re.search(r"\b\d{5}\b", text)
if plz:
    print(f"PLZ: {plz.group()}")  # 80331

Wichtige Regex-Muster

Ersetzen mit re.sub()

import re

text = "Kontakt: 0170-1234567 oder 0171-9876543"

# Telefonnummern zensieren
zensiert = re.sub(r"\d{4}-\d{7}", "XXXX-XXXXXXX", text)
print(zensiert)
# Kontakt: XXXX-XXXXXXX oder XXXX-XXXXXXX

E-Mail-Adressen finden

import re

text = "Schreibe an anna@example.com oder ben.mueller@firma.de"

emails = re.findall(r"[\w.+-]+@[\w-]+\.[\w.-]+", text)
print(emails)  # ['anna@example.com', 'ben.mueller@firma.de']

collections — Spezielle Datenstrukturen

Das collections-Modul bietet erweiterte Container-Typen, die ueber die eingebauten Listen und Dicts hinausgehen.

Counter — Dinge zaehlen

from collections import Counter

# Woerter zaehlen
text = "der hund und der katz und der maus"
woerter = text.split()
zaehler = Counter(woerter)

print(zaehler)
# Counter({'der': 3, 'und': 2, 'hund': 1, 'katz': 1, 'maus': 1})

# Die 2 haeufigsten
print(zaehler.most_common(2))
# [('der', 3), ('und', 2)]

# Buchstaben zaehlen
buchstaben = Counter("Mississippi")
print(buchstaben)
# Counter({'s': 4, 'i': 4, 'p': 2, 'M': 1})

defaultdict — Dict mit Standardwerten

from collections import defaultdict

# Normales Dict: KeyError bei fehlendem Schluessel
# defaultdict: Erstellt automatisch einen Standardwert

# Woerter nach Anfangsbuchstabe gruppieren
woerter = ["Apfel", "Birne", "Ananas", "Banane", "Avocado", "Beere"]

gruppen = defaultdict(list)
for wort in woerter:
    gruppen[wort[0]].append(wort)

print(dict(gruppen))
# {'A': ['Apfel', 'Ananas', 'Avocado'], 'B': ['Birne', 'Banane', 'Beere']}

from collections import defaultdict

# Zaehlen ohne vorherige Initialisierung
zaehler = defaultdict(int)
text = "aababccc"
for zeichen in text:
    zaehler[zeichen] += 1

print(dict(zaehler))  # {'a': 3, 'b': 2, 'c': 3}

namedtuple — Benannte Tupel

from collections import namedtuple

# Wie ein Tupel, aber mit benannten Feldern
Punkt = namedtuple("Punkt", ["x", "y"])
Person = namedtuple("Person", ["name", "alter", "beruf"])

p = Punkt(3, 4)
print(p.x, p.y)      # 3 4
print(p[0], p[1])     # 3 4 (wie normales Tupel)

anna = Person("Anna", 28, "Entwicklerin")
print(f"{anna.name} ist {anna.alter} und arbeitet als {anna.beruf}")

itertools — Kombinationen und Permutationen

Das itertools-Modul bietet leistungsstarke Iterator-Werkzeuge fuer effiziente Schleifen.

from itertools import combinations, permutations, product, chain, count, cycle

# Kombinationen (Reihenfolge egal)
farben = ["rot", "gruen", "blau"]
for kombi in combinations(farben, 2):
    print(kombi)
# ('rot', 'gruen')
# ('rot', 'blau')
# ('gruen', 'blau')

# Permutationen (Reihenfolge wichtig)
for perm in permutations(farben, 2):
    print(perm)
# ('rot', 'gruen'), ('rot', 'blau'), ('gruen', 'rot'), ...

# Kartesisches Produkt
for p in product(["S", "M", "L"], ["rot", "blau"]):
    print(p)
# ('S', 'rot'), ('S', 'blau'), ('M', 'rot'), ...

chain — Iteratoren verketten

from itertools import chain

liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
liste3 = [7, 8, 9]

# Alle drei Listen wie eine durchlaufen
for zahl in chain(liste1, liste2, liste3):
    print(zahl, end=" ")
# 1 2 3 4 5 6 7 8 9

groupby — Gruppieren

from itertools import groupby

# Daten muessen sortiert sein!
tiere = [
    ("Hund", "Saeugetier"),
    ("Katze", "Saeugetier"),
    ("Adler", "Vogel"),
    ("Papagei", "Vogel"),
    ("Lachs", "Fisch"),
]

for kategorie, gruppe in groupby(tiere, key=lambda x: x[1]):
    mitglieder = [t[0] for t in gruppe]
    print(f"{kategorie}: {', '.join(mitglieder)}")
# Saeugetier: Hund, Katze
# Vogel: Adler, Papagei
# Fisch: Lachs

sys — Systemparameter

import sys

# Python-Version
print(sys.version)         # 3.12.0 (main, ...)
print(sys.version_info)    # sys.version_info(major=3, minor=12, ...)

# Plattform
print(sys.platform)        # 'win32', 'linux', 'darwin'

# Kommandozeilen-Argumente
print(sys.argv)            # ['skript.py', 'arg1', 'arg2']

# Suchpfad fuer Module
print(sys.path)

# Programm beenden
# sys.exit(0)   # 0 = Erfolg
# sys.exit(1)   # 1 = Fehler

# Maximale Rekursionstiefe
print(sys.getrecursionlimit())  # 1000 (Standard)

Einfache Kommandozeilen-Argumente

# gruss.py
import sys

if len(sys.argv) > 1:
    name = sys.argv[1]
    print(f"Hallo, {name}!")
else:
    print("Hallo, Welt!")

# Aufruf: python gruss.py Anna
# Ausgabe: Hallo, Anna!

argparse — Kommandozeilen-Argumente

Fuer professionelle Kommandozeilen-Programme ist argparse der Standard. Es erstellt automatisch Hilfe-Texte und validiert Eingaben.

# rechner_cli.py
import argparse

# Parser erstellen
parser = argparse.ArgumentParser(
    description="Ein einfacher Taschenrechner fuer die Kommandozeile."
)

# Argumente definieren
parser.add_argument("zahl1", type=float, help="Erste Zahl")
parser.add_argument("zahl2", type=float, help="Zweite Zahl")
parser.add_argument(
    "-o", "--operation",
    choices=["add", "sub", "mul", "div"],
    default="add",
    help="Rechenoperation (Standard: add)"
)
parser.add_argument(
    "-v", "--verbose",
    action="store_true",
    help="Ausfuehrliche Ausgabe"
)

# Argumente parsen
args = parser.parse_args()

# Berechnung
operationen = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
    "mul": lambda a, b: a * b,
    "div": lambda a, b: a / b if b != 0 else float("inf"),
}

ergebnis = operationen[args.operation](args.zahl1, args.zahl2)

if args.verbose:
    symbole = {"add": "+", "sub": "-", "mul": "*", "div": "/"}
    symbol = symbole[args.operation]
    print(f"{args.zahl1} {symbol} {args.zahl2} = {ergebnis}")
else:
    print(ergebnis)

# Verwendung:
python rechner_cli.py 10 5 -o mul
# 50.0

python rechner_cli.py 10 5 -o add -v
# 10.0 + 5.0 = 15.0

python rechner_cli.py --help
# usage: rechner_cli.py [-h] [-o {add,sub,mul,div}] [-v] zahl1 zahl2
# ...

Praxis: Passwort-Generator

Kombiniere random, string und argparse zu einem nuetzlichen Werkzeug:

# passwort_generator.py
import random
import string
import argparse


def passwort_generieren(laenge=16, gross=True, zahlen=True, sonder=True):
    """Generiert ein sicheres Passwort."""
    zeichensatz = string.ascii_lowercase  # Immer Kleinbuchstaben

    if gross:
        zeichensatz += string.ascii_uppercase
    if zahlen:
        zeichensatz += string.digits
    if sonder:
        zeichensatz += "!@#$%&*+-=?"

    # Sicherstellen, dass mindestens ein Zeichen jeder Kategorie enthalten ist
    passwort = []
    if gross:
        passwort.append(random.choice(string.ascii_uppercase))
    if zahlen:
        passwort.append(random.choice(string.digits))
    if sonder:
        passwort.append(random.choice("!@#$%&*+-=?"))

    # Rest auffuellen
    while len(passwort) < laenge:
        passwort.append(random.choice(zeichensatz))

    # Mischen, damit die Pflichtzeichen nicht immer am Anfang sind
    random.shuffle(passwort)
    return "".join(passwort)


def passwort_staerke(passwort):
    """Bewertet die Staerke eines Passworts."""
    punkte = 0
    if len(passwort) >= 8:
        punkte += 1
    if len(passwort) >= 12:
        punkte += 1
    if len(passwort) >= 16:
        punkte += 1
    if any(c.isupper() for c in passwort):
        punkte += 1
    if any(c.isdigit() for c in passwort):
        punkte += 1
    if any(c in "!@#$%&*+-=?" for c in passwort):
        punkte += 1

    staerken = {0: "Sehr schwach", 1: "Schwach", 2: "Mittel",
                3: "Gut", 4: "Stark", 5: "Sehr stark", 6: "Ausgezeichnet"}
    return staerken.get(punkte, "Ausgezeichnet")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Sicherer Passwort-Generator")
    parser.add_argument("-l", "--laenge", type=int, default=16,
                        help="Passwortlaenge (Standard: 16)")
    parser.add_argument("-n", "--anzahl", type=int, default=1,
                        help="Anzahl der Passwoerter (Standard: 1)")
    parser.add_argument("--keine-zahlen", action="store_true",
                        help="Keine Zahlen verwenden")
    parser.add_argument("--keine-sonderzeichen", action="store_true",
                        help="Keine Sonderzeichen verwenden")

    args = parser.parse_args()

    print(f"\n{'=' * 40}")
    print(f"  Passwort-Generator")
    print(f"{'=' * 40}\n")

    for i in range(args.anzahl):
        pw = passwort_generieren(
            laenge=args.laenge,
            zahlen=not args.keine_zahlen,
            sonder=not args.keine_sonderzeichen
        )
        staerke = passwort_staerke(pw)
        print(f"  {pw}  [{staerke}]")

    print()

Praxis: Datum-Rechner

# datum_rechner.py
from datetime import datetime, timedelta, date


def tage_bis(ziel_datum_str):
    """Berechnet die Tage bis zu einem Zieldatum."""
    ziel = datetime.strptime(ziel_datum_str, "%d.%m.%Y").date()
    heute = date.today()
    differenz = ziel - heute

    if differenz.days > 0:
        print(f"Noch {differenz.days} Tage bis zum {ziel_datum_str}")
    elif differenz.days == 0:
        print(f"Das ist HEUTE!")
    else:
        print(f"Das war vor {abs(differenz.days)} Tagen")


def alter_berechnen(geburtstag_str):
    """Berechnet das Alter basierend auf dem Geburtstag."""
    geburtstag = datetime.strptime(geburtstag_str, "%d.%m.%Y").date()
    heute = date.today()

    alter = heute.year - geburtstag.year
    # Hatte die Person dieses Jahr schon Geburtstag?
    if (heute.month, heute.day) < (geburtstag.month, geburtstag.day):
        alter -= 1

    # Naechster Geburtstag
    naechster = date(heute.year, geburtstag.month, geburtstag.day)
    if naechster <= heute:
        naechster = date(heute.year + 1, geburtstag.month, geburtstag.day)

    tage_bis_geb = (naechster - heute).days

    print(f"Alter: {alter} Jahre")
    print(f"Naechster Geburtstag in {tage_bis_geb} Tagen ({naechster.strftime('%d.%m.%Y')})")


def wochentag_finden(datum_str):
    """Findet den Wochentag eines Datums."""
    wochentage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag",
                  "Freitag", "Samstag", "Sonntag"]

    datum = datetime.strptime(datum_str, "%d.%m.%Y")
    tag = wochentage[datum.weekday()]
    print(f"Der {datum_str} ist ein {tag}")


def arbeitstage_berechnen(start_str, ende_str):
    """Berechnet die Anzahl der Arbeitstage zwischen zwei Daten."""
    start = datetime.strptime(start_str, "%d.%m.%Y").date()
    ende = datetime.strptime(ende_str, "%d.%m.%Y").date()

    arbeitstage = 0
    aktuell = start
    while aktuell <= ende:
        if aktuell.weekday() < 5:  # Montag bis Freitag
            arbeitstage += 1
        aktuell += timedelta(days=1)

    gesamt = (ende - start).days + 1
    print(f"Zeitraum: {start_str} bis {ende_str}")
    print(f"Gesamttage: {gesamt}")
    print(f"Arbeitstage: {arbeitstage}")
    print(f"Wochenendtage: {gesamt - arbeitstage}")


if __name__ == "__main__":
    print("=== Datum-Rechner ===\n")

    tage_bis("31.12.2026")
    print()

    alter_berechnen("15.03.1995")
    print()

    wochentag_finden("03.10.1990")
    print()

    arbeitstage_berechnen("01.01.2026", "31.01.2026")

Uebungen

Uebung 1: Datei-Statistik

Erstelle ein Skript, das Statistiken ueber Dateien in einem Ordner ausgibt:

from pathlib import Path
from collections import Counter

def ordner_statistik(pfad="."):
    """Zeigt Statistiken ueber Dateien in einem Ordner."""
    ordner = Path(pfad)
    dateien = list(ordner.rglob("*"))
    nur_dateien = [d for d in dateien if d.is_file()]

    # Dateitypen zaehlen
    endungen = Counter(d.suffix.lower() for d in nur_dateien if d.suffix)

    print(f"Ordner: {ordner.resolve()}")
    print(f"Gesamtanzahl Dateien: {len(nur_dateien)}")
    print(f"\nDateitypen:")
    for endung, anzahl in endungen.most_common(10):
        print(f"  {endung}: {anzahl}")

    # Gesamtgroesse
    gesamt_bytes = sum(d.stat().st_size for d in nur_dateien)
    print(f"\nGesamtgroesse: {gesamt_bytes / 1024 / 1024:.2f} MB")

ordner_statistik(".")

Uebung 2: Textanalyse mit Regex

Analysiere einen Text mit regulaeren Ausdruecken:

import re
from collections import Counter

def text_analysieren(text):
    """Fuehrt eine umfassende Textanalyse durch."""
    # Woerter zaehlen
    woerter = re.findall(r"\b\w+\b", text.lower())
    print(f"Anzahl Woerter: {len(woerter)}")

    # Saetze zaehlen
    saetze = re.split(r"[.!?]+", text)
    saetze = [s.strip() for s in saetze if s.strip()]
    print(f"Anzahl Saetze: {len(saetze)}")

    # Haeufigste Woerter
    zaehler = Counter(woerter)
    print(f"\nTop 5 Woerter:")
    for wort, anzahl in zaehler.most_common(5):
        print(f"  '{wort}': {anzahl}x")

    # E-Mails und URLs finden
    emails = re.findall(r"[\w.+-]+@[\w-]+\.[\w.-]+", text)
    urls = re.findall(r"https?://[\w./-]+", text)

    if emails:
        print(f"\nGefundene E-Mails: {emails}")
    if urls:
        print(f"Gefundene URLs: {urls}")

beispiel = """
Python ist eine grossartige Programmiersprache. Python wird in vielen
Bereichen eingesetzt. Fuer Fragen schreibe an hilfe@example.com oder
besuche https://python.org fuer mehr Informationen. Python macht Spass!
"""

text_analysieren(beispiel)

Uebung 3: Datenverarbeitung

Kombiniere datetime, random und json fuer eine kleine Datenanalyse:

import random
import json
from datetime import datetime, timedelta
from collections import Counter

def verkaufsdaten_generieren(anzahl=50):
    """Generiert zufaellige Verkaufsdaten."""
    produkte = ["Laptop", "Maus", "Tastatur", "Monitor", "Headset"]
    daten = []
    start = datetime(2026, 1, 1)

    for _ in range(anzahl):
        datum = start + timedelta(days=random.randint(0, 30))
        eintrag = {
            "datum": datum.strftime("%Y-%m-%d"),
            "produkt": random.choice(produkte),
            "menge": random.randint(1, 10),
            "preis": round(random.uniform(10, 500), 2)
        }
        daten.append(eintrag)

    return daten

def daten_analysieren(daten):
    """Analysiert die Verkaufsdaten."""
    # Umsatz pro Produkt
    umsatz = {}
    for eintrag in daten:
        produkt = eintrag["produkt"]
        summe = eintrag["menge"] * eintrag["preis"]
        umsatz[produkt] = umsatz.get(produkt, 0) + summe

    print("=== Verkaufsanalyse ===\n")
    print("Umsatz pro Produkt:")
    for produkt, summe in sorted(umsatz.items(), key=lambda x: -x[1]):
        print(f"  {produkt:12s}: {summe:>10.2f} EUR")

    # Meistverkauftes Produkt
    verkauft = Counter()
    for eintrag in daten:
        verkauft[eintrag["produkt"]] += eintrag["menge"]

    print(f"\nMeistverkauft: {verkauft.most_common(1)[0]}")
    print(f"Gesamtumsatz: {sum(umsatz.values()):.2f} EUR")

# Generieren, speichern, laden und analysieren
daten = verkaufsdaten_generieren(50)

with open("verkauf.json", "w", encoding="utf-8") as f:
    json.dump(daten, f, indent=2, ensure_ascii=False)

with open("verkauf.json", "r", encoding="utf-8") as f:
    geladene_daten = json.load(f)

daten_analysieren(geladene_daten)

# 1. dir() -- Was bietet ein Modul?
import collections
print([x for x in dir(collections) if not x.startswith("_")])

# 2. help() -- Wie funktioniert eine Funktion?
help(collections.Counter.most_common)

# 3. Die offizielle Dokumentation
# https://docs.python.org/3/library/