En af Pythons mindre kendte, men værdifulde funktioner er evnen til at implementere magiske metoder på objekter. Ved hjælp af magiske metoder kan vi skrive renere kode, der er intuitiv og let at forstå.
Med magiske metoder kan vi skabe grænseflader til at interagere med objekter på en måde, der føles mere pytonisk. Denne artikel vil introducere dig til magiske metoder, diskutere bedste praksis for at skabe dem og udforske de almindelige magiske metoder, du vil støde på.
Indholdsfortegnelse
Hvad er magiske metoder?
Magiske metoder er Python-metoder, der definerer, hvordan Python-objekter opfører sig, når almindelige operationer udføres på dem. Disse metoder er tydeligt defineret med dobbelt understregning før og efter metodenavnet.
Som et resultat kaldes de almindeligvis dunder-metoder, som i dobbelt understregning. En almindelig dunder-metode, du måske allerede har stødt på, er __init__()-metoden, der bruges til at definere klassekonstruktører.
Typisk er det ikke meningen, at dunder-metoder skal kaldes direkte i din kode; snarere vil de blive kaldt af tolken, mens programmet kører.
Hvorfor er magiske metoder nyttige?
Magiske metoder er et nyttigt koncept i objektorienteret programmering i Python. Ved at bruge dem angiver du adfærden af dine brugerdefinerede datatyper, når de bruges med almindelige, indbyggede operationer. Disse operationer omfatter:
🟢 Aritmetiske operationer
🟢 Sammenligningsoperationer
Livscyklus operationer
🟢 Repræsentationsoperationer
Det følgende afsnit vil diskutere, hvordan man implementerer magiske metoder, der definerer, hvordan applikationen opfører sig, når den bruges i alle ovenstående kategorier.
Sådan defineres magiske metoder
Som tidligere nævnt specificerer magiske metoder objekters adfærd. Som sådan er de defineret som en del af objektets klasse. Fordi de er en del af objektklassen, tager de ind som det første argument selv, som er en reference til selve objektet.
De kan tage yderligere argumenter ind afhængigt af, hvordan de vil blive kaldt af tolken. De er også tydeligt defineret med to understregninger før og efter deres navne.
Implementering
Meget af det, vi har diskuteret indtil nu, virker teoretisk og abstrakt. I dette afsnit vil vi implementere en simpel rektangelklasse.
Denne klasse vil have længde- og breddeegenskaber. Ved at bruge __init__ metoden kan du angive disse egenskaber ved instansiering. Derudover vil du være i stand til at sammenligne forskellige rektangler for at se, om de er lig, mindre eller større end en anden ved at bruge ==, < og > operatorerne. Endelig skal rektanglet være i stand til at give en meningsfuld strengrepræsentation.
Opsætning af kodningsmiljøet
For at følge med i denne gennemgang skal du bruge et Python-runtime-miljø. Du kan bruge en lokal, eller du kan bruge online toadmin.dk Python-kompileren.
Oprettelse af rektangelklassen
Lad os først starte med at definere klassen Rektangel.
class Rectangle:
pass
Oprettelse af konstruktørmetoden
Lad os derefter skabe vores første magiske metode, klassekonstruktørmetoden. Denne metode tager højden og bredden ind og gemmer dem som attributter på klasseforekomsten.
class Rectangle:
def __init__(self, height, width):
self.height = height
self.width = width
Oprettelse af en magisk metode til strengrepræsentation
Dernæst vil vi skabe en metode, der tillader vores klasse at generere en menneskelig læsbar streng til at repræsentere objektet. Denne metode kaldes hver gang vi kalder funktionen str() og sender en instans af klassen Rectangle som et argument. Denne metode kaldes også, når du kalder funktioner, der forventer et strengargument, såsom printfunktionen.
class Rectangle:
def __init__(self, height, width):
self.height = height
self.width = width
def __str__(self):
return f'Rectangle({self.height}, {self.width})'
Metoden __str__() skal returnere en streng, som du ønsker skal repræsentere objektet. I dette tilfælde returnerer vi en streng af formatet Rectangle(
Oprettelse af magiske metoder til sammenligningsoperationer
Dernæst vil vi oprette sammenligningsoperatorer for lig med, mindre end og større end operationer. Dette kaldes operatøroverbelastning. For at skabe disse bruger vi de magiske metoder __eq__, __lt__ og __gt__ henholdsvis. Disse metoder returnerer en boolsk værdi efter sammenligning af rektanglernes areal.
class Rectangle:
def __init__(self, height, width):
self.height = height
self.width = width
def __str__(self):
return f'Rectangle({self.height}, {self.width})'
def __eq__(self, other):
""" Checking for equality """
return self.height * self.width == other.height * other.width
def __lt__(self, other):
""" Checking if the rectangle is less than the other one """
return self.height * self.width < other.height * other.width
def __gt__(self, other):
""" Checking if the rectage is greater than the other one """
return self.height * self.width > other.height * other.width
Som du kan se, tager disse metoder to parametre. Den første er det aktuelle rektangel, og den anden er den anden værdi, som den sammenlignes med. Denne værdi kan være en anden rektangelforekomst eller en hvilken som helst anden værdi. Logikken for, hvordan sammenligningen og betingelserne, hvorunder sammenligningen vil vende tilbage, er helt op til dig.
Almindelige magiske metoder
I dette næste afsnit vil vi diskutere de almindelige magiske metoder, du vil støde på og bruge.
#1. Aritmetiske operationer
Aritmetiske magiske metoder kaldes, når en forekomst af din klasse er placeret i venstre side af et regnetegn. Metoden vil blive kaldt med to argumenter, hvor det første er en reference til instansen. Den anden værdi er objektet til højre for tegnet. Metoderne og tegnene er som følger:
NameMethodSignDescriptionAddition__add__+Implementerer tilføjelse. Subtraktion__sub__–Implementerer subtraktion.Multiplication__mul__*Implementerer multiplikationDivision__div__/Implementerer division.Etageopdeling__floordiv__//Implementerer etagedeling.
#2. Sammenligningsoperationer
Ligesom de aritmetiske magiske metoder kaldes disse metoder, når en instans af den klasse, de er defineret for, er placeret til venstre for sammenligningsoperatoren. Ligesom aritmetiske magiske metoder kaldes de også med to parametre; den første er en reference til instansen af objektet. Den anden er en reference til værdien på højre side af skiltet.
NameMethodSignDescriptionLess than__lt__
#3. Livscyklusdrift
Disse metoder vil blive kaldt som svar på de forskellige livscyklusmetoder for et objekt, såsom at blive instansieret eller slettet. Konstruktøren __init__ falder ind under denne kategori. De almindelige metoder i denne kategori er angivet i tabellen nedenfor:
NameMethodDescriptionConstructor__init__Denne metode kaldes, når et objekt i den klasse, det er defineret for, slettes. Den kan bruges til at udføre oprydningshandlinger, såsom at lukke alle filer, den havde åbnet. Deletion__del__Denne metode kaldes, når et objekt i den klasse, det er defineret til, slettes. Den kan bruges til at udføre oprydningshandlinger, såsom at lukke alle filer, den har åbnet. Denne metode kaldes før konstruktøren og tager klassen ind såvel som eventuelle yderligere argumenter. Det returnerer en forekomst af klassen. For det meste er det ikke for nyttigt, men det er dækket i detaljer her.
#4. Repræsentationsdrift
NameMethodDescriptionStr__str__Returneringer en menneskelæselig strengrepræsentation af objektet. Denne metode kaldes, når du kalder funktionen str() og sender en forekomst af klassen som et argument. Det kaldes også, når du videregiver i instansen til funktionerne print() og format(). Det er beregnet til at give en streng, der er forståelig af slutbrugeren af applikationen.Repr__repr__Returnerer en strengrepræsentation af objektet, der bruges af udvikleren. Ideelt set bør den returnerede streng være informationsrig, så du kan konstruere en identisk forekomst af objektet ud fra strengen.
Bedste praksis for at skabe magiske metoder
Magiske metoder er utrolige og vil forenkle din kode. Det er dog vigtigt at have følgende ting for øje, når du bruger dem.
- Brug dem sparsomt – Implementering af for mange magiske metoder i dine klasser gør din kode svær at forstå. Begræns dig selv til kun at implementere de væsentlige.
- Sørg for, at du forstår præstationsimplikationerne af metoder som __setatrr__ og __getattr__, før du bruger dem.
- Dokumenter adfærden af dine magiske metoder, så andre udviklere kan vide præcis, hvad de gør. Dette gør det nemmere for dem at bruge dem og fejlfinde, når det er nødvendigt.
Afsluttende ord
I denne artikel introducerede jeg magiske metoder som en måde at lave klasser på, der kan bruges med indbyggede operationer. Jeg diskuterede også, hvordan de defineres, og gennemgik et eksempel på en klasse, som magiske metoder implementerede. Dernæst nævnte jeg de forskellige metoder, som du sandsynligvis kommer til at bruge og har brug for, før du deler et par bedste fremgangsmåder, du skal huske på.
Dernæst vil du måske lære, hvordan du implementerer Counter-klassen i Python.