SOLID-Programmierprinzipien Schulung: wartbare Klassen in Python

Einführung in die SOLID-Programmierung

• Vorteile der SOLID-Prinzipien: Änderbarkeit, Testbarkeit, geringere Kopplung
• Überblick über die fünf Prinzipien und ihre Herkunft bei Robert C. Martin
• SOLID in Python: Typ-Hinweise, typing.Protocol und abstrakte Basisklassen mit abc
• Statische Typprüfung mit mypy oder Pyright als frühe Rückmeldung zum Entwurf
• CRC-Karten im Entwurfsprozess: Klasse, Verantwortlichkeiten, Kollaborateure
• Testgetriebener Entwurf mit pytest: Schnittstelle aus der Nutzung ableiten

Prinzip der Schnittstellentrennung (Interface Segregation Principle)

• Einführung: Clients sollen nicht von Methoden abhängen, die sie nicht nutzen
• Objekte des Problembereichs: einzelne Datenproben als unveränderliche dataclass
• Sammlungen von Stichproben: Sequence und Iterable statt einer Sammelklasse für alles
• Lesen und Erstellen von Stichproben: Leser für CSV und JSON hinter getrennten Protokollen
• Schmale Protokolle kombinieren: Protokoll-Vererbung und strukturelle Typisierung

Liskov-Substitutions-Prinzip

• Einführung: Unterklassen halten den Vertrag ihrer Basisklasse ein
• Vor- und Nachbedingungen, Invarianten und das Rechteck-Quadrat-Problem
• Duck Typing: Verhalten statt Abstammung, Protocol als dokumentierter Vertrag
• Variationen der Schnittstelle: optionale Parameter, Rückgabetypen und Varianz
• Vermeidung von isinstance(): Polymorphie und functools.singledispatch statt Typweichen
• Strukturelles Pattern Matching mit match: wo es Typabfragen ordnet und wo es LSP verletzt

Das Open/Closed Design-Prinzip

• Einführung: offen für Erweiterung, geschlossen für Änderung
• Modifizieren einer Klasse und Beheben von Fehlern: wann Änderung legitim ist
• OCP durch Vererbung: Template-Methode mit abstrakten Methoden
• OCP durch Komposition: Verhalten als Callable oder Protokoll-Objekt übergeben
• Weitere OCP-Techniken: Registrierung per Dekorator, Plugins über Entry Points
• @typing.override und @final als Schutz für Erweiterungspunkte

Prinzip der Inversion von Abhängigkeiten (Dependency Inversion Principle)

• Einführung: Fachlogik hängt von Abstraktionen ab, nicht von Infrastruktur
• Injektion von Abhängigkeiten über den Konstruktor, Protocol als Abhängigkeitstyp
• Anwendungskonfiguration: Objekte an einer Stelle zusammenbauen, Einstellungen aus der Umgebung
• Manuelle Verdrahtung, DI-Bibliotheken oder Depends in FastAPI – Kriterien für die Wahl
• Konsequenzen für das Testen: Fakes statt tief verschachtelter Mocks
• Testdoubles über pytest-Fixtures bereitstellen, unittest.mock gezielt einsetzen

Prinzip der Einzelverantwortung und GRASP-Muster

• Einführung in die Einzelverantwortung: ein Grund zur Änderung, ein verantwortlicher Akteur
• Verantwortung in Modulen, Klassen und Funktionen erkennen und trennen
• GRASP-Muster: Hohe Kohäsion und Indirektion
• Weitere GRASP-Muster: Information Expert, Creator, Controller und Low Coupling
• Polymorphism, Pure Fabrication und Protected Variations

SOLID im Code-Review

• Typische Verstöße: Gottklasse, Typweichen, harte Importe aus der Infrastruktur
• Code Smells als Hinweis: lange Parameterlisten, Shotgun Surgery, Feature Envy
• Komplexitätsregeln in Ruff und Schichtgrenzen mit import-linter prüfen
• Wann SOLID übertrieben wird: Abstraktion ohne zweite Variante, YAGNI
• Vom Prinzip zum Muster: Überblick und Verweis auf Entwurfsmuster und Python Entwurfsmuster

SOLID-Verstöße in generiertem Python-Code

• Projektregel für den Agenten: Protocols statt isinstance()-Ketten, Abhängigkeiten per Konstruktor
• mypy im strikten Modus und import-linter-Verträge laufen nach jeder Agentenänderung
• CRC-Karte als Auftrag: Der Agent implementiert nur die vereinbarten Verantwortlichkeiten
• Gottklasse vom Agenten zerlegen lassen, nachdem pytest das Verhalten festgeschrieben hat
• Agent markiert im Pull Request Verstöße je SOLID-Prinzip mit Begründung, entschieden wird im Review

Praxisprojekt: Auswertung der Messreihen einer Wetterstation

• CRC-Karten für Messwert, Messreihe, Leser und Statistik entwerfen
• Leser für CSV und JSON hinter einem Protocol, dann ein drittes Format ohne Änderung ergänzen
• Statistik mit injiziertem Ausreißerfilter bauen und mit Fakes testen
• Generiertes Auswertungsmodul auf SOLID-Verstöße prüfen und refaktorisieren

Lernziele

• Sie verteilen Verantwortlichkeiten mit CRC-Karten und leiten Schnittstellen testgetrieben aus der Nutzung ab.
• Sie schneiden Python-Schnittstellen mit typing.Protocol so, dass Clients nur von den Methoden abhängen, die sie nutzen.
• Sie ersetzen Typabfragen mit isinstance() durch Polymorphie und halten das Liskov-Substitutionsprinzip ein.
• Sie erweitern Klassen über Vererbung und Komposition, ohne bestehenden Code zu ändern, und injizieren Abhängigkeiten testfreundlich.
• Sie benennen SOLID-Verstöße und GRASP-Muster im Code-Review und in generiertem Code begründet.

Zielgruppe

• Entwickler:innen mit objektorientierter Erfahrung, die wartbaren Code schreiben wollen
• Tech Leads und Reviewer:innen, die Code-Reviews mit klaren Kriterien fundierter führen möchten