Hvordan tilpasse klasseatferd i Python ved hjelp av magiske metoder

I Python gir klasser en ren måte å pakke data og funksjonalitet sammen til gjenbrukbare elementer. Ved å lage tilpassede klasser kan du modellere virkelige enheter som brukere, produkter og ansatte.

Python-klasser definerer magiske metoder som du kan tilpasse slik at du kan forme oppførselen til klassene dine for unike situasjoner.

Forstå magiske metoder

Se for deg magiske metoder, også kalt dunder-metoder, som hemmelige trollformler eller skjulte chants som Python automatisk kaller når du utfører bestemte handlinger på et objekt.

Python gir mye innebygd atferd for klasser gjennom forekomst, statiske og klassemetoder. Du kan lage Python-klasser, og tilpasse dem ytterligere ved å bruke magiske metoder.

Magiske metoder er instansmetoder i Python som har to understrekinger (__metode__) før og etter metodenavnet.

Disse spesielle metodene gir instruksjoner til Python om hvordan man håndterer objekter i en klasse. Her er noen vanlige magiske metoder i Python-klasser:

• __gt__: Denne metoden sjekker om ett objekt er større enn et annet.
• __i det__: Denne metoden kjører når du oppretter en forekomst av en klasse, og den er hovedsakelig for attributtinitialisering.
• __str__: Dette returnerer en strengrepresentasjon av klassen som beskriver objektet.
• __repr__: Denne metoden gir en utgang som lar deg gjenskape objektet ved hjelp av eval().
• __len__: Når du bruker len() funksjon på et objekt denne metoden returnerer objektets lengde.
• __eq__: Denne metoden muliggjør sammenligning mellom objekter ved å bruke dobbel lik (==) operatør.
• __lt__: Den implementerer mindre enn (
• __Legg til__: Når du bruker tillegget (+) operatør på objekter denne metoden kjører og utfører tilleggsoperasjoner.
• __getitem__: Lar deg hente elementer fra et objekt ved å bruke indekssyntaks, som obj[nøkkel].

Implementering av magiske metoder

Den beste måten å forstå magiske metoder på er å bruke dem.

Strengrepresentasjon av et objekt

Du kan tilpasse strengrepresentasjonen av et objekt for lesbarhet eller videre behandling.

classPerson:
def__init__(self, name, age):
 self.name = name
 self.age = age
p1 = Person('John', 25)
print(p1)

Her har du en enkel Person klasse med en __i det__ magisk metode for å initialisere den. Når du skriver ut p1 objekt, bruker den standard strengrepresentasjon levert av Python.

For å tilpasse strengrepresentasjonen, definer __str__ og __repr__ magiske metoder:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__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)

Nå har du en mer lesbar og omfattende strengrepresentasjon av p1 gjenstand:

Lengdeegenskapen til et objekt

Tenk deg det når du ringer len() metoden til et Person-objekt, vil du ha høyden deres. Implementer __len__ magisk metode for Person klasse:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__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__ magisk metode returnerer høydeattributtet til en Person forekomst. Når du ringer len (p2), vil den kalle __len__ magisk metode automatisk som returnerer høyden på s2 gjenstand.

Håndtering av sammenligning mellom objekter

Hvis du trenger å sammenligne objekter i en klasse basert på visse egenskaper for klassen. Du kan definere __eq__ magisk metode og implementer sammenligningslogikken din.

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__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
def__eq__(self, other):
return self.name == other.name and self.age == other.age
p1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)

De __eq__ metoden sammenligner Navn og alder egenskapene til de to Personens gjenstander for å bestemme likhet.

Det doble lik (==)-operatøren bruker denne metoden for å se etter likhet i stedet for å sammenligne identiteter. Så to Person forekomster er like hvis de har samsvarende navn og aldersattributter. Dette lar deg overstyre standard oppførsel for likhetskontroll for din egendefinerte klasse.

Ved å implementere disse magiske metodene kan du definere tilpasset atferd som vil være i samsvar med Pythons innebygde elementer.

Avanserte magiske metoder

Her er noen avanserte eksempler på bruk av magiske metoder for å tilpasse klasser.

Få klasser til å fungere som containere

Ved å bruke magiske metoder kan du definere klasser som oppfører seg som containere. Du kan bruke beholdere, som tupler, for å lagre samlinger av dataelementer. De gir ulike metoder for å manipulere, få tilgang til og iterere gjennom de inneholdte elementene.

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] = value
def__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

Nå kan et personobjekt oppføre seg som en beholder:

Tilpasse attributttilgang

Bruker __getattr__ magisk metode kan du tilpasse måten attributter til Person klasse blir tilgjengelig basert på visse betingelser.

classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40

De __getattr__ metoden vil kjøre når du prøver å få tilgang til et attributt som ikke eksisterer direkte i objektet. I dette tilfellet sjekker den om attributtnavnet er alder og returnerer 40.

For et hvilket som helst annet attributtnavn gir det en AttributeError med tilhørende melding.

Få klasser til å oppføre seg som ringbare

De __anrop__ metoden lar deg behandle en forekomst av klassen som et anropbart objekt (dvs. en funksjon).

classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5

Når du oppretter en forekomst av Huggorm og så kall det med argumenter, __anrop__ metoden kjører og utfører tillegget før resultatet returneres.

Operatør overbelastning

Ved å bruke magiske metoder kan du utføre operatøroverbelastning. Operatøroverbelastning lar deg definere tilpasset atferd for innebygde operatører når de brukes med forekomster av dine egne klasser. Her er et vanlig eksempel som forklarer operatørens overbelastning.

classVector:
def__init__(self, x, y):
 self.x = x
 self.y = y
def__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)

Resultatet er en ny vektor:

De Vektor klasse definerer __Legg til__ metoden, som kjører når du bruker + operatør mellom to forekomster av klassen. Metoden legger til de tilsvarende komponentene i de to vektorene og returnerer en ny Vektor eksempel med resultatet.

Her har du sett grunnleggende magiske metoder som du kan implementere for å tilpasse klasseatferden din. Python har mange flere magiske metoder som gir mer fleksibilitet når du lager klasser. Referere til offisiell dokumentasjon for en komplett liste.

Objektorientert programmering i Python

Magiske metoder i Python gir kraftige måter å tilpasse og forbedre oppførselen til klassene. Magiske metoder går sammen med konseptet objektorientert programmering (OOP) i Python. Så det er viktig å forstå konseptet OOP når du prøver å bruke magiske metoder.