Magische Methoden in Python verstehen

Magic-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 geben.

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: Zugriff auf benutzerdefinierte Attribute 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 



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 benötigt und dennoch 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: Gesamtbestellung für eine benutzerdefinierte Klasse implementieren

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) 



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 Schlüsseln, bei denen die Groß-/Kleinschreibung nicht berücksichtigt wird


Erstellen eines wörterbuchähnlichen Objekts, das Schlüssel ohne Berücksichtigung der Groß-/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, in 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