Python

Literale, Variablen, Zuweisungen, Ausdrücke, Operatoren und Kommentare verwenden. Dabei entsteht ein klares Modell davon, wie Python Quelltext auswertet und Werte im Speicher bindet.

Die Entwicklung von Python von den frühen Versionen über Python 2 und 3 bis zum heutigen Veröffentlichungsmodell nachvollziehen. PEPs, die Python Software Foundation und Veränderungen des Ökosystems erklären, warum modernes Python so arbeitet wie heute.

Mit Ganzzahlen, Fließkommazahlen, komplexen Zahlen und Dezimalwerten rechnen. Rundung, Genauigkeitsgrenzen, Zufallszahlen und mathematische Funktionen passend einsetzen.

Text erzeugen, indizieren, zerlegen, suchen, ersetzen und formatieren. Unicode, Zeichenkodierungen, f-Strings und der sichere Umgang mit Bytes werden an realen Textdaten geübt.

Vergleiche, boolesche Ausdrücke sowie if-, elif- und else-Blöcke einsetzen. Wahrheitstests, Kurzschlussauswertung und Identitätsvergleiche helfen dabei, klare Entscheidungen im Code zu formulieren.

Mit for- und while-Schleifen wiederholte Arbeit steuern. range, enumerate, zip, break, continue und Schleifen-else werden in kleinen Verarbeitungsaufgaben eingesetzt.

Geordnete Daten in Listen und Tupeln speichern, lesen, verändern, sortieren und kopieren. Slicing, Entpacken, Veränderbarkeit und verschachtelte Strukturen bilden die Grundlage für größere Datenmodelle.

Schlüssel-Wert-Daten mit Dictionaries und eindeutige Werte mit Sets verwalten. Nachschlagen, Aktualisieren, Mengenoperationen und geeignete Schlüsseltypen werden praktisch angewendet.

Wiederverwendbaren Code mit def, Parametern, Rückgabewerten und Docstrings schreiben. Positions-, Schlüsselwort-, Standard- und variable Argumente ermöglichen flexible Schnittstellen.

Lokale, globale und umschließende Namensräume sowie die LEGB-Regel nachvollziehen. Referenzen, Veränderbarkeit, Argumentübergabe und Closures erklären typische Seiteneffekte und Fehler.

Listen, Sets und Dictionaries kompakt aus vorhandenen Daten ableiten. Bedingte Comprehensions und Generatorausdrücke werden so eingesetzt, dass der Code lesbar und speichersparend bleibt.

Dateien sicher lesen und schreiben sowie Verzeichnisse mit pathlib verwalten. Pfade, Kodierungen, Dateioperationen und portable Verarbeitung werden in einem kleinen Dateiprojekt verbunden.

Fehler mit try, except, else und finally behandeln und gezielt mit raise auslösen. Eigene Ausnahmeklassen und hilfreiche Fehlermeldungen machen Programme robuster, ohne Fehler still zu verschlucken.

Code auf Module und Pakete verteilen und mit import kontrolliert wiederverwenden. Suchpfade, relative Importe, __name__, Paketstrukturen und zirkuläre Importe werden nachvollziehbar gemacht.

Projekte mit venv isolieren und Abhängigkeiten mit pip oder modernen Paketmanagern reproduzierbar installieren. Versionsgrenzen, Sperrdateien und Konfliktanalyse sorgen für verlässliche Entwicklungsumgebungen.

Eigene Typen mit Klassen, Instanzen, Attributen und Methoden modellieren. Konstruktoren, Klassenattribute, Properties und klare Objektgrenzen werden anhand eines kleinen Domänenmodells geübt.

Verhalten durch Komposition, Vererbung und Polymorphie strukturieren. Abstrakte Basisklassen, Mixins und Method Resolution Order helfen bei der Wahl zwischen flexiblen und eng gekoppelten Entwürfen.

Spezielle Methoden wie __repr__, __eq__, __hash__, __len__ und __call__ gezielt implementieren. Dadurch fügen sich eigene Klassen natürlich in Operatoren, Container und andere Sprachmechanismen ein.

Das Iteratorprotokoll mit iter und next verwenden und eigene Iteratoren schreiben. Generatorfunktionen, yield, Delegation und verzögerte Auswertung ermöglichen speichersparende Datenströme.

Funktionen und Klassen mit Decorators erweitern, ohne ihren Kerncode zu verändern. Wrapper, functools.wraps, parametrisierte Decorators und typische Anwendungen wie Caching werden praktisch umgesetzt.

Ressourcen mit with zuverlässig öffnen und wieder freigeben. Eigene Context Manager mit Klassen und contextlib schützen Dateien, Verbindungen, Sperren und temporäre Zustände.

Datenorientierte Klassen mit @dataclass knapp und korrekt definieren. Standardwerte, unveränderliche Instanzen, Sortierung, Nachbearbeitung und der Vergleich mit normalen Klassen werden behandelt.

Typannotationen für Funktionen, Collections, Klassen und generische APIs schreiben. Union-Typen, TypeVar, Protocol und statische Typprüfung helfen, Schnittstellen zu dokumentieren und Fehler früher zu finden.

Strukturelles Pattern Matching mit match und case für verschachtelte Daten und klar erkennbare Varianten einsetzen. Guards, Sequenz-, Mapping- und Klassenmuster werden gegen klassische Bedingungen abgewogen.

Funktionen als Werte verwenden und Daten mit map, filter, reduce sowie kleinen Lambdas verarbeiten. Reine Funktionen, unveränderliche Daten und functools werden dort genutzt, wo sie den Code wirklich vereinfachen.

Wichtige Module wie collections, itertools, enum, heapq, bisect, math, statistics und secrets passend auswählen. Kleine Aufgaben zeigen, wann vorhandene Bausteine besser sind als eigene Implementierungen.

Texte mit regulären Ausdrücken suchen, prüfen, zerlegen und umformen. Gruppen, Quantifizierer, Grenzen, Flags und typische Leistungsfallen werden an Protokollen und Eingabedaten geübt.

Zeitpunkte, Zeitspannen und Kalenderdaten mit datetime verarbeiten. Zeitzonen, Sommerzeit, ISO-Formate und verlässliche Speicherung verhindern häufige Fehler in internationalen Anwendungen.

Strukturierte Daten in CSV und JSON lesen, prüfen, umformen und schreiben. Serialisierung, Zeichensätze, fehlende Werte und sichere Grenzen zwischen internen Objekten und Austauschformaten stehen im Mittelpunkt.

Externe Eingaben anhand klarer Schemas prüfen und in typisierte Modelle umwandeln. Moderne Validierungsbibliotheken wie Pydantic zeigen verschachtelte Modelle, verständliche Fehler und kontrollierte Konvertierung.

Kommandozeilenprogramme mit Argumenten, Optionen, Unterbefehlen, Hilfetexten und sinnvollen Rückgabecodes bauen. Umgebungsvariablen, Standard-Ein- und -Ausgabe sowie Pipe-fähige Ausgaben machen sie alltagstauglich.

Dateien, Verzeichnisse, Prozesse und Betriebssystemaufgaben mit Python automatisieren. Ein wiederholbarer Workflow verarbeitet Eingaben, protokolliert Ergebnisse und behandelt Teilerfolge sicher.

HTTP-Anfragen senden, Header und Parameter setzen sowie JSON-Antworten auswerten. Authentifizierung, Zeitüberschreitungen, Wiederholungen, Pagination und Rate Limits werden beim Nutzen einer realen API berücksichtigt.

HTML-Dokumente abrufen und gezielt auswerten, ohne fragile Selektoren zu bauen. robots.txt, Nutzungsbedingungen, Lastbegrenzung und der Unterschied zwischen statischen und dynamischen Seiten gehören zur verantwortlichen Praxis.

Relationale Daten modellieren und mit SQL abfragen, ändern und absichern. Python-Code verwendet parametrisierte Abfragen, Transaktionen, Migrationen und Connection Management statt unsicherer String-Konstruktion.

TCP- und UDP-Verbindungen mit Sockets aufbauen und einfache Protokolle implementieren. Nachrichtenrahmen, Zeitüberschreitungen, Verbindungsfehler und Client-Server-Abläufe machen Netzwerkkommunikation greifbar.

Automatisierte Tests mit pytest oder unittest schreiben und sinnvoll strukturieren. Assertions, Fixtures, Parametrisierung, Test Doubles und Abdeckungsmessung sichern Verhalten statt Implementierungsdetails.

Fehler systematisch reproduzieren, eingrenzen und mit Breakpoints, Stacktraces und dem Debugger untersuchen. Kleine Experimente und minimale Fehlerbeispiele ersetzen planloses Ändern des Codes.

Anwendungsereignisse mit dem logging-Modul strukturiert erfassen und über Metriken und Traces beobachtbar machen. Log-Level, Kontextdaten, sensible Inhalte und aussagekräftige Produktionssignale werden praktisch behandelt.

Lesbaren Python-Code mit klaren Namen, kleinen Einheiten und konsistentem Stil schreiben. Formatierer, Linter und Typprüfer wie Black, Ruff und mypy werden automatisiert eingesetzt, ohne Werkzeugmeldungen blind zu übernehmen.

Python-Projekte mit Git versionieren, Änderungen prüfen und sichere Branch- und Merge-Abläufe nutzen. Commits, Konfliktlösung, Tags und Code Reviews schaffen eine nachvollziehbare Zusammenarbeit.

Eigene Bibliotheken über pyproject.toml konfigurieren und als Quellarchiv oder Wheel bauen. Versionierung, Metadaten, optionale Abhängigkeiten und die Veröffentlichung in Paketindizes werden in einem vollständigen Paketprojekt umgesetzt.

Größere Programme in Schichten, Komponenten und stabile Schnittstellen gliedern. Abhängigkeitsrichtung, Ports und Adapter, Konfiguration sowie gezieltes Refactoring verhindern, dass ein Skript zum unwartbaren Monolithen wird.

Nebenläufige Ein- und Ausgabe mit Threads koordinieren. Sperren, Queues, Race Conditions, Deadlocks und die Grenzen des Global Interpreter Lock werden an einem Worker-System sichtbar.

CPU-intensive Arbeit auf mehrere Prozesse verteilen. Process Pools, Serialisierung, gemeinsamer Zustand, Startmethoden und die Kosten der Prozesskommunikation bestimmen einen sinnvollen Entwurf.

Viele wartende Aufgaben mit async, await und dem Event Loop effizient bearbeiten. Tasks, Cancellation, Timeouts, asynchrone Context Manager und kontrollierte Nebenläufigkeit werden in einem Netzwerkprogramm eingesetzt.

Laufzeit und Speicherverbrauch messen, bevor Code optimiert wird. Profiling, Benchmarks, algorithmische Verbesserungen, Caching und passende Datenstrukturen führen zu belegbaren statt vermuteten Beschleunigungen.

Bytecode, Referenzzählung, Garbage Collection, Objektlayout und den Global Interpreter Lock in CPython nachvollziehen. Dieses Laufzeitmodell erklärt Speicherverhalten, Performance und Unterschiede zu anderen Python-Implementierungen.

Python mit nativen Bibliotheken und anderen Sprachen verbinden. ctypes, CFFI, C-Erweiterungen und moderne Bindings zeigen, wie bestehender Systemcode genutzt oder besonders heiße Pfade ausgelagert werden.

Interaktive Analysen in Jupyter-Notebooks durchführen und reproduzierbar aufbauen. Zellreihenfolge, Kernelzustand, Darstellungen, Exporte und die Grenze zwischen Experiment und produktivem Modul werden bewusst gehandhabt.

Numerische Arrays mit NumPy erstellen, indizieren und vektorisieren. Broadcasting, Datentypen, lineare Algebra und Speicherlayout ermöglichen schnelle Berechnungen ohne unnötige Python-Schleifen.

Tabellarische Daten mit pandas laden, bereinigen, verbinden, gruppieren und umformen. Fehlende Werte, Datentypen, Zeitreihenindizes und effiziente Operationen werden an einem realen Datensatz geübt.

Daten mit Matplotlib und darauf aufbauenden Werkzeugen klar visualisieren. Diagrammwahl, Achsen, Farben, Beschriftungen und irreführende Darstellungen werden anhand einer kleinen Analyse beurteilt.

Numerische Integration, Optimierung, Signalverarbeitung und Statistik mit SciPy durchführen. Dabei stehen die Wahl geeigneter Verfahren, Einheiten, Genauigkeit und die Prüfung der Ergebnisse im Vordergrund.

Einen klassischen Machine-Learning-Ablauf mit scikit-learn umsetzen: Daten aufteilen, Merkmale vorbereiten, Modelle trainieren und fair bewerten. Pipelines, Kreuzvalidierung, Datenleckage und reproduzierbare Experimente sichern belastbare Resultate.

Serverseitige Webanwendungen mit Routing, Templates, Formularen, Sitzungen und Datenbankzugriff entwickeln. Frameworks wie Django oder Flask dienen dazu, Architektur, Sicherheit und Request-Response-Abläufe praktisch umzusetzen.

HTTP-APIs mit klaren Ressourcen, Schemas und Statuscodes entwerfen und implementieren. Authentifizierung, Versionierung, Fehlerformate, OpenAPI-Dokumentation und Tests werden etwa mit FastAPI oder einem vergleichbaren Framework umgesetzt.

Grafische Desktop-Anwendungen mit Ereignisschleife, Widgets, Layouts und Hintergrundarbeit erstellen. Ein kleines Programm mit Tkinter oder Qt trennt Benutzeroberfläche, Zustand und Anwendungslogik sauber voneinander.

Eingaben als nicht vertrauenswürdig behandeln und typische Risiken wie Injection, unsichere Deserialisierung, Pfadmanipulation und Geheimnislecks vermeiden. Sichere Zufallswerte, Berechtigungen und Schutzgrenzen werden direkt im Python-Code angewendet.

Abhängigkeiten, Build-Prozesse und veröffentlichte Pakete gegen Manipulation absichern. Hashes, Sperrdateien, Herkunftsprüfung, Schwachstellenscans, signierte Artefakte und minimale Vertrauensketten schützen die Software-Lieferkette.

Python-Anwendungen mit reproduzierbaren Container-Images ausliefern. Kleine Basis-Images, mehrstufige Builds, Nicht-Root-Betrieb, persistente Daten und lokale Container-Komposition verbinden Entwicklung und Betrieb.

Tests, Qualitätsprüfungen, Paketbau und Auslieferung in automatisierten Pipelines verbinden. Caches, Geheimnisse, Freigaben, Rollbacks und geschützte Umgebungen machen CI/CD zuverlässig und nachvollziehbar.

Python-Dienste in verwalteten Cloud- und Serverless-Laufzeiten betreiben. Zustandslosigkeit, Kaltstarts, Ereignisquellen, Konfiguration, Kosten und Anbietergrenzen bestimmen, wann dieses Modell passt.

Konfiguration, Datenbankmigrationen, Health Checks, kontrolliertes Herunterfahren und Rollbacks für den laufenden Betrieb vorbereiten. Kapazität, Fehlerbudgets, Backups und Störungsanalyse ergänzen den Code um betriebliche Verantwortung.

KI-Werkzeuge für Entwürfe, Erklärungen, Tests und Refactorings einsetzen, ohne ihre Ausgaben ungeprüft zu übernehmen. Datenschutz, erfundene APIs, Sicherheitsfehler, Lizenzfragen und reproduzierbare Verifikation bestimmen einen verantwortlichen Arbeitsablauf.

Eine echte Anforderung von der Klärung über Entwurf und Implementierung bis zu Tests, Paketierung, Auslieferung und Beobachtung bearbeiten. Das Abschlussprojekt enthält dokumentierte Entscheidungen, automatisierte Qualitätsprüfungen und eine nachvollziehbare Übergabe.

Rollen und Spezialisierungen wie Backend-Entwicklung, Automatisierung, Datenarbeit, wissenschaftliches Rechnen und Plattformbetrieb einordnen. Portfolio-Projekte, Open-Source-Beiträge, relevante Zertifikate, Bewerbungsnachweise sowie PEPs, Dokumentation und Community-Kanäle zeigen Wege zum Einstieg und zum dauerhaften Weiterlernen.