Kā pielāgot klases uzvedību Python, izmantojot burvju metodes

Programmā Python klases nodrošina tīru līdzekli datu un funkcionalitātes apvienošanai atkārtoti lietojamos elementos. Pielāgotu klašu izveide ļauj modelēt reālās pasaules entītijas, piemēram, lietotājus, produktus un darbiniekus.

Python klasēs tiek definētas maģiskas metodes, kuras varat pielāgot, lai ļautu jums pielāgot klašu uzvedību unikālām situācijām.

Izpratne par burvju metodēm

Iedomājieties maģiskās metodes, ko sauc arī par dunder metodēm, kā slepenas burvestības vai slēptās dziesmas, ko Python automātiski izsauc, kad veicat noteiktas darbības ar objektu.

Python nodrošina daudz iebūvētu uzvedību klasēm, izmantojot instances, statiskās un klases metodes. Jūs varat izveidot Python klases, un vēl vairāk pielāgojiet tos, izmantojot maģiskas metodes.

Maģiskās metodes ir Python instanču metodes, kurām ir divas pasvītras (__metode__) pirms un pēc metodes nosaukuma.

Šīs īpašās metodes sniedz norādījumus Python par to, kā rīkoties ar klases objektiem. Šeit ir dažas Python klasēs visbiežāk izmantotās maģijas metodes:

• __gt__: šī metode pārbauda, ​​vai viens objekts ir lielāks par citu.
• __tajā__: šī metode darbojas, kad veidojat klases gadījumu, un tā galvenokārt ir paredzēta atribūtu inicializācijai.
• __str__: atgriež objektu aprakstošās klases virknes attēlojumu.
• __repr__: šī metode dod izvadi, kas ļauj atkārtoti izveidot objektu, izmantojot eval().
• __len__: Kad lietojat len() funkcija objektā, šī metode atgriež objekta garumu.
• __eq__: šī metode ļauj salīdzināt objektus, izmantojot dubulto vērtību, kas vienāda ar (==) operators.
• __lt__: Tas īsteno mazāk nekā (
• __pievienot__: Kad izmantojat papildinājumu (+) operatoru objektos šī metode palaiž un veic pievienošanas darbības.
• __getitem__: ļauj izgūt vienumus no objekta, izmantojot indeksa sintaksi, piemēram obj [atslēga].

Burvju metožu ieviešana

Labākais veids, kā izprast burvju metodes, ir to izmantošana.

Objekta virknes attēlojums

Varat pielāgot objekta virknes attēlojumu lasāmībai vai turpmākai apstrādei.

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

Šeit jums ir vienkāršs Persona klase ar an __tajā__ maģiska metode, lai to inicializētu. Kad drukājat p1 objektu, tas izmanto Python nodrošināto noklusējuma virknes attēlojumu.

Lai pielāgotu virknes attēlojumu, definējiet __str__ un __repr__ burvju metodes:

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)

Tagad jums ir lasāmāks un visaptverošāks virknes attēlojums p1 objekts:

Objekta garuma īpašība

Iedomājieties to, kad zvanāt uz len() Personas objekta metode, vēlaties to augstumu. Ieviest __len__ burvju metode Persona klase:

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))

The __len__ burvju metode atgriež augstuma atribūtu a Persona piemēram. Kad tu zvani len (2. lpp.), tas izsauks __len__ burvju metode automātiski, kas atgriež augstumu p2 objektu.

Objektu salīdzināšana

Ja jums ir jāsalīdzina klases objekti, pamatojoties uz noteiktām klases īpašībām. Jūs varat definēt __eq__ burvju metodi un īstenojiet savu salīdzināšanas loģiku.

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)

The __eq__ metode salīdzina nosaukums un vecums abu atribūti Personas objekti vienlīdzības noteikšanai.

Dubults vienāds ar (==) operators izmanto šo metodi, lai pārbaudītu vienlīdzību, nevis salīdzinātu identitātes. Tātad divi Persona gadījumi ir vienādi, ja tiem ir atbilstoši vārda un vecuma atribūti. Tas ļauj ignorēt noklusējuma vienlīdzības pārbaudes darbību jūsu pielāgotajai klasei.

Ieviešot šīs maģiskās metodes, varat definēt pielāgotu uzvedību, kas atbilst Python iebūvētajām ierīcēm.

Uzlabotas maģijas metodes

Šeit ir daži uzlaboti piemēri maģisko metožu izmantošanai, lai pielāgotu klases.

Nodarbības kā konteineri

Izmantojot maģiskas metodes, varat definēt klases, kas darbojas kā konteineri. Tu vari izmantot konteineri, piemēram, korteži, lai saglabātu datu elementu kolekcijas. Tie nodrošina dažādas metodes, kā manipulēt ar ietvertajiem elementiem, piekļūt tiem un atkārtot tos.

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

Tagad personas objekts var darboties kā konteiners:

Atribūtu piekļuves pielāgošana

Izmantojot __getattr__ burvju metodi, jūs varat pielāgot veidu, kā atribūtus Persona klasei tiek piekļūts, pamatojoties uz noteiktiem nosacījumiem.

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

The __getattr__ metode darbosies, mēģinot piekļūt atribūtam, kas objektā tieši nepastāv. Šajā gadījumā tas pārbauda, ​​vai atribūta nosaukums ir vecums un atgriež 40.

Jebkuram citam atribūta nosaukumam tas rada an Atribūta kļūda ar atbilstošu ziņojumu.

Padariet nodarbības izsaucamas

The __zvanīt__ metode ļauj uzskatīt klases gadījumu kā izsaucamu objektu (t.i., funkciju).

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

Kad veidojat gadījumu Papildinātājs un pēc tam nosauciet to ar argumentiem, __zvanīt__ metode palaiž un veic pievienošanu pirms rezultāta atgriešanas.

Operatora pārslodze

Izmantojot maģiskas metodes, jūs varat veikt operatora pārslodzi. Operatora pārslodze ļauj definēt pielāgotas darbības iebūvētajiem operatoriem, ja tos lieto kopā ar jūsu klašu gadījumiem. Šeit ir izplatīts piemērs, kas izskaidro operatora pārslodzi.

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)

Rezultāts ir jauns vektors:

The Vektors klase definē __pievienot__ metode, kas darbojas, kad izmantojat + operators starp diviem klases gadījumiem. Metode pievieno abu vektoru atbilstošās sastāvdaļas un atgriež jaunu Vektors piemēram ar rezultātu.

Šeit jūs redzējāt fundamentālas burvju metodes, kuras varat ieviest, lai pielāgotu savas klases uzvedību. Python ir daudz vairāk maģisko metožu, kas piedāvā lielāku elastību, veidojot klases. Skatiet uz oficiālā dokumentācija lai iegūtu pilnu sarakstu.

Objektorientētā programmēšana Python

Maģiskās metodes Python nodrošina jaudīgus veidus, kā pielāgot un uzlabot klašu uzvedību. Maģiskās metodes ir saistītas ar Python objektorientētās programmēšanas (OOP) koncepciju. Tāpēc, mēģinot izmantot maģiskas metodes, ir svarīgi saprast OOP jēdzienu.