Exkurs - Datenkapselung in Python

Öffentliche / private Attribute

Ein Attribut wird in Python zu einem privaten Attribut, wenn der Attributname mit zwei Unterstrichen beginnt und nicht mit Unterstrichen endet. Beginnt der Attributname nicht mit einem Unterstrich, so ist das Attribut öffentlich.

Zur Verdeutlichung betrachten wir die folgende Implementierung der Klasse Konto:

class Konto(object):
    def __init__(self, nummer):
        self.__nr = nummer
        self.__stand = 0.0
        self.__inhaber = None
        self.__minimum = -1000.0

    def einzahlen(self, betrag):
        self.__stand = self.__stand + betrag

    def auszahlen(self, betrag):
        if self.__stand - betrag >= self.__minimum:
            self.__stand = self.__stand - betrag
        else:
            print("Auszahlung nicht möglich!")

    def getNr(self):
        return self.__nr
    
    def getStand(self):
        return self.__stand

    def setStand(self, stand):
        if stand >= self.__minimum:
            self.__stand = stand
        else:
            print("Initialisierung nicht möglich!")

    def getMinimum(self):
        return self.__minimum

    def setMinimum(self, minimum):
        self.__minimum = minimum

Beachte, dass die Attribute __nr, __stand , __inhaber und __minimum hier alle private Attribute sind.

Zugriffsmethoden

Zugriffsmethoden benötigt man, um auf private Attribute lesend und schreibend zugreifen zu können. Das Programm oben zeigt, wie man solche Methoden implementiert.

Solche Zugriffsmethoden benutzt man, um z. B. privaten Attribut Werte zuzuweisen und um diese Werte anschließend auszulesen.

>>> k = Konto(3)
>>> k.getNr()
3
>>> k.setStand(500.0)
>>> k.getStand()
500.0

Achtung: Python-Besonderheiten

Python verhält sich bei privaten Attributen (leider) nicht so restriktiv, wie das eigentlich sein sollte. Der folgende Python-Dialog zeigt einige Besonderheiten von Python.

>>> k = Konto(3)
>>> k.__stand
Traceback (most recent call last):
  File ...
AttributeError: 'Konto' object has no attribute '__stand'
>>> k.__dict__
{'_Konto__minimum': -1000.0, '_Konto__nr': 3, '_Konto__stand': 0}
>>> k._Konto__stand
0

Wie erwartet kann man auf das private Attribut __stand des neu erzeugten Objekts k nicht zugreifen. Python meldet als Fehler, dass es kein Attribut __stand gibt. Der Aufruf k.__dict__ verrät, woran das liegt. Ein Aufruf wie k.__dict__ listet sämtliche Attribute mit den zugehörigen Attributwerten des betreffenden Objekts auf. Interessant ist hier, dass sich das private Attribut __stand hinter einem anderen Namen versteckt. Wenn man weiß, wie der neue Name - hier _Konto__stand - gebildet wird, dann kann man auf das betreffende Attribut zugreifen. Also: Private Attribute werden in Python mit anderen Namen versehen, so dass kein direkter Zugriff möglich ist. Kennt man den Namen, hinter dem sich ein privates Attribut verbirgt, so kann man durchaus auf dieses Attribut zugreifen. Python liefert also keinen echten Zugriffsschutz.

Die völlig unrestiktive Art von Python kann zu unerwartetem Verhalten von Objekten und sehr schwer zu findenden Fehlern führen. Der folgende Dialog zeigt ein solches Beispiel.

>>> k = Konto(3)
>>> k.__stand
Traceback (most recent call last):
  File ...
AttributeError: 'Konto' object has no attribute '__stand'
>>> k.__dict__
{_Konto__minimum': -1000.0, '_Konto__nr': 3, '_Konto__stand': 0}
>>> k.__stand = 100.0
>>> k.__stand
100.0
>>> k.__dict__
{_Konto__minimum': -1000.0, '_Konto__nr': 3, '_Konto__stand': 0, '__stand': 100.0}

Ein erster Zugriff auf das private Attribut __stand scheitert. Dann aber ist es - entgegen aller Zugriffslogik - scheinbar möglich, dem privaten Attribut __stand einen Wert zuzuweisen. Der Aufruf k.__dict__ erklärt erst, was hier passiert ist. Neben dem privaten Attribut __stand, das sich hinter dem neuen Namen _Konto__stand versteckt, gibt es noch öffentliches Attribut __stand, auf das man direkt zugreifen kann.

Das Beispiel zeigt, dass man in Python am besten klare Regeln befolgt, um nicht zu solch undurchschaubaren Objektsituationen zu gelangen.

Vereinbarung: Umgang mit privaten Attributen und Methoden

Wir werden im Folgenden bei der Implementierung von Klassen in Python keine Attribute und Methoden als privat deklarieren. Alle Attribute und Methoden sind daher direkt zugänglich. Allerdings werden wir von dem direkten Zugriff nicht immer Gebrauch machen. In der Regel werden wir keinen schreibenden Zugriff auf Attribute vornehmen. Zur Veränderung von Attributwerten sollen immer geeignete Methoden vorgesehen. Nur in begründeten Sonderfällen (z.B. zum schnellen Testen) weichen wir von dieser Vereinbarung ab.