I denne vejledning lærer vi om metodeopløsningsrækkefølgen, som også er kendt som MRO. Det er et væsentligt koncept for Python-arv.
Metodeopløsningsrækkefølgen beskriver søgestien for klassen, som Python bruger til at få den passende metode i klasser, der indeholder multi-arven.
Introduktion
Som vi ved det, kaldes en klasse, der bliver nedarvet, underklassen eller forældreklassen, mens den klasse, der arver, er kendt som en underklasse eller underklasse. I multi-arven kan en klasse bestå af mange funktioner, så metodeopløsningsordreteknikken bruges til at søge i den rækkefølge, som basisklassen udføres i.
Med enkle ord - 'Metoden eller attributterne udforskes i den aktuelle klasse, hvis metoden ikke er til stede i den aktuelle klasse, flytter søgningen til de overordnede klasser, og så videre'. Dette er et eksempel på en dybde-først-søgning.
Det spiller en væsentlig rolle i multipel arv, hvor den samme metode kan findes i de flere superklasser.
For at forstå det på en bedre måde, lad os se, hvordan vi kan bruge det.
Eksempel -
class A: def myname(self): print('I am a class A') class B(A): def myname(self): print('I am a class B') class C(A): def myname(self): print('I am a class C') c = C() print(c.myname())
Produktion:
I am a class C
Forklaring -
Der er en multipel arv i ovenstående kode. Vi har defineret tre klasse kaldet A, B og C, og disse klasser har samme navn metode kaldet mit navn(). Vi oprettede en objektklasse C. Objektet påkaldte klasse C, ikke klassen, mens klasse C arvede klasse A-metoden.
Rækkefølgen følges i ovenstående kode er klasse B - > klasse A. Denne teknik er kendt som MRO (metodeopløsningsrækkefølge).
hvordan fungerer en computer
Lad os forstå et andet eksempel på multipel arv.
Eksempel -
class A: def myname(self): print(' I am a class A') class B(A): def myname(self): print(' I am a class B') class C(A): def myname(self): print('I am a class C') # classes ordering class D(B, C): pass d = D() d.myname()
Produktion:
I am a class B
Forklaring -
I ovenstående kode har vi oprettet en anden D-klasse uden at definere klasseattributter, der arvede B- og C-klasse. Da vi påberåbte os metoden mit navn(), den går i klasse D og søger efter mit navn( ) funktion. Men klasse D har ingen erklæring. Derfor overføres søgningen til klasse B og får mit navn() funktion og returnerer resultatet. Eftersøgningen vil foregå som følger.
Class D -> Class B -> Class C -> Class A
Hvis klasse B ikke ville have en metode, vil den påberåbe sig klasse C-metoden.
chr funktion python
Her foreslår vi, at du fjerner klasse B-metoden og kontrollerer, hvad der sker. Ved at gøre dette får du en idé om, hvordan metodeopløsningen fungerer.
Gammel og ny stilrækkefølge
I den ældre version af Python (2.1) er vi begrænset til at bruge de gamle klasser men Python (2.2 & fortsæt), kan vi bruge de nye klasser. Som standard har Python 3 originale (nye) klasser. Den nye stilklasses første forælder arver fra Python root 'objekt' klasse. Lad os se følgende eksempel -
Eksempel -
# Old style class class OldStyleClass: pass # New style class class NewStyleClass(object): pass
Deklarationsstilen for begge klasser er forskellig. I metodeopløsningen følger old-style klasser dybden-først venstre mod højre algoritmen (DLR), mens nye stilklasser bruger C3 Linearization algoritmen, mens de udfører multipel nedarvning.
DLR algoritme
Python opretter en liste over klasser, mens den implementerer multiple arv mellem klasserne. Denne liste bruges til at bestemme, hvilken metode der skal kaldes en påberåbes af instanser.
Vi kan antage, at man arbejder efter dens navn, da metodeopløsning vil søge i dybden først og derefter gå fra venstre mod højre. Nedenfor er eksemplet.
Eksempel -
class A: pass class B: pass class C(A, B): pass class D(B, A): pass class E(C,D): pass
Først vil algoritmen søge i instansklassen efter den påberåbte metode. Findes den ikke, går den ind i de første forældre, hvis der heller ikke findes. Det vil se på forælderens forælder. Dette vil fortsætte indtil slutningen af nedarvede klasser.
I ovenstående eksempel vil metodeopløsningsrækkefølgen være -
class D -> class B -> class A -> class C -> class A
Men A kan ikke være til stede to gange, så -
class D -> class B -> class A -> class C ->
Denne algoritme viser den mærkelige adfærd på det tidspunkt. Lad os se nedenstående eksempel.
array.fra java
Eksempel -
class A: pass class B: pass class C(A, B): pass class D(B, A): pass class E(C,D): pass
Ifølge DLR Algorithm vil rækkefølgen være E, C, D, B, A. Der er udveksling af klasse A & B i klasse C, hvilket er meget tvetydigt. Det betyder, at algoritmen ikke bevarer monotoniegenskaben.
Samuele Perdoni var den første person, der opdagede en uoverensstemmelse mellem MRO-algoritmerne.
C3 Lineariseringsalgoritme
C3-lineariseringsalgoritmen er en bedre version af DLR-algoritmen, fordi den fjerner inkonsistensen. Denne algoritme har nogle begrænsninger, der er angivet nedenfor.
- Børn skal gå forud for deres forældre.
- Hvis en bestemt klasse arver fra en eller flere klasser, gemmes de i den rækkefølge, der er angivet i basisklassens tuple.
Regler for C3-lineariseringsalgoritme
- Strukturen af metodeopløsningsrækkefølgen defineres af arvegrafen.
- Brugeren skal først besøge superklassen, efter at metoderne fra de lokale klasser er besøgt.
- Bevar monotoniteten
Metode til metodeopløsningsklasse
Python giver to måder at få metodeopløsningsrækkefølgen for en klasse - __mro__ attribut eller mro() metode. Ved hjælp af disse metoder kan vi vise rækkefølgen af metoden, hvori de er løst.
Lad os forstå følgende eksempel.
Eksempel -
class A: def myname(self): print(' I am a class A') class B(A): def myname(self): print(' I am a class B') class C(A): def myname(self): print('I am a class C') # classes ordering class D(B, C): pass # it prints the lookup order print(D.__mro__) print(C.mro())
Produktion:
(, , , , ) [, , ]
Som vi kan se i ovenstående output, får vi rækkefølgen af metodeopløsningsrækkefølgen. På en sådan måde fungerer C3-lineariseringsalgoritmen for multipel nedarvning.