Magische Methoden in Python
Dieser Artikel erklärt magische Methoden in Python.
YouTube Video
Magische Methoden in Python
Magische Methoden (Spezialmethoden) in Python sind speziell benannte Methoden, die verwendet werden, um Klassen ein einzigartiges Verhalten zu verleihen. Zum Beispiel sind sie durch doppelte Unterstriche (Dunders) gekennzeichnet, wie etwa __init__
und __str__
. Daher werden sie auch Dunder-Methoden genannt.
Durch das Definieren von magischen Methoden kann das Standardverhalten von Klassen angepasst werden. Zum Beispiel ermöglicht das Definieren von __add__
, das Verhalten des +
-Operators zu ändern.
Magische Methoden für Initialisierung und Zeichenketten-Darstellung
__init__
: Initialisierungsmethode
Die Methode __init__
ist ein Konstruktor, der automatisch aufgerufen wird, wenn eine Instanz erstellt wird.
1class Person:
2 def __init__(self, name, age):
3 self.name = name
4 self.age = age
5
6person = Person("Alice", 30)
7print(person.name) # Alice
__str__
: Menschlich lesbare Zeichenketten-Darstellung
Die Methode __str__
gibt eine menschenlesbare Zeichenkettendarstellung zurück. Sie wird von print()
und str()
aufgerufen.
1class Person:
2 def __init__(self, name):
3 self.name = name
4
5 def __str__(self):
6 return f"Person: {self.name}"
7
8person = Person("Bob")
9print(person) # Person: Bob
__repr__
: Debug-orientierte Zeichenketten-Darstellung
Die Methode __repr__
gibt eine Zeichenkettendarstellung für Debugging-Zwecke zurück. Sie wird von repr()
und bei der Anzeige im Interpreter verwendet.
1class Person:
2 def __init__(self, name):
3 self.name = name
4
5 def __repr__(self):
6 return f"Person(name={self.name!r})"
7
8person = Person("Eve")
9print(repr(person)) # Person(name='Eve')
Überladen von arithmetischen Operatoren
__add__
: +
-Operator
Durch die Verwendung magischer Methoden können arithmetische Operatoren überladen werden. Zum Beispiel ermöglicht die Methode __add__
das Überladen des +
-Operators.
1class Vector:
2 def __init__(self, x, y):
3 self.x = x
4 self.y = y
5
6 def __add__(self, other):
7 return Vector(self.x + other.x, self.y + other.y)
8
9 def __repr__(self):
10 return f"Vector({self.x}, {self.y})"
11
12 # Other arithmetic magic methods:
13 # def __sub__(self, other): # Subtraction (-)
14 # def __mul__(self, other): # Multiplication (*)
15 # def __truediv__(self, other): # True division (/)
16 # def __floordiv__(self, other): # Floor division (//)
17 # def __mod__(self, other): # Modulo (%)
18 # def __pow__(self, other): # Exponentiation (**)
19
20v1 = Vector(1, 2)
21v2 = Vector(3, 4)
22print(v1 + v2) # Vector(4, 6)
Weitere arithmetische magische Methoden sind:.
Methode | Operator |
---|---|
__add__ |
+ |
__sub__ |
- |
__mul__ |
* |
__truediv__ |
/ |
__floordiv__ |
// |
__mod__ |
% |
__pow__ |
** |
Anpassen von Vergleichsoperatoren
Man kann auch Vergleichsoperatoren überladen. Zum Beispiel überlädt die Methode __eq__
den Gleichheitsoperator.
1class Box:
2 def __init__(self, volume):
3 self.volume = volume
4
5 def __eq__(self, other):
6 return self.volume == other.volume
7
8 def __lt__(self, other):
9 return self.volume < other.volume
10
11 # Comparison magic methods:
12 # def __eq__(self, other): # Equal to (==)
13 # def __ne__(self, other): # Not equal to (!=)
14 # def __lt__(self, other): # Less than (<)
15 # def __le__(self, other): # Less than or equal to (<=)
16 # def __gt__(self, other): # Greater than (>)
17 # def __ge__(self, other): # Greater than or equal to (>=)
18
19b1 = Box(100)
20b2 = Box(200)
21
22print(b1 == b2) # False
23print(b1 < b2) # True
Es gibt auch folgende magische Methoden:. Diese magischen Methoden definieren Vergleiche wie Gleichheit und Reihenfolge zwischen Objekten.
Operator | Magische Methode |
---|---|
== |
__eq__ |
!= |
__ne__ |
< |
__lt__ |
<= |
__le__ |
> |
__gt__ |
>= |
__ge__ |
Magische Methoden für Containertypen
Man kann Klassen erstellen, die sich wie Listen oder Dictionaries verhalten.
__len__
: Ermitteln der Anzahl der Elemente
Die Methode __len__
ist eine magische Methode, die die Anzahl der Elemente zurückgibt.
1class Basket:
2 def __init__(self, items):
3 self.items = items
4
5 def __len__(self):
6 return len(self.items)
7
8basket = Basket(["apple", "banana"])
9print(len(basket)) # 2
__getitem__
: Indexzugriff
Die Methode __getitem__
wird beim Zugriff über einen Index aufgerufen.
1class Basket:
2 def __init__(self, items):
3 self.items = items
4
5 def __getitem__(self, index):
6 return self.items[index]
7
8basket = Basket(["apple", "banana"])
9print(basket[1]) # banana
__setitem__
und __delitem__
: Schreiben und Löschen
Die Methoden __setitem__
und __delitem__
werden beim Schreiben oder Löschen von Elementen aufgerufen.
1class Basket:
2 def __init__(self, items):
3 self.items = items
4
5 def __setitem__(self, index, value):
6 self.items[index] = value
7
8 def __delitem__(self, index):
9 del self.items[index]
10
11basket = Basket(["apple", "banana"])
12basket[1] = "grape"
13del basket[0]
14print(basket.items) # ['grape']
Magische Methoden für Iteration
Damit ein Objekt in einer for
-Schleife iterierbar ist, implementieren Sie Folgendes:.
__iter__
und __next__
1class Counter:
2 def __init__(self, limit):
3 self.limit = limit
4 self.current = 0
5
6 def __iter__(self):
7 return self
8
9 def __next__(self):
10 if self.current >= self.limit:
11 raise StopIteration
12 self.current += 1
13 return self.current
14
15for num in Counter(3):
16 print(num)
17# Output:
18# 1
19# 2
20# 3
Kontextmanager (with
-Anweisung)
Durch das Definieren von __enter__
- und __exit__
-Methoden kann man Vor- und Nachverarbeitung für die with
-Anweisung implementieren.
1class FileOpener:
2 def __init__(self, filename):
3 self.filename = filename
4
5 def __enter__(self):
6 self.file = open(self.filename, 'r')
7 return self.file
8
9 def __exit__(self, exc_type, exc_val, exc_tb):
10 self.file.close()
11
12with FileOpener("example.txt") as f:
13 content = f.read()
14 print(content)
Aufrufbare Objekte: __call__
Durch das Definieren der Methode __call__
kann eine Instanz wie eine Funktion aufgerufen werden.
1class Greeter:
2 def __init__(self, greeting):
3 self.greeting = greeting
4
5 def __call__(self, name):
6 return f"{self.greeting}, {name}!"
7
8hello = Greeter("Hello")
9print(hello("Alice")) # Hello, Alice!
Zusammenfassung
Magische Methoden in Python sind eine leistungsfähige Möglichkeit, Klassen ein natürliches und intuitives Verhalten zu verleihen. Jede Methode hat einen klaren Zweck, und durch die richtige Implementierung kann flexiblerer und pythonischer Code geschrieben werden.
Magische Methoden dienen als eine „unsichtbare Schnittstelle“, die unterstützt, wie Python-Objekte hinter den Kulissen interagieren und sich verhalten.
Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.