Verfijn het gedrag van uw klassen met het flexibele overheersingsmechanisme van Python.
In Python bieden klassen een schone manier om gegevens en functionaliteit samen te bundelen in herbruikbare elementen. Door aangepaste klassen te maken, kunt u entiteiten uit de echte wereld modelleren, zoals gebruikers, producten en werknemers.
Python-klassen definiëren magische methoden die u kunt aanpassen, zodat u het gedrag van uw klassen voor unieke situaties kunt vormgeven.
Magische methoden begrijpen
Stel je magische methoden voor, ook wel dunder-methoden genoemd, als geheime spreuken of verborgen gezangen die Python automatisch oproept wanneer je bepaalde acties op een object uitvoert.
Python biedt veel ingebouwd gedrag voor klassen instance-, statische- en klassenmethoden. Jij kan Python-klassen makenen pas ze nog verder aan met behulp van magische methoden.
Magische methoden zijn instantiemethoden in Python die twee onderstrepingstekens hebben (__methode__) voor en na de naam van de methode.
Deze speciale methoden geven instructies aan Python over hoe om te gaan met objecten van een klasse. Hier zijn enkele veelgebruikte magische methoden in Python-klassen:
- __gt__: Deze methode controleert of het ene object groter is dan het andere.
- __in het__: Deze methode wordt uitgevoerd wanneer u een exemplaar van een klasse maakt, en is voornamelijk bedoeld voor attribuutinitialisatie.
- __str__: Dit retourneert een tekenreeksrepresentatie van de klasse die het object beschrijft.
- __repr__: deze methode levert een uitvoer op waarmee u het object opnieuw kunt maken met behulp van evaluatie().
- __len__: Wanneer u de len() functie op een object. Deze methode retourneert de lengte van het object.
- __eq__: Deze methode maakt vergelijking tussen objecten mogelijk met behulp van het dubbele gelijk aan (==) exploitant.
- __lt__: Het implementeert een vergelijking van minder dan (
- __toevoegen__: Wanneer u de toevoeging (+) operator op objecten wordt deze methode uitgevoerd en optelbewerkingen uitgevoerd.
- __krijgitem__: Hiermee kunt u items uit een object ophalen met behulp van de indexsyntaxis, zoals obj[sleutel].
Magische methoden implementeren
De beste manier om magische methoden te begrijpen is door ze te gebruiken.
Tekenreeksweergave van een object
U kunt de tekenreeksweergave van een object aanpassen voor leesbaarheid of verdere verwerking.
classPerson:
def__init__(self, name, age):
self.name = name
self.age = age
p1 = Person('John', 25)
print(p1)
Hier heb je een simpele Persoon klasse met een __in het__ magische methode om het te initialiseren. Wanneer u de p1 object, gebruikt het de standaard tekenreeksrepresentatie van Python.
Om de tekenreeksrepresentatie aan te passen, definieert u de __str__ En __repr__ magische methoden:
classPerson:
def__init__(self, name, age, height):
self.name = name
self.age = age
self.height = heightdef__str__(self):
returnf'{self.name} is {self.age} years old'def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78)
print(p1)
Nu hebt u een beter leesbare en uitgebreide tekenreeksrepresentatie van de p1 voorwerp:
Lengte-eigenschap van een object
Stel je voor dat, wanneer je de len() methode van een Person-object, wilt u de hoogte ervan. Implementeer de __len__ magische methode voor de Persoon klas:
classPerson:
def__init__(self, name, age, height):
self.name = name
self.age = age
self.height = heightdef__str__(self):
returnf'{self.name} is {self.age} years old'def__repr__(self):
returnf'{self.name} is {self.age} years old'def__len__(self):
return self.height
p2 = Person('Issac', 25, 89)
print(len(p2))
De __len__ magic-methode retourneert het hoogte-attribuut van a Persoon voorbeeld. Wanneer je belt len (p2), het zal de __len__ magische methode automatisch die de hoogte van de retourneert p2 voorwerp.
Vergelijking tussen objecten hanteren
Als u objecten van een klasse moet vergelijken op basis van bepaalde eigenschappen van de klasse. Je kunt definiëren __eq__ magische methode en implementeer uw vergelijkingslogica.
classPerson:def__init__(self, name, age, height):
self.name = name
self.age = age
self.height = heightdef__str__(self):
returnf'{self.name} is {self.age} years old'def__repr__(self):
returnf'{self.name} is {self.age} years old'def__len__(self):
return self.heightdef__eq__(self, other):
return self.name == other.name and self.age == other.agep1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)
De __eq__ methode vergelijkt de naam En leeftijd attributen van de twee Personen objecten om gelijkheid te bepalen.
Het dubbele gelijk aan (==) operator gebruikt deze methode om te controleren op gelijkheid in plaats van identiteiten te vergelijken. Dus twee Persoon instanties zijn gelijk als ze overeenkomende naam- en leeftijdskenmerken hebben. Hiermee kunt u het standaard gelijkheidscontrolegedrag voor uw aangepaste klasse overschrijven.
Door deze magische methoden te implementeren, kun je aangepast gedrag definiëren dat consistent is met de ingebouwde functies van Python.
Geavanceerde magische methoden
Hier zijn enkele geavanceerde voorbeelden van het gebruik van magische methoden om klassen aan te passen.
Klassen als containers laten fungeren
Met behulp van magische methoden kun je klassen definiëren die zich als containers gedragen. Je kunt gebruiken containers, zoals tupels, om verzamelingen gegevenselementen op te slaan. Ze bieden verschillende methoden voor het manipuleren, openen en doorlopen van de aanwezige elementen.
classPerson:
def__init__(self):
self.data = []def__len__(self):
return len(self.data)def__getitem__(self, index):
return self.data[index]def__setitem__(self, index, value):
self.data[index] = valuedef__delitem__(self, index):
del self.data[index]p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5
Nu kan een Person-object zich als een container gedragen:
Attribuuttoegang aanpassen
De... gebruiken __getattr__ magische methode kun je de manier waarop attributen van de Persoon klasse zijn toegankelijk op basis van bepaalde voorwaarden.
classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40
De __getattr__ methode wordt uitgevoerd wanneer u probeert toegang te krijgen tot een attribuut dat niet rechtstreeks in het object bestaat. In dit geval wordt gecontroleerd of de attribuutnaam dat is leeftijd en geeft 40 terug.
Voor elke andere attribuutnaam wordt een AttribuutFout met een bijbehorend bericht.
Zorg ervoor dat klassen zich gedragen alsof ze opvraagbaar zijn
De __telefoongesprek__ Met de methode kunt u een instantie van de klasse behandelen als een opvraagbaar object (d.w.z. een functie).
classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5
Wanneer u een exemplaar van Adder en noem het dan met argumenten, de __telefoongesprek__ methode wordt uitgevoerd en voert de optelling uit voordat het resultaat wordt geretourneerd.
Overbelasting van de machinist
Met behulp van magische methoden kunt u operatoroverbelasting uitvoeren. Door overbelasting van operators kunt u aangepast gedrag definiëren voor ingebouwde operators bij gebruik met exemplaren van uw eigen klassen. Hier is een veelvoorkomend voorbeeld dat de overbelasting van de operator verklaart.
classVector:
def__init__(self, x, y):
self.x = x
self.y = ydef__add__(self, other):
if isinstance(other, Vector):
new_x = self.x + other.x
new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")def__str__(self):
returnf"({self.x}, {self.y})"# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)
Het resultaat is een nieuwe vector:
De Vector klasse definieert de __toevoegen__ methode, die wordt uitgevoerd wanneer u de + operator tussen twee instanties van de klasse. De methode telt de overeenkomstige componenten van de twee vectoren op en retourneert een nieuwe Vector voorbeeld met het resultaat.
Hier heb je fundamentele magische methoden gezien die je kunt implementeren om het gedrag van je klas aan te passen. Python heeft nog veel meer magische methoden die meer flexibiliteit bieden bij het maken van klassen. Verwijs naar de officiële documentatie voor een volledige lijst.
Objectgeoriënteerd programmeren in Python
Magische methoden in Python bieden krachtige manieren om het gedrag van klassen aan te passen en te verbeteren. Magische methoden gaan samen met het concept van objectgeoriënteerd programmeren (OOP) in Python. Het is dus belangrijk om het concept van OOP te begrijpen wanneer je magische methoden probeert te gebruiken.