Objektorientierte Programmierung mit Python (Grundlagen)

Wer IT-Teams führen oder technische Entscheidungen mitgestalten möchte, braucht ein belastbares Verständnis dafür, wie moderne Software tatsächlich aufgebaut ist. Dieser Kurs vermittelt die objektorientierte Programmierung mit Python von den Grundlagen bis zur Anwendung im Team: Klassen, Vererbung und Designprinzipien für wartbaren Code ebenso wie die Übersetzung fachlicher Anforderungen in technische Lösungen. Damit richtet er sich gleichermaßen an angehende Entwickler:innen und an IT-Führungskräfte, die technische Entscheidungen fundiert nachvollziehen möchten.

Grundlagen der objektorientierten Programmierung Der Einstieg gilt den zentralen Bausteinen der Objektorientierung: Klassen, Objekten und ihrem Zusammenspiel. Die Teilnehmenden üben an konkreten Python-Beispielen, bevor die Konzepte komplexer werden.

• Klassen und Objekte als zentrale Bausteine der Objektorientierung verstehen
• Attribute und Methoden zur Strukturierung von Objekten definieren
• Konstruktoren zur kontrollierten Erzeugung von Objekten nutzen
• Kapselung zur sauberen Trennung von internem Zustand und Schnittstelle anwenden
• Objektbeziehungen wie Komposition und Aggregation unterscheiden
• Einfache objektorientierte Programme in Python selbstständig entwerfen

Vererbung, Polymorphismus und Designprinzipien Aufbauend auf den Grundlagen vertieft dieser Block, wie sich Code über Vererbung wiederverwenden und über Polymorphismus flexibel gestalten lässt – und wie Designprinzipien dabei helfen, Software wartbar zu halten.

• Vererbung zur Wiederverwendung und Erweiterung bestehender Klassen einsetzen
• Polymorphismus zur flexiblen Gestaltung von Schnittstellen nutzen
• Abstrakte Klassen und Schnittstellen für klare Architekturen entwerfen
• Designprinzipien wie Single Responsibility im eigenen Code anwenden
• Code-Duplikate durch geeignete Objektstrukturen vermeiden
• Bestehenden Code zur Verbesserung der Wartbarkeit refaktorisieren

Von der Anforderung zur Softwarelösung Python-Entwickler:innen übersetzen fachliche Anforderungen in funktionierenden Code. Dieser Block zeigt, wie sich Anforderungen von Product Ownern in objektorientierte Teilaufgaben zerlegen und technisch umsetzen lassen.

• Anforderungen von Product Ownern in technische Aufgaben übersetzen
• Komplexe Problemstellungen in handhabbare, objektorientierte Teilaufgaben zerlegen
• Python in unterschiedlichen Anwendungsbereichen wie Automatisierung oder Datenverarbeitung einsetzen
• Logisches Denken zur Strukturierung von Lösungswegen einsetzen
• Testfälle zur Absicherung objektorientierter Funktionalität entwickeln
• Softwarelösungen für konkrete fachliche Anforderungen konzipieren

Zusammenarbeit und technische Führung im Entwicklungsteam Der letzte inhaltliche Block richtet sich besonders an angehende IT-Führungskräfte: Wie arbeiten Entwicklungsteams zusammen, und wie lassen sich technische Entscheidungen gegenüber Nicht-Techniker:innen nachvollziehbar begründen?

• Arbeitsweisen und Rollen in Softwareentwicklungsteams nachvollziehen
• Technische Entscheidungen im Team nachvollziehbar begründen
• Code-Qualität und Wartbarkeit als Bewertungskriterium für Architekturentscheidungen einordnen
• Technische Diskussionen zwischen Entwicklung und Führungsebene vermitteln
• Auswirkungen von Designentscheidungen auf spätere Wartung und Erweiterung einschätzen
• Die eigene Rolle zwischen technischem Verständnis und Führungsverantwortung einordnen

Anwendung an einem durchgehenden Softwareprojekt Im praktischen Teil entwickeln die Teilnehmenden ein zusammenhängendes Softwareprojekt von der fachlichen Anforderung bis zur funktionierenden, objektorientierten Lösung.

• Eine fachliche Anforderung in ein objektorientiertes Klassenmodell übersetzen
• Klassen mit Attributen, Methoden und Konstruktoren in Python implementieren
• Vererbungsbeziehungen zwischen verwandten Klassen umsetzen
• Polymorphismus zur flexiblen Erweiterung des Beispielprojekts nutzen
• Bestehenden Code auf Wartbarkeit prüfen und gezielt refaktorisieren
• Eine komplexe Aufgabenstellung in mehrere objektorientierte Teilaufgaben zerlegen
• Testfälle für zentrale Klassen des Beispielprojekts entwickeln
• Eine Anforderung eines fiktiven Product Owners technisch umsetzen
• Architekturentscheidungen für das Beispielprojekt begründen und dokumentieren
• Code-Reviews im Team zu eigenen und fremden Lösungen durchführen
• Das fertige Beispielprojekt strukturiert präsentieren
• Den gesamten Weg von der Anforderung bis zur funktionierenden Softwarelösung nachvollziehen

Die vier Module folgen bewusst dem Weg vom technischen Grundverständnis zur Führungsperspektive: erst Klassen und Objekte, dann Vererbung und Designprinzipien, anschließend die Übersetzung fachlicher Anforderungen und zuletzt die Zusammenarbeit und Kommunikation im Entwicklungsteam. Wer den Kurs abschließt, versteht damit nicht nur, wie objektorientierter Code funktioniert, sondern auch, wie sich technische Entscheidungen im Team treffen und gegenüber der Führungsebene begründen lassen.

Der Kurs richtet sich an Einsteiger:innen, Quereinsteiger:innen und Fachkräfte aus angrenzenden Bereichen, die sich in Richtung IT-Führungskräfte entwickeln oder entsprechende Aufgaben übernehmen möchten. Da Vorkenntnisse nicht zwingend erforderlich sind, eignet sich der Kurs sowohl für den direkten Einstieg als Python-Entwickler:in als auch für Fachkräfte, die Programmierung für Führungsaufgaben verstehen möchten.

• Personen, die eine berufliche Neuausrichtung in Richtung Softwareentwicklung anstreben
• Fachkräfte, die perspektivisch technische Führungsaufgaben übernehmen möchten
• Quereinsteiger:innen mit Interesse an objektorientierter Programmierung
• IT-affine Fachkräfte, die technische Entscheidungen in Entwicklungsteams besser nachvollziehen möchten

Der Kurs ist projektorientiert aufgebaut: Neue OOP-Konzepte werden jeweils unmittelbar an einem wachsenden Beispielprojekt erprobt, statt isoliert an abstrakten Übungen. Die Teilnehmenden entwickeln durchgehend an derselben Softwarelösung weiter, sodass Klassen, Vererbung und Designprinzipien im Zusammenhang sichtbar bleiben.

Der modulare Aufbau führt von den Grundlagen der Objektorientierung über Vererbung und Designprinzipien bis zur Übersetzung fachlicher Anforderungen und der Zusammenarbeit im Entwicklungsteam. Jedes Modul baut auf dem vorherigen auf und mündet im abschließenden Softwareprojekt.

Der Kurs schließt mit einer Abschlussprüfung und einem Trägerzertifikat ab, das die erworbenen Python- und OOP-Kompetenzen dokumentiert. Es handelt sich um eine qualifizierte Teilnahmebescheinigung des Kursanbieters, nicht um eine Herstellerzertifizierung. Das entwickelte Softwareprojekt lässt sich unmittelbar als Nachweis praktischer Erfahrung in Bewerbungen einbringen.

Objektorientierte Programmierung ist das Fundament, auf dem ein Großteil moderner Software aufbaut – wer dieses Fundament versteht, kann nicht nur eigenen Code schreiben, sondern auch fremden Code und fremde Architekturentscheidungen nachvollziehen. Das gilt für angehende Entwickler:innen ebenso wie für Führungskräfte, die technische Entscheidungen mittragen müssen. Der Mehrwert dieses Kurses liegt in der doppelten Perspektive: Statt OOP rein technisch zu vermitteln, verbindet er das Programmierhandwerk mit der Frage, wie sich technische Entscheidungen im Team treffen und gegenüber Nicht-Techniker:innen begründen lassen – eine Kompetenz, die reine Programmierkurse selten abdecken. Für die berufliche Entwicklung bedeutet das einen klaren Vorteil: Wer objektorientierte Programmierung versteht und gleichzeitig weiß, wie Entwicklungsteams arbeiten, kann sowohl als Python-Entwickler:in einsteigen als auch den Weg in eine technische Führungsposition vorbereiten, ohne die eine oder andere Perspektive zu vernachlässigen.