Operatora nozīmi Python var mainīt atkarībā no izmantotajiem operandiem. Šajā apmācībā jūs uzzināsiet, kā izmantot operatora pārslodzi Python objektorientētajā programmēšanā.
Python operatora pārslodze
Python operatori strādā iebūvētajās klasēs. Bet viens un tas pats operators ar dažādiem tipiem izturas atšķirīgi. Piemēram, +operators veiks aritmētisko pievienošanu diviem skaitļiem, apvienos divus sarakstus vai saīsinās divas virknes.
Šo Python funkciju, kas ļauj vienam un tam pašam operatoram atšķirīgi nozīmēt atkarībā no konteksta, sauc par operatora pārslodzi.
Tātad, kas notiek, kad mēs tos izmantojam ar lietotāja definētas klases objektiem? Apskatīsim šādu klasi, kas mēģina simulēt punktu 2-D koordinātu sistēmā.
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y p1 = Point(1, 2) p2 = Point(2, 3) print(p1+p2)
Rezultāts
Traceback (pēdējais zvans pēdējais): Fails "", 9. rindiņa, drukātā veidā (p1 + p2) TypeError: neatbalstīts (-i) operanda tips (-i): "Point" un "Point"
Šeit mēs varam redzēt, ka TypeErrortika izvirzīts a, jo Python nezināja, kā pievienot divus Pointobjektus kopā.
Tomēr šo uzdevumu mēs varam sasniegt Python, izmantojot operatora pārslodzi. Bet vispirms iegūsim priekšstatu par īpašajām funkcijām.
Python īpašās funkcijas
Klases funkcijas, kas sākas ar dubultu pasvītrojumu __, Python sauc par īpašām funkcijām.
Šīs funkcijas nav tipiskās funkcijas, kuras mēs definējam klasei. __init__()Funkcija mēs iepriekš noteikta, ir viens no tiem. To sauc katru reizi, kad mēs izveidojam jaunu šīs klases objektu.
Python ir daudzas citas īpašas funkcijas. Apmeklējiet Python īpašās funkcijas, lai uzzinātu vairāk par tām.
Izmantojot īpašas funkcijas, mēs varam padarīt mūsu klasi saderīgu ar iebūvētām funkcijām.
>>> p1 = Point(2,3) >>> print(p1)
Pieņemsim, ka mēs vēlamies, lai print()funkcija drukātu objekta koordinātas, Pointnevis to, ko ieguvām. Mēs varam definēt __str__()metodi savā klasē, kas kontrolē objekta izdruku. Apskatīsim, kā mēs to varam sasniegt:
class Point: def __init__(self, x = 0, y = 0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x,self.y)
Tagad mēģināsim print()funkciju vēlreiz.
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0), (1))".format(self.x, self.y) p1 = Point(2, 3) print(p1)
Rezultāts
(2, 3)
Tā ir labāk. Izrādās, ka šī pati metode tiek izmantota, kad mēs izmantojam iebūvēto funkciju str()vai format().
>>> str(p1) '(2,3)' >>> format(p1) '(2,3)'
Tātad, kad izmantojat str(p1)vai format(p1), Python iekšēji izsauc p1.__str__()metodi. Līdz ar to nosaukums, īpašās funkcijas.
Tagad atgriezīsimies pie operatora pārslodzes.
Operatora pārslodze
Lai pārslogotu +operatoru, mums __add__()klasē būs jāievieš funkcija. Ar lielu spēku nāk liela atbildība. Šīs funkcijas ietvaros mēs varam darīt visu, kas mums patīk. Bet ir saprātīgāk atgriezt Pointkoordinātu summas objektu.
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x, self.y) def __add__(self, other): x = self.x + other.x y = self.y + other.y return Point(x, y)
Tagad mēģināsim pievienošanas operāciju vēlreiz:
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x, self.y) def __add__(self, other): x = self.x + other.x y = self.y + other.y return Point(x, y) p1 = Point(1, 2) p2 = Point(2, 3) print(p1+p2)
Rezultāts
(3,5)
Patiesībā notiek tas, ka, lietojot p1 + p2, Python zvana, p1.__add__(p2)kas savukārt ir Point.__add__(p1,p2). Pēc tam pievienošanas darbība tiek veikta tā, kā mēs norādījām.
Līdzīgi mēs varam pārslogot arī citus operatorus. Īpašā funkcija, kas mums jāievieš, ir dota zemāk.
| Operators | Izteiksme | Iekšēji |
|---|---|---|
| Papildinājums | p1 + p2 | p1.__add__(p2) |
| Atņemšana | p1 - p2 | p1.__sub__(p2) |
| Reizināšana | p1 * p2 | p1.__mul__(p2) |
| Jauda | p1 ** p2 | p1.__pow__(p2) |
| Nodaļa | p1 / p2 | p1.__truediv__(p2) |
| Stāvu nodaļa | p1 // p2 | p1.__floordiv__(p2) |
| Atlikums (modulo) | p1 % p2 | p1.__mod__(p2) |
| Pa kreisi Shift | p1 << p2 | p1.__lshift__(p2) |
| Pa labi pa labi | p1>> p2 | p1.__rshift__(p2) |
| Bitu virzienā UN | p1 & p2 | p1.__and__(p2) |
| Bitwise OR | p1 | p2 | p1.__or__(p2) |
| Bitor XOR | p1 p2 | p1.__xor__(p2) |
| Bitwise NĒ | ~p1 | p1.__invert__() |
Pārslodzes salīdzināšanas operatori
Python neierobežo operatora pārslodzi tikai aritmētiskajiem operatoriem. Mēs varam pārslogot arī salīdzināšanas operatorus.
Pieņemsim, ka mēs <savā Pointklasē vēlējāmies ieviest simbolu, kas mazāks par simbolu .
Salīdzināsim šo punktu lielumu no izcelsmes un šim nolūkam atgriezīsim rezultātu. To var īstenot šādi.
# overloading the less than operator class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x, self.y) def __lt__(self, other): self_mag = (self.x ** 2) + (self.y ** 2) other_mag = (other.x ** 2) + (other.y ** 2) return self_mag < other_mag p1 = Point(1,1) p2 = Point(-2,-3) p3 = Point(1,-1) # use less than print(p1
Output
True False FalseSimilarly, the special functions that we need to implement, to overload other comparison operators are tabulated below.
Operator Expression Internally
Less than p1 < p2p1.__lt__(p2)
Less than or equal to p1 <= p2p1.__le__(p2)
Equal to p1 == p2p1.__eq__(p2)
Not equal to p1 != p2p1.__ne__(p2)
Greater than p1> p2p1.__gt__(p2)
Greater than or equal to p1>= p2p1.__ge__(p2)
