Bitte warten...

Python: Objektorientierte Programmierung

Python unterstützt verschiedene Programmierparadigmen wie die prozedurale oder die objektorientierte Programmierung. An dieser Stelle soll auf die verschiedenen Sprachelemente der objektorientierten Programmierung (OOP) und ihre Verwendung eingegangen werden.

Objekte sind in diesem Zusammenhang Konstrukte, die an einen Bezeichner (Namen) gebunden sind und eine Reihe beliebiger Eigenschaften (Werte) und Methoden (Funktionen) enthalten können, auf die über den gewählten Bezeichner zugegriffen werden kann.

Das Konzept der objektorientierten Programierung soll hier am Beispiel von Code demonstriert werden, wie er in der Entwicklung eines Rollenspiels verwendet werden könnte.

Klassen

► Python-Dokumentation: Classes

Klassen sind quasi die Baupläne von Objekten. In folgendem Beispiel wird in Zeile 1 bis 30 die Klasse Mob() definiert, mit der in einem Rollenspiel die handelnden Charaktere erzeugt werden können. Die Klasse enthält eine Reihe von Eigenschaften eines Charakters (die innerhalb der Methode __init__(self) definiert werden), sowie eine Reihe von Methoden, mit denen der Status des Charakters verändert werden kann (damage(), recover() etc.). Die Variable self ist in der Definition der Klasse obligatorisch und repräsentiert die konkrete Instanz der Klasse.

Code auswählen
  1. class Mob():
  2. def __init__(self):
  3. self.name = None
  4. self.pos = [50, 40, 0]
  5. self.health = 100.0
  6. self.saturation = 100.0
  7. self.strength = 50.0
  8. self.xp = 0.0
  9. def damage(self, value):
  10. self.health *= value
  11. return self
  12. def recover(self, value):
  13. self.health *= value
  14. return self
  15. def feed(self, value):
  16. self.saturation *= value
  17. return self
  18. def empower(self, value):
  19. self.strength *= value
  20. return self
  21. def move(self, x, y, z):
  22. self.pos[0] += x
  23. self.pos[1] += y
  24. self.pos[2] += z
  25. return self
  26. player = Mob()
  27. player.name = "Oberon"
  28. print("Name", player.name) # Oberon
  29. print("Gesundheit", player.health) # 100.0
  30. player.damage(.9).move(5, -3, 0).empower(.8)
  31. print("Gesundheit", player.health) # 90.0
  32. print("Position", player.pos) # [55, 37, 0]
  33. print("Stärke", player.strength) # 60.0
  34. dwarf1 = Mob()
  35. dwarf1.name = "Laurin"
  36. print("Name", dwarf1.name) # Laurin
  37. print("Gesundheit", dwarf1.health) # 100.0

Objekte

In Zeile 32 wird nun ein neues Objekt als Instanz der Klasse Mob() an den Bezeichner player gebunden und somit der Spieler-Charakter erzeugt.

In Zeile 41 wird dann eine weitere Instanz der Klasse Mob() erzeugt und an den Bezeichner dwarf1 gebunden. Diese Instanz verfügt nun über die gleichen Eigenschaften und Methoden wie die Instanz player, aber mit eigenen Werten.

Eigenschaften

Der Name des Charakters wurde in der Klasse nicht vorgegeben (Vorgabewert: None) und kann nun innerhalb des Programmablaufs festgelegt werden. Die Eigenschaft health wurde dagegen bereits in der Klasse definiert und steht somit sofort zur Verfügung.

Methoden

In Zeile 36 werden nun einige der verfügbaren Methoden auf das Objekt player angewandt, wobei der Wert der Änderung einer Eigenschaft in dem Methoden-Aufruf übergeben wird. Das Argument self muss hier nicht übergeben werden.

Die Methoden können nur verkettet werden, wenn die vorangehende Methode den Rückgabewert self hat.

Abgeleitete Klassen

Eine abgeleitete Klasse bzw. Unterklasse (subclass) enthält („erbt“) alle Eigenschaften und Methoden der Basisklasse bzw. Überklasse (superclass).

Eine Unterklasse wird erzeugt, indem man den Namen der Basisklasse als Argument übergibt (s. Zeile 1).

Natürlich macht eine Ableitung nur Sinn, wenn die Unterklasse sich von der Überklasse unterscheidet. Methoden können einfach durch eine Neudefinition unter gleichem Namen geändert werden. Für die Eigenschaften importiert man die Eigenschaften der Basisklasse mit der Funktion super().__init__(). Bestehende Eigenschaften können überschrieben und neue einfach ergänzt werden.

Code auswählen
  1. class Mob2(Mob):
  2. def __init__(self): # überschreibt Mob.__init__()
  3. super().__init__() # importiert die Eigenschaften von Mob() nach Mob2()
  4. self.name = "Gandalf"
  5. self.type = "Sorcerer"
  6. sorcerer1 = Mob2()
  7. print("Name", sorcerer1.name) # Gandalf (aus der Basisklasse überschrieben)
  8. print("Typ", sorcerer1.type) # Sorcerer (neu definiert)
  9. print("Gesundheit", sorcerer1.health) # 100.0 (aus der Basisklasse übernommen)
  10. sorcerer1.move(5, -3, 0).empower(.8) # die Methoden der Basisklasse wurden übernommen
  11. print("Stärke", sorcerer1.strength) # 40.0