Die Kontrolle: das Geheimnis des Attributzugriffs

Oh hat Bag so gebaut, dass beim Erzeugen das Gewicht geprüft wird, damit keine negativen Gewichte vorkommen. In den Aufzeichnungen steht trotzdem ein Koffer mit -10 kg. Schichtleiterin Do Miran blättert durch das Zugangsprotokoll. „Am Haupteingang steht eine Kontrolle, aber der Koffer kam durch die Seitentür.“

Heute sehen wir uns die Kontrolle an, durch die Python geht, wenn obj.x gelesen oder geschrieben wird. Das ist zugleich das vollständige Bild der Leseregel, die wir in Lektion 7 als „erst die Instanz, dann die Klasse“ kennengelernt haben.

10-1. @property: eine Kontrolle am Attribut (9 min)

Das ist der Code aus der Meldung. Geprüft wird nur in __init__.

class Bag:
    def __init__(self, kg):
        if kg < 0:
            raise ValueError("negative weight")
        self.kg = kg

b = Bag(20)
b.kg -= 30
print(b.kg)
# -10

Beim Erzeugen ging es durch die Prüfung, aber das spätere b.kg -= 30 schreibt den Wert direkt ins __dict__ der Instanz. Das ist die Seitentür. Soll die Prüfung am Schreiben des Attributs selbst hängen, nimmt man @property.

class Bag:
    def __init__(self, kg):
        self.kg = kg
    @property
    def kg(self):
        return self._kg
    @kg.setter
    def kg(self, value):
        if value < 0:
            raise ValueError(f"negative weight: {value}")
        self._kg = value

b = Bag(20)
print(b.kg, vars(b))
# 20 {'_kg': 20}
b.kg -= 30
# ValueError: negative weight: -10

• Beim Lesen von b.kg wird die erste Funktion kg aufgerufen, beim Schreiben mit b.kg = v die Funktion unter @kg.setter. Von außen benutzt man es wie ein ganz normales Attribut.
• Auch self.kg = kg in __init__ geht durch den Setter. Die Prüfung muss also nur an einer Stelle stehen.
• Der eigentliche Wert liegt in _kg. Der Name kg ist ein property-Objekt, und zwar nicht in der Instanz, sondern in der Klasse.

Ohne Setter wird das Attribut schreibgeschützt. Das passt für Werte, die aus anderen Attributen berechnet werden.

class Box:
    def __init__(self, w, h):
        self.w, self.h = w, h
    @property
    def area(self):
        return self.w * self.h

x = Box(3, 4)
print(x.area, type(Box.__dict__["area"]).__name__)
# 12 property
x.area = 5
# AttributeError: property 'area' of 'Box' object has no setter

10-2. Deskriptoren: die Kontrolle im Bauplan (10 min)

Der Koffer aus der Meldung hat nicht nur ein Gewicht (kg), sondern auch eine Länge (cm). Kopiert man für jedes Attribut ein property, vervielfacht sich der Prüfcode. Stattdessen kann man eine einzige Kontrolle bauen und vor mehrere Attribute stellen. Das ist ein Deskriptor.

Ein Deskriptor ist ein Objekt mit mindestens einer der Methoden __get__ und __set__ (oder __delete__). Steht er als Klassenattribut in der Klasse, ruft Python diese Methoden auf, sobald der Name in einer Instanz gelesen oder geschrieben wird.

class Positive:
    def __set_name__(self, owner, name):
        print(f"set_name: {owner.__name__}.{name}")
        self.name = name
    def __get__(self, obj, owner=None):
        if obj is None:
            return self
        return obj.__dict__[self.name]
    def __set__(self, obj, value):
        if value < 0:
            raise ValueError(f"{self.name} must be >= 0: {value}")
        obj.__dict__[self.name] = value

class Bag:
    kg = Positive()
    cm = Positive()
    def __init__(self, kg, cm):
        self.kg, self.cm = kg, cm
# set_name: Bag.kg
# set_name: Bag.cm

b = Bag(20, 55)
print(b.kg, b.cm, vars(b))
# 20 55 {'kg': 20, 'cm': 55}
print(type(Bag.kg).__name__)
# Positive
b.cm = -1
# ValueError: cm must be >= 0: -1

• __set_name__ (3.6) teilt der Kontrolle in dem Moment, in dem die class-Anweisung endet, den Namen mit, unter dem sie hängt. Deshalb kann dasselbe Positive sowohl vor kg als auch vor cm stehen.
• Das Kontrollobjekt gibt es nur einmal in der Klasse, und alle Koffer teilen es sich. Deshalb wird der Wert nicht in der Kontrolle notiert, sondern im __dict__ des jeweiligen Koffers.
• Obwohl der Wert unter demselben Namen "kg" im __dict__ steht, geht das Lesen nicht über __dict__, sondern durch die Kontrolle. Um diese Reihenfolge geht es in 10-4.
• Auch @property ist ein Deskriptor, den Python fertig mitbringt.

10-3. Wie aus einer Funktion eine Methode wird (7 min)

In Lektion 7 haben wir gesehen, dass bag.m is bag.m False ergibt. Der Grund: Auch Funktionen sind Deskriptoren. Eine Funktion hat nur __get__ und kein __set__, sie ist also ein Nicht-Daten-Deskriptor.

class Bag:
    def weigh(self):
        return 20

b = Bag()
f = Bag.__dict__["weigh"]
print(type(f).__name__, hasattr(f, "__get__"), hasattr(f, "__set__"))
# function True False
m = f.__get__(b, Bag)
print(type(m).__name__, m.__self__ is b, m())
# method True 20
print(b.weigh is b.weigh, b.weigh == b.weigh, Bag.weigh is f)
# False True True

Bei jedem Lesen von b.weigh ruft Python f.__get__(b, Bag) auf und erzeugt eine neue gebundene Methode: ein kleines Objekt, das die Funktion und b zusammenbindet. Deshalb ergibt is False und == True. Dass man b.weigh() ohne self aufrufen kann, verdankt man ebenfalls diesem Bündel. Liest man über die Klasse (Bag.weigh), gibt es keine Instanz zum Binden, und die Funktion kommt unverändert heraus.

staticmethod und classmethod sind Deskriptoren, deren __get__ etwas anderes bindet.

class Bag:
    @staticmethod
    def kg_to_lb(kg):
        return round(kg * 2.2046, 1)
    @classmethod
    def empty(cls):
        return cls()

class Suitcase(Bag):
    pass

print(Bag.kg_to_lb(20), Bag().kg_to_lb(20))
# 44.1 44.1
print(type(Suitcase.empty()).__name__, Suitcase.empty.__self__ is Suitcase)
# Suitcase True
print(type(Bag.__dict__["empty"]).__name__)
# classmethod

classmethod bekommt die Klasse, über die aufgerufen wird, deshalb erzeugt Suitcase.empty() ein Suitcase. Man nutzt das für „alternative Konstruktoren“, die auch bei Vererbung den passenden Bauplan erzeugen.

10-4. Die Reihenfolge an der Kontrolle (9 min)

Beim Lesen von obj.x schaut Python (genauer: object.__getattribute__) in dieser Reihenfolge nach:

Daten-Deskriptoren stehen vor dem __dict__ der Instanz, deshalb wird die Kontrolle vor dem Wert im Koffer befragt. Darum war es kein Problem, dass Positive aus 10-2 den Wert unter demselben Namen ins __dict__ legt. Funktionen stehen dagegen hinter dem __dict__, und ein gleichnamiger Eintrag in der Instanz verdeckt die Methode.

Wähl im Ablaufdiagramm unten nacheinander die Attribute aus. Es zeigt, in welchem Schritt die Antwort kommt.

Diesmal legen wir absichtlich gleichnamige Einträge ins __dict__ der Instanz. Die letzte Zeile ist die „Seitentür“: ein direkter Schreibzugriff auf __dict__, um die Kontrolle zu umgehen.

• Auch ein property ohne Setter ist ein Daten-Deskriptor. property hat immer ein __set__, und ohne Setter löst es darin einen AttributeError aus. Deshalb lässt es sich nicht über __dict__ verdecken.
• Beim Schreiben (b.x = v) ist der Weg kürzer. Gibt es in der Klasse einen Deskriptor mit __set__, wird er aufgerufen, sonst wird ins __dict__ der Instanz geschrieben.

10-5. __getattr__, __getattribute__ und type (5 min)

Die beiden Griffe mit ähnlichem Namen werden zu verschiedenen Zeitpunkten aufgerufen.

• __getattribute__: wird bei jedem Lesen eines Attributs immer aufgerufen. Die gesamte Reihenfolge aus 10-4 steckt in object.__getattribute__. Wer es selbst überschreibt, landet leicht in einer Endlosrekursion, deshalb tut man es fast nie.
• __getattr__: die letzte Rettung, die nur aufgerufen wird, wenn nichts gefunden wurde.

class Loud:
    def __init__(self):
        self.kg = 20
    def __getattribute__(self, name):
        print("getattribute", name)
        return super().__getattribute__(name)
    def __getattr__(self, name):
        print("getattr", name)
        return None

x = Loud()
v = x.kg
# getattribute kg
v = x.color
# getattribute color
# getattr color

Zum Schluss: Wenn auch Klassen Objekte sind, welchen Typ hat dann eine Klasse? type. Die class-Anweisung entspricht eigentlich einem Aufruf von type(name, bases, dict), also Name, Elternklassen und ein dict mit den Attributen.

class Bag:
    kind = "bag"

print(type(Bag()).__name__, type(Bag), type(type))
# Bag <class 'type'> <class 'type'>
Dyn = type("Dyn", (Bag,), {"kind": "dyn"})
print(Dyn.kind, [c.__name__ for c in Dyn.__mro__])
# dyn ['Dyn', 'Bag', 'object']

Erbt man von type, um den Vorgang der Klassenerzeugung selbst zu verändern, spricht man von einer Metaklasse. Für fast alles reichen __init_subclass__ (Lektion 9) und Deskriptoren, merk dir in diesem Kurs also nur den Namen.

Fall abgeschlossen (10 min)

Verlegt man die Prüfung in die Kontrolle Positive, geht alles durch dieselbe Kontrolle: das Erzeugen, das Ändern und das Verringern mit -=.

class Positive:
    def __set_name__(self, owner, name):
        self.name = name
    def __get__(self, obj, owner=None):
        return self if obj is None else obj.__dict__[self.name]
    def __set__(self, obj, value):
        if value < 0:
            raise ValueError(f"{self.name} must be >= 0: {value}")
        obj.__dict__[self.name] = value

class Bag:
    kg = Positive()
    cm = Positive()
    def __init__(self, kg, cm):
        self.kg, self.cm = kg, cm

b = Bag(20, 55)
for change in (lambda: setattr(b, "kg", -1), lambda: Bag(-3, 40)):
    try:
        change()
    except ValueError as e:
        print("blocked:", e)
# blocked: kg must be >= 0: -1
# blocked: kg must be >= 0: -3
b.kg -= 30
# ValueError: kg must be >= 0: -10

Ob mit setattr, beim Neuerzeugen oder mit -=: Alles wird abgefangen. b.kg -= 30 besteht aus zwei Schritten, dem Lesen von b.kg (__get__) und dem Zurückschreiben des verringerten Werts (__set__), und kommt deshalb nicht an der Kontrolle vorbei.

Oh lässt die Waagenaufzeichnung noch einmal laufen. Negative Gewichte tauchen nicht mehr auf. Die Schichtleiterin sagt: „Besser als Türen zu verriegeln ist es, jeden Weg durch die Kontrolle zu führen.“

Übungen

1. Ändere Positive so, dass es eine Untergrenze entgegennimmt (kg = AtLeast(0), cm = AtLeast(10)). Benutze dafür in der Prüfung den Wert, den __init__ bekommen hat.
2. Ergänze den Code des ersten Ablaufdiagramms aus 10-4 um b.weigh = "x". In welchem Schritt kommt dann die Antwort für b.weigh? Und bei b.kg = "x"?
3. Prüfe mit print bei einer Klasse, die nur __getattr__ definiert: Wird __getattr__ aufgerufen, wenn du ein Attribut liest, das in __init__ gesetzt wurde?