inf-schule | Verwaltung von Objekten » Exkurs

Exkurs - Objekte in Python

Datenobjekte in Python

Jedes Datenobjekt in Python hat eine Identitätsnummer, einen Typ und einen Zustand. Ein Objekt der Klasse Konto könnte etwa wie folgt beschrieben werden:

Die Identitätsnummer ist die Adresse des Objekts im Speicher. Sie ist eine Zahl, mit der man ein Datenobjekt eindeutig identifizieren kann.

Der folgende Python-Dialog zeigt, wie man Zustand, Identitätsnummer und Typ eines Objekts bestimmt.

>>> rob = Roboter()
>>> rob.x
0
>>> rob.y
0
>>> rob.r
'S'
>>> id(rob)
20366320
>>> type(rob)

Veränderbare und unveränderbare Objekte

In Python werden sämtliche Daten durch Objekte repräsentiert. Python unterscheidet zwischen veränderbaren und unveränderbaren Objekten. Ein Objekt zur Darstellung einer Zahl wie z.B. der Zahl 0.0 ist ein unveränderbares Objekt. Sein Wert bzw. Zustand kann nicht verändert werden. Anders verhält es sich bei veränderbaren Objekten wie z.B. Objekten der Klasse Roboter oder Objekten der Klasse list. Mit Hilfe geeigneter Operationen lässt sich der Zustand solcher Objekte verändern.

Dieser Umstand führt dazu, dass sich die beiden folgenden Programme unterschiedlich verhalten. Während die Prozedur in Programm 1 einen Seiteneffekt bewirkt, verändert die Prozedur in Programm 2 den Wert der global definierten Variablen nicht.

Programm 1: Verarbeitung von Objekten

from roboter import *

def init(roboter):
    print(id(roboter))
    roboter.x = 0
    roboter.y = 0
    roboter.r = 'S'
    print(id(roboter))

rob = Roboter()
rob.schritt()
print(rob.x)
print(id(rob))
init(rob)
print(rob.x)
print(id(rob))

Programm 2: Verarbeitung von Zahlen

def init(zahl):
    print(id(zahl))
    zahl = 0.0
    print(id(zahl))

z = 100.0
print(z)
print(id(z))
init(z)
print(z)
print(id(z))

Zur Erklärung soll die Abarbeitung mit Hilfe von Objektdiagrammen verdeutlicht werden.

Veränderbare Objekte

Das folgende Ablaufprotokoll verdeutlicht, wie Seiteneffekte bei der Verarbeitung veränderbarer Objekte zustande kommen können.

def init(roboter):
    roboter.x = 0
    roboter.y = 0
    roboter.r = 'S'

Zunächst wird ein Objekt der Klasse Roboter erzeugt. Zusätzlich wird die Methode schritt aktiviert.

rob = Roboter()
rob.schritt()

Anschließend wird die Variable zur Verwaltung dieses Objekts als aktueller Parameter der Prozedur init übergeben.

init(rob)

Bei der Parameterübergabe wird die Zuweisung roboter = rob ausgeführt. Die lokal verfügbare Variable roboter verwaltet dann dasselbe Objekt wie die Variable rob.

    roboter.x = 0
    roboter.y = 0
    roboter.r = 'S'

Wenn die Prozedur init abgearbeitet ist, werden sämtliche nur lokal verfügbaren Variablen (hier also roboter) wieder entfernt.

Die Objektdiagramme zeigen, dass innerhalb der Prozedur das global definierte Objekt verändert wird. Dies führt also zu einem Seiteneffekt.

Unveränderbare Objekte

Das folgende Ablaufprotokoll verdeutlicht, dass bei der Verarbeitung von Prozeduren / Funktionen bei unveränderbaren Objekten keine Seiteneffekte entstehen.

def null(zahl):
    zahl = 0.0

Zunächst wird ein float-Objekt mit dem Wert 100.0 erzeugt und mit der Variablen z verwaltet.

z = 100.0

Diese Variable wird als aktueller Parameter der Prozedur null übergeben.

null(z)

Bei der Parameterübergabe wird die Zuweisung zahl = z ausgeführt. Die lokal verfügbare Variable zahl verwaltet dann dasselbe Objekt wie die Variable z.

    zahl = 0.0

Da das float-Objekt mit dem Wert 100.0 unveränderbar ist, führt die Zuweisung zahl = 0.0 dazu, dass der Variablen zahl ein anderes Objekt (ein float-Objekt mit dem Wert 0.0) zugeordnet wird. Die lokale Variable zahl verwaltet nach Abarbeitung der Zuweisung zahl = 0.0 also ein anderes Objekt als die globale Variable z.

Nach Abarbeitung der Anweisungen der Prozedur null werden sämtliche lokal verfügbaren Variablen (hier also zahl) wieder entfernt.