Python Tutorial
- jetzt Python programmieren lernen

Grundlagen: Objektorientierte Programmierung (OOP) verstehen und anwenden in Python

Öfters liest man solche Worte wie Programmierparadigma und komplex zum Thema Objektorientierte Programmierung. Davon nicht erschrecken lassen!

Objektorientierte Programmierung ist nicht schwer und macht vieles einfacher! Also einfach auf das Abenteuer einlassen. Um das sperrige Wort Objektorientierte Programmierung zu vermeiden verwende ich die geläufige Abkürzung OOP.

Am Rande bemerkt: durch das Verständnis von OOP werden auch die Python Module und die komplette Sprache sehr viel einfacher verständlich.

OOP ganz einfach: Sprechen wir mal von Dingen (um die Materie greifbar zu machen)

  • Dinge haben Eigenschaften wie z.B. Größe, Farbe und Alter
  • Dinge können Aktionen machen/bzw. mit diesen Dingen gemacht werden wie z.B. knurren, schmusen und schlafen

Bisher hatten wir in Python entweder Daten (was wir bei unseren Dingen mit Eigenschaften beschrieben haben) oder wir haben irgendwelche Aufgaben erledigt mit Funktionen und Methoden (in die wir zweitweise verschiedene Daten reingekippt haben).

Was aber passiert, wenn wir Daten und Methoden miteinander verknüpfen? Dann haben wir schon Objektorientierte Programmierung (OOP) bzw. den Kerngedanken begriffen.

Wir trennen uns von den unspezifischen Datenstrukturen wie Variablen, Listen und Tupeln und gehen hin zu Datenstrukturen, die ein Objekt (sprich ein Ding) beschreiben.

Schauen wir uns einmal ganz konkret (m)eine Katze an. Die ist orange, fett und frisst nur Lasagne falls sie nicht schläft und heißt Garfield. Spaß beiseite, aber es kommt schon ganz gut hin mit dieser Beschreibung. Überleg einmal, welche Eigenschaften von Katzen einem einfallen und was Katzen so machen.

Eigenschaften einer Katze

Eigenschaften:

  • hat eine Farbe
  • hat ein Alter
  • hat einen Namen
  • hat 4 Beine

Wir bauen uns also ein allgemeines Bild von einer Katze – einen Bauplan. Wir spielen mit Python Gott und schaffen einen allgemeinen Katzen-Zusammenbau-Plan. Das ist unser Katzen-Klasse.

2 Katzen-Objekte mit unterschiedlichen Eigenschaften

Und nun können wir virtuelle Katzen in beliebiger Anzahl erschaffen – sprich ganz viele Objekte, die grundlegend Gleich nach dem Bauplan aufgebaut sind, aber sich in Ihren Eigenschaften (Farbe, Alter, Name) unterscheiden und in der Ausprägung der Methoden.

Methoden in der OOP

Was sind nun Methoden? Nichts anderes wie in der bisherigen Programmierung die Funktionen! Nur nennt sich Methode bei der OOP, die wir aufrufen können.

Methoden (Funktionen) einer Katze wären z.B.:

  • tut fressen
  • tut schlafen
  • tut schmusen
  • tut fauchen
  • tut krallen (manchmal)

Unsere Katze kann also sobald die Methode „fressen()“ aufgerufen wird den Futternapf leeren (oder die Maus verspeisen).

Je nach Objekt (nicht jede Katze ist gleich) tut (sprich wird eine Methode angewendet) eine Katze spielen, schmusen oder fauchen – muss aber nicht. Prinzipiell wäre es nach der Katzenklasse möglich.

Klasse Objekt
allgemeine Bauplan: Klasse Katze
allgemeine Bauplan: Klasse Katze
Konkretes Tier: Objekt katze_sammy
Konkretes Tier: Objekt katze_sammy

Eigenschaften:

  • Farbe
  • Alter
  • Rufname

Methoden:

  • miauen
  • schlafen
  • fressen
  • schmussen Eigenschaft:

Objekt:

  • fast orange
  • 3
  • Sammy

Methoden:

  • schlafen()
  • fressen()
  • schmussen()

Allgemeine Beschreibung, die Blaupause (Klassen definieren Objekte)

Objekte haben konkrete Werte

Aus der Klasse können wir noch jede Menge weitere Objekte machen. „Machen“ hört sich nicht wirklich professionell an, daher spricht man bei der OOP von Instanzen erstellen bzw. instanziieren.

Wir haben also folgende Begriffe in der OOP:

  • Klassen (die Blaupause)
  • Objekte (aus Klassen erstellte Instanzen)
  • Instanz (nichts anderes wie ein Objekt – Lateinische Begriffe hören sich einfach hipper an – die lateinische Bedeutung ist „abgeschlossene Einheit“
  • Eigenschaft (sprich Attribute – eine Beschreibung, wie das Objekt „ist“)
  • Methoden (flapsig „Funktionen“ – was das Objekt tun kann)
  • Vererbung (hoppla – noch nicht beschrieben)

Ein letzter Begriff aus der OOP: Vererbung

Ähnlich wie bei einem Erbfall bekommt der Erbende etwas vom Verblichenen. Allerdings muss bei der Programmierung nichts sterben.

Wenn wir bei unserem Katzenbeispiel bleiben. Eine Katze ist schon sehr konkret (was man spätestens beim Einsatz der Krallen spürt). Hier können wir noch einen Schritt davor machen. Wir können uns eine allgemeine Klasse „Tier“ vorstellen. So ein Tier hat wie die Katze „Farbe, Alter, Bezeichnung“ und „frisst und schläft“ normalerweise. Es ist eine allgemeine Sichtweise.

Wir können nun eine Klasse „Tier“ erzeugen, was diese Eigenschaften und Methoden hat.

Sprich unsere Klasse „Katze“ kann von der Klasse „Tier“ diese Eigenschaften und Methoden erben und die Katzen-Klasse benötigt dann nur noch die fehlenden Eigenschaften und Methoden (nicht jedes Tier kann schmusen oder hat Krallen für das Gegenteil).

Man spart sich also Programmierarbeit. Zumal wir aus der Klasse Tier auch eine Klasse Hund erstellen können. Auch der Hund hat alle Eigenschaften und Methoden von der Klasse Tier.

Um einen letzten Begriff noch einzuführen. Passt etwas bei der Vererbung nicht, dann kann man es in der Realität einfach nicht annehmen oder wegwerfen. Beim Programmieren dagegen kann man diese Eigenschaft bzw. Methode „überschreiben“. Viele Möglichkeiten die dann beim Programmieren eine konkrete Welt als binäre Welt abbilden lassen.

Das soll soweit erst einmal als grundlegendes Verständnis der OOP reichen. Diese werden in den folgenden Kapiteln noch deutlich klarer, wenn wir diese konkret an Beispielen nutzen.

In den folgenden Kapiteln schauen wir uns also an, wie wir in Python Klassen aufbauen und daraus Instanzen bilden (sprich Objekte wie die Katze Sammy erstellen).