Zusammenhängendes Beispiel

Die bisher angesprochenen Punkte, sind die Grundlagen der Verwendung von Klassen und Objekten in Python. Diese Grundlagen werde ich nun in einem zusammenhängenden Beispiel dargestellt: form.py.

  1. Zunächst erstellen wir eine Basisklasse:

     1"""form module. Contains the classes Form, Square and Circle"""
     2
     3
     4class Form:
     5    """Form class: has method move"""
     6
     7    def __init__(self, x, y):
     8        self.x = x
     9        self.y = y
    10
    11    def move(self, deltaX, deltaY):
    12        self.x = self.x + deltaX
    
    Zeile 7

    Die __init__-Methode benötigt eine Instanz (self) und zwei Parameter

    Zeilen 8 und 9

    Auf die beiden Instanz-Variablen x und y, auf die über self zugegriffen wird.

    Zeile 10

    Die move-Methode benötigt eine Instanz (self) und zwei Parameter.

    Zeilen 11 und 12

    Instanz-Variablen, die in der move-Methode gesetzt werden.

  2. Als nächstes erstellt eine Unterklasse, die von der Basisklasse Form erbt:

    16class Square(Form):
    17    """Square Class:inherits from Form"""
    18
    19    def __init__(self, length=1, x=0, y=0):
    20        super().__init__(x, y)
    21        self.length = length
    
    Zeile 16

    Die Klasse Square erbt von der Klasse Form.

    Zeile 19

    Square’s __init__ nimmt eine Instanz (self) und drei Parameter, alle mit Voreinstellungen.

    Zeile 20

    __init__ von Square verwendet super(), um __init__ von Form aufzurufen.

  3. Schließlich erstellen wir eine weitere Unterklasse, die zudem eine statische Methode enthält:

    27class Circle(Form):
    28    """Circle Class: inherits from Form and has method area"""
    29
    30    circles = []
    31    pi = 3.14159
    32
    33    def __init__(self, diameter=1, x=0, y=0):
    34        super().__init__(x, y)
    35        self.diameter = diameter
    36        self.__class__.circles.append(self)
    37
    38    def circumference(self):
    39        return self.diameter * self.__class__.pi
    40
    41    @classmethod
    42    def circumferences(cls):
    43        """Class method to sum all circle circumferences."""
    
    Zeilen 29 und 30

    pi und circles sind Klassenvariablen für Circle.

    Zeile 34

    In der __init__-Methode fügt sich die Instanz in die Liste circles ein.

    Zeilen 37 und 38

    circumferences ist eine Klassenmethode und nimmt die Klasse selbst (cls) als Parameter.

    Zeile 41

    verwendet den Parameter cls für den Zugriff auf die Klassenvariable circles.

Jetzt könnt ihr einige Instanzen der Klasse Circle erstellen und sie analysieren. Da die __init__-Methode von Circle Standardparameter hat, könnt ihr einen Kreis erstellen, ohne irgendwelche Parameter anzugeben:

>>> import form
>>> c1 = form.Circle()
>>> c1.diameter, c1.x, c1.y
(1, 0, 0)

Wenn ihr Parameter angebt, werden diese verwendet, um die Werte der Instanz festzulegen:

>>> c2 = form.Circle(2, 3, 4)
>>> c2.diameter, c2.x, c2.y
(2, 3, 4)

Wenn ihr die move()-Methode aufruft, findet Python keine move()-Methode in der Klasse Circle, also wird in der Vererbungshierarchie nach oben gegangen und die move()-Methode von Form verwendet:

>>> c2.move(5, 6)
>>> c2.diameter, c2.x, c2.y
(2, 8, 10)

Ihr könnt auch die Klassenmethode circumferences() der Klasse Circle aufrufen, entweder über die Klasse selbst oder durch eine Instanz:

>>> form.Circle.circumferences()
9.424769999999999
>>> c2.circumferences()
9.424769999999999