Unveränderliche Klassen in Python erzeugen¶
Warum brauchen wir unveränderliche Klassen?¶
Beliebte Beispiele für unveränderliche Klassen in Python sind Integers, Floats, Strings und Tuples. Viele funktionale Programmiersprachen, wie z. B. Haskell oder Scala, setzen auf Unveränderlichkeit als grundlegendes Konzept in ihrem Design. Der Grund dafür ist, dass unveränderliche Klassen mehrere Vorteile bei der Softwareentwicklung bieten:
Thread-Sicherheit: Unveränderliche Objekte sind von Natur aus thread-sicher. Da sich ihr Zustand nach der Erstellung nicht ändert, können mehrere Threads gleichzeitig auf sie zugreifen, ohne dass Sperren oder Synchronisation erforderlich sind. Dies kann die parallele Programmierung vereinfachen und das Risiko von Wettlaufbedingungen verringern (race conditions).
Vorhersehbares Verhalten: Einmal erstellte unveränderliche Objekte behalten ihren Zustand während ihrer gesamten Lebensdauer bei. Diese Vorhersehbarkeit erleichtert das Nachvollziehen des Verhaltens des Objekts, was zu robusterem und wartungsfreundlicherem Code führt.
Cachefähigkeit: Unveränderliche Objekte können sicher zwischengespeichert werden, da sich ihre Werte nie ändern. Dies ist besonders vorteilhaft für die Leistung (performance), da es effiziente Memoisierungs- und Caching-Strategien ermöglicht.
Vereinfacht das Testen: Da sich der Zustand eines unveränderlichen Objekts nicht ändert, wird das Testen einfacher. Man muss keine unterschiedlichen Zustände oder Mutationszenarien berücksichtigen, was das Schreiben von Tests und die Überprüfung der Korrektheit des Codes erleichtert.
Konsistentes Hashing: Unveränderliche Objekte haben konsistente Hash-Codes, was für ihren Einsatz in Datenstrukturen wie Wörterbüchern oder Mengen entscheidend ist. Dies stellt sicher, dass Objekte mit denselben Werten denselben Hash-Code erzeugen, was ihren Einsatz in hashbasierten Collections-Objekten vereinfacht.
Erleichtert das Debuggen: Das Debuggen kann mit unveränderlichen Objekten einfacher sein, da sich ihr Zustand nicht ändert. Sobald der Anfangszustand eines Objekts identifiziert ist, bleibt er konstant, was das Verfolgen und Verstehen des Programmflusses erleichtert.
Optimal zur funktionalen Programmierung: Unveränderliche Objekte passen gut zu den Prinzipien der funktionalen Programmierung. In der funktionalen Programmierung werden Funktionen und Daten als separate Entitäten behandelt, und Unveränderlichkeit ist ein Schlüsselkonzept. Unveränderliche Objekte fördern einen funktionalen Programmierstil, der zu modularerem und zusammensetzbarerem Code führt.
Verhindert unbeabsichtigte Änderungen: Bei veränderlichen Objekten können unbeabsichtigte Änderungen am Zustand auftreten, wenn Referenzen zu dem Objekt geteilt werden. Unveränderliche Objekte beseitigen dieses Risiko, da sich ihr Zustand nach der Erstellung nicht mehr ändern kann.
Erstellung unveränderlicher Klassen¶
Klassen mit Gettern und ohne Setter¶
Die folgende Klasse ImmutablRobot
implementiert private Attribute __name
und self.__brandname
, die nur durch die Methoden get_name
und get_brandname
gelesen werden können, aber es gibt keine Möglichkeit, diese Attribute zu ändern, zumindest keine legale:
class ImmutableRobot:
def __init__(self, name, brandname):
self.__name = name
self.__brandname = brandname
def get_name(self):
return self.__name
def get_brandname(self):
return self.__brandname
robot = ImmutableRobot(name="RoboX", brandname="TechBot")
print(robot.get_name())
print(robot.get_brandname())
Wir können das vorige Beispiel mit Properties umschreiben, aber keine Setter-Methoden bereitstellen. Logisch gesehen also das Gleiche wie vorher:
class ImmutableRobot:
def __init__(self, name, brandname):
self.__name = name
self.__brandname = brandname
@property
def name(self):
return self.__name
@property
def brandname(self):
return self.__brandname
robot = ImmutableRobot(name="RoboX", brandname="TechBot")
print(robot.name)
print(robot.brandname)
try:
robot.name = "RoboY"
except AttributeError as e:
print(e)
try:
robot.brandname = "NewTechBot"
except AttributeError as e:
print(e)
Benutzung des dataclass
-Dekorators¶
from dataclasses import dataclass
@dataclass(frozen=True)
class ImmutableRobot:
name: str
brandname: str
# Example usage:
robot = ImmutableRobot(name="RoboX", brandname="TechBot")
print(robot.name)
print(robot.brandname)
try:
robot.name = "RoboY"
except AttributeError as e:
print(e)
try:
robot.brandname = "NewTechBot"
except AttributeError as e:
print(e)
Verwendung von namedtuple
¶
Hier ist eine Alternative mit namedtuple aus dem collections-Modul:
from collections import namedtuple
ImmutableRobot = namedtuple('ImmutableRobot', ['name', 'brandname'])
# Example usage:
robot = ImmutableRobot(name="RoboX", brandname="TechBot")
print(robot.name)
print(robot.brandname)
# Attempting to modify attributes will raise an AttributeError
try:
robot.name = "RoboY"
except AttributeError as e:
print(e)
try:
robot.brandname = "NewTechBot"
except AttributeError as e:
print(e)
In diesem Beispiel erzeugt namedtuple
eine einfache Klasse mit benannten Feldern, und Instanzen dieser Klasse sind unveränderlich. Genau wie bei dataclass
führt der Versuch, Attribute zu ändern, zu einem AttributeError
.
Sowohl namedtuple
als auch dataclass
bieten einen prägnanten Weg, unveränderliche Klassen in Python zu erstellen. Die Wahl zwischen beiden hängt von den spezifischen Bedürfnissen und Vorlieben ab. namedtuple
ist leichtgewichtiger, während dataclass
zusätzliche Funktionen und Anpassungsmöglichkeiten bietet.
__slots__
¶
'Slots' haben nichts mit der Erstellung einer unveränderlichen Klasse zu tun. Dennoch kann es missverstanden werden. Mit Hilfe von __slots__
legen wir die Anzahl der Attribute auf eine feste Menge fest. Mit anderen Worten: Das Attribut slots in Python wird verwendet, um Datenmember (Attribute) in einer Klasse explizit zu deklarieren. Es beschränkt die Erstellung neuer Attribute in Instanzen der Klasse und erlaubt nur die in slots angegebenen Attribute zu definieren. Die Attribute selbst können sich natürlich ändern, sodass die Klasse veränderlich sein kann, aber sie kann nicht dynamisch um zusätzliche Attribute erweitert werden. Der Hauptvorteil von __slots__
besteht jedoch darin, dass wir den Speicherplatz erheblich reduzieren können, der mit jeder Instanz der Klasse verbunden ist. Traditionelle Klassen speichern Attribute in einem dynamischen Wörterbuch, was zusätzlichen Speicherplatz verbraucht. Mit slots werden Attributnamen in einem Tupel gespeichert, und die Instanz reserviert direkt Speicherplatz für diese Attribute.
class ImmutableRobot:
__slots__ = ('__name', '__brandname')
def __init__(self, name, brandname):
self.__name = name
self.__brandname = brandname
@property
def name(self):
return self.__name
@property
def brandname(self):
return self.__brandname
robot = ImmutableRobot(name="RoboX", brandname="TechBot")
print(robot.name)
print(robot.brandname)
Durch die Verwendung von __slots__
kann man explizit die Attribute definieren, die Instanzen der Klasse haben werden, was dazu beitragen kann, die Speichernutzung zu reduzieren und die Leistung zu verbessern, insbesondere bei der Erstellung einer großen Anzahl von Instanzen.