Skip to content
Auf dieser Seite

Theorie OOP

Programmieren mit Python

Beim Objektorientierten Programmieren dreht sich alles – der Name sagt es – um sogenannte Objekte. Im folgenden Beispiel schauen wir als Beispiel nicht die Turtle, sondern ein anderes Tier, nämlich den «Hund» an.

Begriffe

KlasseObjekte
«Hund»«Bitzer»«Space-Bitzer»
EigenschaftWerte
FarbeGelbSpace-Blau
Bell-LautWuff!Beep!
Methodenbelle!, sitz!, hohle Stöckli!, schwimm!, iss!, …

Klasse

Das wäre hier sozusagen die Tierart «der Hund». Also wenn man so will – eine Vorlage für irgendeinen Hund.

Eigenschaften

Die Eigenschaften eines Hundes, z.B. seine Farbe oder der Laut den er beim Bellen von sich gibt.

Etwas salopp gesagt handelt es sich Variablen die zum Hund gehören.

Im Sinne der Abstrahierung beschränken wir uns natürlich auf Eigenschaften die für unser Programm Sinn machen.

Methoden

Die Fähigkeiten werden mit Hilfe von Methoden ausgedrückt. Was kann ein Hund? Z.B. «sitz machen» oder bellen.

Wiederum etwas salopp gesagt sind Methoden Unterprogramme die zum Hund gehören.

Die Methoden werden in der Klasse definiert.

Objekt

Das Objekt wäre der einzelne Hund mit seinen speziellen Eigenschaften und den Methoden. Aus einer Klasse können wir beliebig viele Objekte erzeugen. Diese können sich in ihrem Namen und den Werten der Eigenschaften unterscheiden.

Etwas salopp gesagt ist die Klasse eine Vorlage für das Objekt.

Sowohl Methoden also auch Eigenschaften sind bereits in der Klasse definiert. Das Objekt gibt den Eigenschaften Werte und kann die Methoden aufrufen.

Aufgabe: Turtle

  1. Notiere Eigenschaften der Turtle
  2. Notiere Methoden (also Fähigkeiten) der Turtle

Aufgabe: Dog

  1. Kommen dir weitere Eigenschaften für die Klasse Dog in den Sinn?
  2. Hast du Ideen für zusätzliche Methoden?

eigene Klasse

Die einfachste Python-Klasse sieht wie folgt aus

python
class Dog:
    pass
1
2

Die Klasse wird mit dem Schlüsselwort class definiert. Sie hat einen Namen (hier Dog). Klassennamen schreibt man zur Unterscheidung von Variablen gross.

Aufgabe: Klasse

Erstelle eine Datei dog.py und speichere den obenstehenden Inhalt ab.

Unsere Klasse Dog hat weder Eigenschaften noch Methoden. Ihr einziger Inhalt besteht in der Anweisung pass, die nichts tut, sondern da sein muss, weil Python keine wirklich leeren Klassen zulässt.

Nichtsdestotrotz können wir die Klasse verwenden. Dazu müssen wir diese importieren. Wir nehmen an die Klasse Dog sei in der Datei dog.py im selben Verzeichnis wie untenstehendes Testprogramm abgespeichert. So können wir diese importieren und verwenden:

python
from dog import Dog

bitzer = Dog()
space_bitzer = Dog()
1
2
3
4
Zeilen 3 & 4
wir erzeugen ein neue Objekte der Klasse Dog

Methoden

Methoden werden wie Unterprogramme definiert – allerdings in der Klasse drin. Somit gehören Methoden zum aus der Klasse erzeugten Objekt und haben auch Zugriff auf die Werte der Eigenschaften des Objektes.

python
class Dog:

    def bark(self):
        print("wau!")
1
2
3
4
Zeilen 3 & 4
wir definieren die Methode bark
Methoden erhalten immer self als erstes Argument. Damit können sie auf das Objekt zugreifen (mehr dazu weiter unten)

Hinweis: self

self ist bei Methoden immer das erste Argument.
Beim Aufruf der Methode wird dieses automatisch gesetzt!
self erlaubt der Methode Zugriff aufs Objekt.

Nun können wir nicht nur Hunde erzeugen, sondern auch die Methode bark aufrufen:

python
from dog import Dog

bitzer = Dog()
bitzer.bark()
1
2
3
4
Zeile 4
wir rufen die Methode bark auf

Hinweis: Punktnotation

Methoden und Eigenschaften eines Objektes rufen wir mit Punktnotation auf!

Aufgabe: Methoden

  1. Übernimm das obenstehende Beispiel und teste es
  2. Bau eine weitere Methode sit ein und rufe diese auf

Eigenschaften

Auf die Eigenschaften eines Objektes kann mit der Punktnotation zugegriffen werden:

python
from dog import Dog

bitzer = Dog()
bitzer.color = "beige"
print(bitzer.color)
1
2
3
4
5
Zeile 4
wir setzen die Farbe des Hundes bitzer auf beige
Zeile 5
wir rufen die Farbe des Hundes bitzer auf

Getter und Setter

Das direkte Setzen der Eigenschaften mit der Punktnotation birgt Gefahren und deshabl vermeidet vermeidet wenn immer möglich solche direkten Zugriffe. Eleganter geht der Zugriff mit sogenannten Set- und Get-Methoden.

Als Konvention benennt man diese immer gleich: set resp. get und dann der Name der Eigenschaft in sogenanntem CamelCase[1].
Dank dem Argument self können alle Methoden auf das eigene Objekt zugreifen.

python
class Dog:

    def setColor(self, color):
        self.color = color

    def getColor(self):
        return self.color
1
2
3
4
5
6
7

Nun können wir die Eigenschaft color mittels der Methode setColor festlegen und mittels getColor wieder aufrufen:

python
from dog import Dog

bitzer = Dog()
bitzer.setColor("beige")
print(bitzer.getColor())
1
2
3
4
5
Zeile 4
wir setzen die Farbe des Hundes bitzer auf beige
Zeile 5
wir rufen die Farbe des Hundes bitzer auf

Dank dem indirekten Setzen der Eigenschaften über den Setter können wir durch Überprüfen der Werte nun sicherstellen, dass nur gültige Werte gesetzt werden.

Aufgabe: Getter/Setter

  1. Übernimm das obenstehende Beispiel und teste es
  2. erweitere die setColor-Methode, so dass nur noch «Hunde-Farben» zulässig sind (also z.B. braun, grau, schwarz und weiss)

Methoden und Eigenschaften

Wir können nun die schon zu Beginn verwendete Methode bark anpassen, so dass verschiedene Hunde verschieden bellen:

python
class Dog:

    def setBarking(self, barking):
        self.barking = barking

    def bark(self):
        print(self.barking)
1
2
3
4
5
6
7
python
from dog import Dog

bitzer = Dog()
bitzer.setBarking("wuff!")
bitzer.bark()
1
2
3
4
5

Konstruktor

Oft möchte man gleich beim Erstellen des Objektes gewisse Eigenschaften festlegen, die ev. gar nicht mehr geändert werden sollen.

So ist es ja etwas komisch, dass der Hund die Fähigkeit hat, seine Farbe anzupassen. Wir würden wohl die Farbe besser gleich beim Erzeugen festlegen.

Andere Eigenschaften sollten immer gesetzt werden, z.B. der Bell-Laut der von der Methode bark verwendet wird.

Beides können wir mit der speziellen Methode __init__() – genannt Konstruktor – erreichen. Diese wird beim Erzeugen eines Objektes automatisch aufgerufen. Dabei werden die Argumente direkt übergeben.

python
class Dog:

    def __init__(self, color):
        self.color = color
        self.barking = "wau!"

    def bark(self):
        print(self.barking)
1
2
3
4
5
6
7
8

Ein so erzeugter Hund erhält eine beliebige Farbe und den Standard-Bell-Laut «wau!».

python
from dog import Dog

bitzer = Dog("beige")
bitzer.bark()
1
2
3
4
Zeile 3
Beim Erzeugen des Hundes müssen wir jetzt die Farbe als Argument übergeben

Aufgabe: Abschluss

Bau eine komplette Hundeklasse mit:

  • Konstruktor
  • Eigenschaften color und barking
  • Getter und Setter für barking
  • Methoden bark und sit

Erzeuge in einer Testklasse mehrere Objekte der Klasse Dog und teste ob die Eigenschaften und Methoden funktionieren.


  1. Da Namen in Python (und anderen Programmiersprachen) keine Leerschläge beinhalten dürfen, können wir nicht set color() schreiben. Bei Methoden schreiben wir stattdessen setColor() (CamelCase). Bei normalen Unterprogrammen würden wir set_color() schreiben (snake_case) ↩︎

Gymnasium Kirchenfeld, fts & lem