Lernen Sie Python Magic-Methoden: Eine einfache Erklärung

Magische Methoden in Python verstehen

Magische Methoden in Python, auch bekannt als dunder-Methoden (da sie am Anfang und Ende ihres Namens doppelte Unterstriche haben), ermöglichen es uns, das Verhalten unserer Objekte für verschiedene Operationen zu definieren. Sie ermöglichen benutzerdefiniertes Verhalten und können dafür sorgen, dass sich unsere Klassen wie integrierte Typen verhalten. In diesem Blog werden wir verschiedene Kategorien magischer Methoden untersuchen, detaillierte Erklärungen geben und praktische Beispiele und Anwendungsfälle nennen.

1. Attributzugriffsmethoden

Diese magischen Methoden steuern, wie auf Attribute Ihrer Objekte zugegriffen, diese geändert oder gelöscht werden.

__getattr__ und __getattribute__

• __getattr__: Wird aufgerufen, wenn ein Attribut in einem Objekt nicht gefunden wird.

• __getattribute__: Wird bedingungslos aufgerufen, um auf ein beliebiges Attribut zuzugreifen.

Beispiel: Benutzerdefinierter Attributzugriff mit Protokollierung

class LoggedAttributes:
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        print(f"Accessing non-existent attribute: {item}")
        return None

    def __getattribute__(self, item):
        print(f"Getting attribute: {item}")
        return super().__getattribute__(item)

# Usage
obj = LoggedAttributes("Alice")
print(obj.name)  # Output: Getting attribute: name\nAlice
print(obj.age)   # Output: Accessing non-existent attribute: age\nNone

Praktischer Anwendungsfall: Protokollierung des Attributzugriffs in einem Debugging-Szenario, um zu verfolgen, wann und wie auf Attribute zugegriffen oder diese geändert werden.

__setattr__ und __delattr__

• __setattr__: Wird aufgerufen, wenn eine Attributzuweisung versucht wird.

• __delattr__: Wird aufgerufen, wenn versucht wird, ein Attribut zu löschen.

Beispiel: Benutzerdefinierte Attributänderung mit Validierung

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __setattr__(self, key, value):
        if key == "age" and value < 0:
            raise ValueError("Age cannot be negative")
        super().__setattr__(key, value)

    def __delattr__(self, item):
        if item == "name":
            raise AttributeError("Can't delete attribute 'name'")
        super().__delattr__(item)

# Usage
p = Person("Alice", 30)
p.age = 25  # Works fine
# p.age = -1  # Raises ValueError
# del p.name  # Raises AttributeError

Praktischer Anwendungsfall: Durchsetzung von Validierungsregeln oder Einschränkungen beim Festlegen oder Löschen von Attributen.

2. Containermethoden

Diese magischen Methoden ermöglichen es Ihren Objekten, sich wie Container (Listen, Wörterbücher usw.) zu verhalten.

__len__, __getitem__, __setitem__, __delitem__ und __iter__

• __len__: Gibt die Länge des Containers zurück.

• __getitem__: Ruft ein Element an einem bestimmten Index oder Schlüssel ab.

• __setitem__: Setzt ein Element an einem bestimmten Index oder Schlüssel.

• __delitem__: Löscht ein Element an einem bestimmten Index oder Schlüssel.

• __iter__: Gibt ein Iteratorobjekt zurück.

Beispiel: Benutzerdefiniertes listenähnliches Objekt

class CustomList:
    def __init__(self):
        self._items = []

    def __len__(self):
        return len(self._items)

    def __getitem__(self, index):
        return self._items[index]

    def __setitem__(self, index, value):
        self._items[index] = value

    def __delitem__(self, index):
        del self._items[index]

    def __iter__(self):
        return iter(self._items)

    def append(self, item):
        self._items.append(item)

# Usage
cl = CustomList()
cl.append(1)
cl.append(2)
cl.append(3)
print(len(cl))  # Output: 3
print(cl[1])    # Output: 2
for item in cl:
    print(item)  # Output: 1 2 3

Praktischer Anwendungsfall: Erstellen einer benutzerdefinierten Sammlungsklasse, die spezielles Verhalten oder zusätzliche Methoden erfordert und gleichzeitig Standardlistenoperationen unterstützt.

3. Numerische und Vergleichsmethoden

Diese Methoden definieren, wie Objekte Ihrer Klasse mit numerischen Operationen und Vergleichen interagieren.

Numerische Methoden

• __add__, __sub__, __mul__, __truediv__, __floordiv__, __mod__, __pow__: Definieren Sie arithmetische Operationen.

Beispiel: Benutzerdefinierte komplexe Zahlenklasse

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def __add__(self, other):
        return Complex(self.real + other.real, self.imag + other.imag)

    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)

    def __repr__(self):
        return f"({self.real} + {self.imag}i)"

# Usage
c1 = Complex(1, 2)
c2 = Complex(3, 4)
print(c1 + c2)  # Output: (4 + 6i)
print(c1 - c2)  # Output: (-2 + -2i)

Praktischer Anwendungsfall:Implementierung benutzerdefinierter numerischer Typen wie komplexe Zahlen, Vektoren oder Matrizen.

Vergleichsmethoden

• __eq__, __ne__, __lt__, __le__, __gt__, __ge__: Definieren Sie Vergleichsoperationen.

Beispiel: Implementierung der Gesamtbestellung für eine benutzerdefinierte Klasse

from functools import total_ordering

@total_ordering
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __eq__(self, other):
        return (self.title, self.author) == (other.title, other.author)

    def __lt__(self, other):
        return (self.title, self.author) < (other.title, other.author)

    def __repr__(self):
        return f"{self.title} by {self.author}"

# Usage
book1 = Book("Title1", "Author1")
book2 = Book("Title2", "Author2")
books = [book2, book1]
print(sorted(books))  # Output: [Title1 by Author1, Title2 by Author2]

Praktischer Anwendungsfall:Ermöglicht das Sortieren oder Vergleichen benutzerdefinierter Objekte, nützlich in Datenstrukturen wie Heaps, binären Suchbäumen oder einfach beim Sortieren von Listen benutzerdefinierter Objekte.

4. Containermethoden: Praktischer Anwendungsfall

Benutzerdefiniertes Wörterbuch mit Tasten ohne Berücksichtigung der Groß-/Kleinschreibung

Erstellen eines wörterbuchähnlichen Objekts, das Schlüssel ohne Berücksichtigung der Groß- und Kleinschreibung behandelt.

Beispiel: Wörterbuch ohne Berücksichtigung der Groß-/Kleinschreibung

class CaseInsensitiveDict:
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        return self._data[key.lower()]

    def __setitem__(self, key, value):
        self._data[key.lower()] = value

    def __delitem__(self, key):
        del self._data[key.lower()]

    def __contains__(self, key):
        return key.lower() in self._data

    def keys(self):
        return self._data.keys()

    def items(self):
        return self._data.items()

    def values(self):
        return self._data.values()

# Usage
cid = CaseInsensitiveDict()
cid["Name"] = "Alice"
print(cid["name"])  # Output: Alice
print("NAME" in cid)  # Output: True

Praktischer Anwendungsfall:Erstellen von Wörterbüchern, bei denen bei Schlüsseln die Groß-/Kleinschreibung nicht beachtet werden sollte, nützlich für die Handhabung von Benutzereingaben, Konfigurationseinstellungen usw.

Abschluss

Magic-Methoden bieten eine leistungsstarke Möglichkeit, das Verhalten Ihrer Objekte in Python anzupassen. Das Verstehen und effektive Verwenden dieser Methoden kann Ihre Klassen intuitiver machen und sich nahtlos in die integrierten Funktionen und Operatoren von Python integrieren. Unabhängig davon, ob Sie benutzerdefinierte numerische Typen, Container oder Attributzugriffsmuster implementieren, können magische Methoden die Flexibilität und Funktionalität Ihres Codes erheblich verbessern

Das obige ist der detaillierte Inhalt vonLernen Sie Python Magic-Methoden: Eine einfache Erklärung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!