Der Koffer-Bauplan: Klassen und Instanzen

In der Schreibtischschublade von Schichtleiterin Do Miran liegt ein Stapel Koffer-Baupläne. Mit einem einzigen Bauplan lassen sich beliebig viele Koffer derselben Form herstellen. „Der Bauplan ist ein Blatt Papier, die Koffer sind einzelne Stücke. Beides sind Dinge.“

Moon hat nur auf den Geigenkoffer „Zerbrechlich“ geklebt, sieht denselben Aufkleber aber auch am Cellokoffer. Die Schichtleiterin schlägt nicht den Koffer auf, sondern den Bauplan. Dort klebte der Aufkleber.

7-1. Auch der Bauplan ist ein Koffer: Klassenobjekte (7 min)

Die class-Anweisung erzeugt ein Klassenobjekt und bindet es an einen Namen, ist also eine Zuweisung (genau wie def in Lektion 1). Auch eine Klasse ist ein Objekt mit einem Typ, und dieser Typ ist type.

class Case:
    size = "M"
    def __init__(self, owner):
        self.owner = owner

print(type(Case), isinstance(Case, type))
# <class 'type'> True
b = Case("cello")
print(type(b).__name__, type(b) is Case)
# Case True
print(vars(b))
# {'owner': 'cello'}
print([k for k in vars(Case) if not k.startswith("__")])
# ['size']
print(b.size, "size" in vars(b))
# M False

• Im __dict__ von b steht nur owner. Trotzdem wird b.size als "M" gelesen.
• Beim Lesen eines Attributs wird zuerst im __dict__ der Instanz nachgesehen und, wenn es dort fehlt, in der Klasse. Fehlt etwas im Koffer, schlägt man den Bauplan auf.
• Das __dict__ einer Klasse ist ein schreibgeschütztes Fenster namens mappingproxy. Um ein Klassenattribut zu ändern, weist du es direkt der Klasse zu, etwa Case.size = "L".

7-2. Klassenattribute teilen sich alle (10 min)

Das ist der Bauplan aus der Meldung:

class Case:
    stickers = []
    def __init__(self, owner):
        self.owner = owner

a = Case("violin")
b = Case("cello")
a.stickers.append("FRAGILE")
print(b.stickers, Case.stickers)
# ['FRAGILE'] ['FRAGILE']
print(a.stickers is b.stickers, "stickers" in vars(a))
# True False

• stickers = [] läuft im Klassenrumpf ein einziges Mal. Die Liste hängt nur einmal am Bauplan.
• a.stickers steht nicht im __dict__ von a, wird also in der Klasse gefunden, und append verändert diese eine Liste (Koffer verändern).
• Es ist derselbe Fehlertyp wie bei den Standardargumenten in Lektion 4: „Ein einmal erzeugtes veränderliches Objekt wird von vielen geteilt.“

Was jede Instanz für sich haben soll, hängt man in __init__ an self. Vergleich unten die drei Varianten.

Weist man einer Instanz wie in der dritten Variante etwas unter demselben Namen zu, bleibt das Klassenattribut unangetastet, und im __dict__ der Instanz entsteht ein neuer Name. Für diese Instanz ist das Klassenattribut dann verdeckt (dieselbe Form wie das Verdecken eingebauter Namen in Lektion 5).

class Case:
    size = "M"

a = Case()
b = Case()
a.size = "L"
print(a.size, b.size, vars(a))
# L M {'size': 'L'}
Case.size = "S"
print(a.size, b.size)
# L S
del a.size
print(a.size)
# S

• Ändert man das Klassenattribut, sehen das sofort alle Instanzen, die es nicht verdecken (b).
• Nimmt man mit del a.size den Namen der Instanz ab, ist wieder der Wert der Klasse zu sehen.

Vergiss nicht, dass auch += eine Zuweisung ist. Wendet man += auf ein Klassenattribut mit einer Zahl an, entsteht in der Instanz ein neuer Name.

class Gate:
    count = 0

g = Gate()
g.count += 1
print(g.count, Gate.count, vars(g))
# 1 0 {'count': 1}

g.count += 1 ist g.count = g.count + 1. Rechts wird die 0 aus der Klasse gelesen, links landet die 1 im __dict__ von g. Soll die Zahl für alle Instanzen gemeinsam zählen, musst du wie bei Gate.count += 1 direkt der Klasse zuweisen.

7-3. Die Lesereihenfolge: erst die Instanz, dann die Klasse (7 min)

Den Weg, den Python beim Lesen von b.x geht, zeigt das Ablaufdiagramm der Kontrolle. In dieser Lektion genügen Schritt 2 (das __dict__ der Instanz) und Schritt 4 (ein normales Attribut der Klasse). Die Schritte 1, 3 und 5 behandeln wir in Lektion 10.

Das b unten hat size sowohl in der Klasse als auch im eigenen __dict__.

• size steht auch in der Klasse, wird aber zuerst in Schritt 2 gefunden und ist deshalb 'L'. Das Case.size in Klammern in der Ergebniszeile bedeutet: „Die Klasse hat ebenfalls einen Namen dieser Art.“
• label ist eine Funktion in der Klasse. Funktionen sind besondere Objekte, die in Schritt 3 hängen bleiben. Holt man sie heraus, bekommt man keine einfache Funktion, sondern eine bound method. Darum geht es im nächsten Abschnitt.

7-4. Gebundene Methoden: bei jedem Zugriff neu erzeugt (6 min)

Eine Methode ist eine ganz normale Funktion in der Klasse. Holt man sie über eine Instanz heraus, erzeugt Python ein neues Objekt, das Funktion und Instanz zusammenbindet: eine gebundene Methode.

class Bag:
    def __init__(self, owner):
        self.owner = owner
    def label(self):
        return "bag of " + self.owner

bag = Bag("kim")
print(bag.label is bag.label, bag.label == bag.label)
# False True
print(bag.label.__self__ is bag, bag.label.__func__ is Bag.label)
# True True
print(bag.label(), Bag.label(bag))
# bag of kim bag of kim
print(type(bag.label).__name__, type(Bag.label).__name__)
# method function

• Jedes Mal, wenn du bag.label schreibst, entsteht eine neue gebundene Methode. Deshalb ergibt is False. Weil dieselbe Funktion an dieselbe Instanz gebunden ist, ergibt == True.
• __self__ ist die gebundene Instanz, __func__ die ursprüngliche Funktion der Klasse.
• bag.label() ist dasselbe wie Bag.label(bag). self ist nur das erste Argument, das die gebundene Methode für dich ausfüllt.
• Wie aus einer Funktion beim Herausholen eine Methode wird, lösen wir in Lektion 10 (Deskriptoren) auf.

7-5. Namen als Strings behandeln: vars, getattr, setattr, hasattr (5 min)

Manchmal steht der Attributname erst zur Laufzeit als String fest, zum Beispiel als Schlüssel aus einer Konfigurationsdatei oder als Spaltenname, den jemand auf dem Bildschirm ausgewählt hat.

class Bag:
    def __init__(self, owner):
        self.owner = owner

bag = Bag("kim")
setattr(bag, "color", "red")
print(getattr(bag, "color"), hasattr(bag, "weight"), getattr(bag, "weight", 0))
# red False 0
print(vars(bag))
# {'owner': 'kim', 'color': 'red'}
vars(bag)["tag"] = "T1"
print(bag.tag, vars(bag) is bag.__dict__)
# T1 True
bag.weight
# AttributeError: 'Bag' object has no attribute 'weight'

• setattr(obj, "x", v) entspricht obj.x = v, getattr(obj, "x") entspricht obj.x. Das dritte Argument von getattr ist der Standardwert, falls das Attribut fehlt.
• hasattr probiert tatsächlich ein getattr und entscheidet danach, ob ein AttributeError kommt.
• vars() einer Instanz ist keine Momentaufnahme, sondern das echte __dict__. Das ist anders als locals() in einer Funktion aus Lektion 5.
• An Python-Objekte kann man jederzeit neue Attribute hängen. Das ist bequem, aber auch ein Tippfehler (bag.colour = ...) wird stillschweigend zu einem neuen Attribut.

7-6. Den Bauplan festziehen: __slots__ und weitere neue Funktionen (5 min)

Schreibt man Attributnamen in __slots__, bekommen Instanzen kein __dict__, und nur die aufgeführten Namen sind erlaubt. In CPython spart das außerdem Speicher, weil nicht jede Instanz ein eigenes Dictionary hat.

class Slim:
    __slots__ = ("owner",)
    def __init__(self, owner):
        self.owner = owner

s = Slim("kim")
print(s.owner, hasattr(s, "__dict__"))
# kim False
s.color = "red"
# AttributeError: 'Slim' object has no attribute 'color' and no __dict__ for setting new attributes

Seit 3.13 haben Klassen __static_attributes__. Darin stehen sortiert die Namen, denen in den Methoden der Klasse per self.name = ... ein Wert zugewiesen wird.

class Trunk:
    def __init__(self, owner):
        self.owner = owner
        self.tags = []
    def pack(self):
        self.weight = 10

print(Trunk.__static_attributes__)
# ('owner', 'tags', 'weight')

Zum Schluss die verzögerte Auswertung von Annotationen in 3.14 (PEP 649, 749). Annotationen im Klassenrumpf werden nicht beim Erzeugen der Klasse ausgewertet, sondern erst beim ersten Lesen von __annotations__. Deshalb entsteht die Klasse auch dann, wenn in einer Annotation ein Name steht, der noch gar nicht definiert ist. Bis 3.13 gab es in der Zeile friend: Missing einen NameError.

class Partner:
    friend: Missing

print("created", Partner.__name__)
# created Partner

class Missing:
    pass

print(Partner.__annotations__)
# {'friend': <class '__main__.Missing'>}

Fall abgeschlossen (10 min)

Die Aufkleberliste kommt weg vom Bauplan und an jeden einzelnen Koffer. Gemeinsame Werte (die Standardgröße) bleiben in der Klasse.

class Case:
    size = "M"
    def __init__(self, owner):
        self.owner = owner
        self.stickers = []

a = Case("violin")
b = Case("cello")
a.stickers.append("FRAGILE")
print(a.stickers, b.stickers)
# ['FRAGILE'] []
print(vars(a))
# {'owner': 'violin', 'stickers': ['FRAGILE']}
print(Case.__static_attributes__)
# ('owner', 'stickers')

Jetzt klebt „Zerbrechlich“ nur noch am Geigenkoffer. Als Moon gegangen ist, holt Pin die Aufzeichnungen zu den Geisterkoffern von Band 13 auf den Bildschirm. Beide Koffer wurden nach demselben Bauplan gebaut, und das Attribut partner des einen zeigt auf den anderen, das partner des anderen wiederum auf den ersten. Die Schichtleiterin zieht mit dem Stift einen Kreis um diese Zeile.

Übungen

1. Lass Case.stickers = [] in der Klasse stehen und führe a.stickers += ["FRAGILE"] aus. Was wird aus b.stickers und vars(a)? (Tipp: Das += aus Lektion 2 und das += aus 7-2 passieren gleichzeitig.)
2. Eine Klasse mit __slots__ = ("owner",) bekommt das Klassenattribut size = "M". Kann man in einer Instanz s.size lesen? Und was ist mit s.size = "L"?
3. Schreib eine Schleife, die mit getattr die drei Attribute ["owner", "color", "weight"] nacheinander holt und ausgibt, wobei fehlende Attribute als "-" erscheinen.