Magische Methoden in Python

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.

YouTube Video