Grundlegende Magic-Methoden

Einführung

In diesem Tutorial werden wir die grundlegenden Magic-Methoden in Python erkunden. Magic-Methoden, auch bekannt als „dunder“-Methoden (doppelter Unterstrich-Methoden), ermöglichen es Ihnen, zu definieren, wie Python-Objekte in bestimmten Situationen verhalten, was eine fortgeschrittene und benutzerdefinierte Objektmanipulation ermöglicht.

Skills Graph

Objektinitialisierung und Darstellung

In diesem Abschnitt werden wir die Magic-Methoden für die Objektinitialisierung und -darstellung in Python erkunden. Diese Methoden ermöglichen es Ihnen, benutzerdefiniertes Verhalten für das Erstellen von Objekten und deren Darstellung als menschenlesbare und eindeutige Strings zu definieren.

__init__

Die __init__-Methode wird aufgerufen, wenn ein Objekt erstellt wird. Sie wird verwendet, um die Attribute des Objekts zu initialisieren.

Beginnen wir mit einem einfachen Objekt. In person.py erstellen Sie eine Klasse namens Person, die zwei Attribute hat.

class Person:
    def __init__(self, name: str, age: int):
        """
        Initialisiert das Person-Objekt mit einem Namen und einem Alter.

        :param name: Der Name der Person.
        :param age: Das Alter der Person.
        """
        self.name = name
        self.age = age

__str__

Die __str__-Methode wird von der eingebauten str()-Funktion und der print()-Funktion aufgerufen, um eine menschenlesbare Stringdarstellung des Objekts zu erhalten.

    #... (vorheriger Code in person.py)

    def __str__(self) -> str:
        """
        Gibt eine menschenlesbare Stringdarstellung des Person-Objekts zurück.

        :return: Ein String, der die Person beschreibt.
        """
        return f"{self.name} ist {self.age} Jahre alt."

__repr__

Die __repr__-Methode wird von der eingebauten repr()-Funktion aufgerufen und wird im interaktiven Interpreter verwendet, um eine Stringdarstellung zu erhalten, die, sofern möglich, verwendet werden kann, um das Objekt neu zu erstellen.

    #... (vorheriger Code in person.py)

    def __repr__(self) -> str:
        """
        Gibt eine Stringdarstellung des Person-Objekts zurück, die verwendet werden kann, um das Objekt neu zu erstellen.

        :return: Ein String im Format 'Person(name, age)'.
        """
        return f"Person('{self.name}', {self.age})"

Beispiel: Verwenden der grundlegenden Magic-Methoden

Jetzt, da wir die grundlegenden Magic-Methoden für unsere Person-Klasse definiert haben, schauen wir uns an, wie sie in init_repr_example.py funktionieren:

from person import Person

## Erstellen eines neuen Person-Objekts
p = Person("Alice", 30)

## Verwenden der __str__-Methode mit der print-Funktion
print(p)  ## Ausgabe: Alice ist 30 Jahre alt.

## Verwenden der __repr__-Methode im interaktiven Interpreter
print(repr(p))  ## Ausgabe: Person('Alice', 30)

Geben Sie dann den folgenden Befehl in der Konsole ein, um das Skript auszuführen.

python init_repr_example.py

Objektvergleich

In diesem Abschnitt werden wir die Magic-Methoden untersuchen, die in Python zum Vergleich von Objekten verwendet werden. Diese Methoden ermöglichen es Ihnen, benutzerdefiniertes Vergleichsverhalten für Objekte Ihrer Klasse zu definieren.

__eq__

Die __eq__-Methode wird verwendet, um zu bestimmen, ob zwei Objekte gleich sind. Sie wird vom ==-Operator aufgerufen.

    #... (vorheriger Code in person.py)

    def __eq__(self, other: "Person") -> bool:
        """
        Vergleicht zwei Person-Objekte auf Gleichheit.

        :param other: Das andere Person-Objekt, mit dem verglichen werden soll.
        :return: True, wenn beide Objekte denselben Namen und das gleiche Alter haben, andernfalls False.
        """
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

__ne__

Die __ne__-Methode wird verwendet, um zu bestimmen, ob zwei Objekte nicht gleich sind. Sie wird vom !=-Operator aufgerufen.

    #... (vorheriger Code in person.py)

    def __ne__(self, other: "Person") -> bool:
        """
        Vergleicht zwei Person-Objekte auf Ungleichheit.

        :param other: Das andere Person-Objekt, mit dem verglichen werden soll.
        :return: True, wenn die Objekte unterschiedliche Namen oder Alters haben, andernfalls False.
        """
        return not self.__eq__(other)

__lt__

Die __lt__-Methode wird verwendet, um zu bestimmen, ob ein Objekt kleiner als ein anderes ist. Sie wird vom <-Operator aufgerufen.

    #... (vorheriger Code in person.py)

    def __lt__(self, other: "Person") -> bool:
        """
        Vergleicht zwei Person-Objekte, um zu sehen, ob eines kleiner als das andere ist, basierend auf dem Alter.

        :param other: Das andere Person-Objekt, mit dem verglichen werden soll.
        :return: True, wenn das Alter des aktuellen Objekts kleiner als das Alter des anderen Objekts ist, andernfalls False.
        """
        if isinstance(other, Person):
            return self.age < other.age
        return NotImplemented

__le__

Die __le__-Methode wird verwendet, um zu bestimmen, ob ein Objekt kleiner als oder gleich einem anderen ist. Sie wird vom <=-Operator aufgerufen.

    #... (vorheriger Code in person.py)

    def __le__(self, other: "Person") -> bool:
        """
        Vergleicht zwei Person-Objekte, um zu sehen, ob eines kleiner als oder gleich dem anderen ist, basierend auf dem Alter.

        :param other: Das andere Person-Objekt, mit dem verglichen werden soll.
        :return: True, wenn das Alter des aktuellen Objekts kleiner als oder gleich dem Alter des anderen Objekts ist, andernfalls False.
        """
        if isinstance(other, Person):
            return self.age <= other.age
        return NotImplemented

__gt__

Die __gt__-Methode wird verwendet, um zu bestimmen, ob ein Objekt größer als ein anderes ist. Sie wird vom >-Operator aufgerufen.

    #... (vorheriger Code in person.py)

    def __gt__(self, other: "Person") -> bool:
        """
        Vergleicht zwei Person-Objekte, um zu sehen, ob eines größer als das andere ist, basierend auf dem Alter.

        :param other: Das andere Person-Objekt, mit dem verglichen werden soll.
        :return: True, wenn das Alter des aktuellen Objekts größer als das Alter des anderen Objekts ist, andernfalls False.
        """
        if isinstance(other, Person):
            return self.age > other.age
        return NotImplemented

__ge__

Die __ge__-Methode wird verwendet, um zu bestimmen, ob ein Objekt größer als oder gleich einem anderen ist. Sie wird vom >=-Operator aufgerufen.

    #... (vorheriger Code in person.py)

    def __ge__(self, other: "Person") -> bool:
        """
        Vergleicht zwei Person-Objekte, um zu sehen, ob eines größer als oder gleich dem anderen ist, basierend auf dem Alter.

        :param other: Das andere Person-Objekt, mit dem verglichen werden soll.
        :return: True, wenn das Alter des aktuellen Objekts größer als oder gleich dem Alter des anderen Objekts ist, andernfalls False.
        """
        if isinstance(other, Person):
            return self.age >= other.age
        return NotImplemented

Beispiel: Verwenden der Magic-Methoden für den Objektvergleich

Jetzt, da wir die Magic-Methoden für den Objektvergleich für unsere Person-Klasse definiert haben, schauen wir uns an, wie sie in compare_example.py funktionieren:

from person import Person

## Erstellen von zwei Person-Objekten
p1 = Person("Alice", 30)
p2 = Person("Bob", 35)

## Verwenden der __eq__- und __ne__-Methoden
print(p1 == p2)  ## Ausgabe: False
print(p1!= p2)  ## Ausgabe: True

## Verwenden der __lt__-, __le__-, __gt__- und __ge__-Methoden
print(p1 < p2)  ## Ausgabe: True
print(p1 <= p2)  ## Ausgabe: True
print(p1 > p2)  ## Ausgabe: False
print(p1 >= p2)  ## Ausgabe: False

Geben Sie dann den folgenden Befehl in der Konsole ein, um das Skript auszuführen.

python compare_example.py

Objektzerstörung

In diesem Abschnitt werden wir die Magic-Methode für die Objektzerstörung in Python untersuchen. Die Methode ermöglicht es Ihnen, benutzerdefiniertes Verhalten zu definieren, wenn ein Objekt zerstört werden soll.

__del__

Die __del__-Methode wird aufgerufen, wenn ein Objekt zerstört werden soll. Sie ermöglicht es Ihnen, Bereinigungsaufgaben durchzuführen, wie z. B. das Schließen von Dateihandlern oder die Freigabe von Ressourcen, bevor das Objekt von der Garbage Collection entfernt wird.

    #... (vorheriger Code in person.py)

    def __del__(self):
        """
        Reinigt das Person-Objekt, bevor es zerstört wird.
        """
        print(f"Person '{self.name}' wird gelöscht.")

Beispiel: Verwenden der Magic-Methode für die Objektzerstörung

Jetzt, da wir die Magic-Methode für die Objektzerstörung für unsere Person-Klasse definiert haben, schauen wir uns an, wie sie in del_example.py funktioniert:

from person import Person

## Erstellen eines Person-Objekts und anschließend Löschen
p = Person("Alice", 30)
del p  ## Ausgabe: Person 'Alice' wird gelöscht.

Geben Sie dann den folgenden Befehl in der Konsole ein, um das Skript auszuführen.

python del_example.py

Es ist wichtig zu beachten, dass die __del__-Methode nicht unbedingt sofort aufgerufen wird, wenn ein Objekt nicht mehr benötigt wird. Die tatsächliche Zerstörung des Objekts hängt von dem Garbage Collection-Mechanismus des Python-Interpreters ab. Die __del__-Methode wird aufgerufen, wenn der Garbage Collector beschließt, das Objekt aus dem Arbeitsspeicher zu entfernen.

Zusammenfassung

In dieser Reihe von Tutorials haben wir die Magic-Methoden in Python untersucht, auch bekannt als „dunder“-Methoden (doppelter Unterstrich-Methoden), die es Ihnen ermöglichen, benutzerdefiniertes Verhalten für Ihre Objekte in verschiedenen Situationen zu definieren.

Durch die Beherrschung dieser Magic-Methoden können Sie leistungsfähigere und anpassbare Python-Klassen und -Objekte erstellen. Das Verständnis und die Implementierung dieser Methoden werden es Ihnen ermöglichen, effizienteres, sauberes und pythonisches Code zu schreiben, was Ihre Programme robuster und wartbarer macht.