Python - Konstruktörer

I Pytonorm det finns så kallade "magiska" metoder, det vill säga metoder som är konstruerade och har ett speciellt namn och som endast kallas under vissa omständigheter, eftersom dessa metoders direkta anrop inte är vanligt inom ramen för ett program.
Byggare
Metoden __i det__ den ansvarar för att agera som konstruktör, det vill säga att den kommer att initiera en serie attribut och köra den kod som vi definierar för när ett objekt i klassen skapas, kallas "__init__" med två understreck vid början och slutet av init -ordet då har du redan rätt syntax för det Pytonorm ta det som en "magisk" metod och vet att det måste köras när klassen startas.
Vad konstruktören uppnår är att istället för att göra följande för att initiera ett objekt:

 >>> f = FooBar () >>> f.init () 

Objektet har redan placerat den här koden och har initialiserat sina attribut endast med:

>>> f = FooBar ()

Som du kan se är det en viktig besparing vid kodning och en hjälp om vi glömmer att initiera objektet.
Skapar konstruktören
Skapa konstruktören i Pytonorm Det är ganska enkelt, vi måste bara definiera metoden och lägga till vad som måste göras när objektet skapas, låt oss se ett exempel:

I bilden kan du se den definierade metoden och i vad den måste utföra ser vi att den definierar attributet någon gång och är lika med 42. Låt oss se ett exempel på hur ett objekt av denna klass skulle köras:

På bilden ser vi det när man definierar objektet f av typen Foo bar Det initieras och när man öppnar dess attribut skriver somevar ut 42, vilket är värdet som definieras i konstruktorn.
Vad händer nu om vi vill att attributen ska initieras dynamiskt, låt oss skriva om metoden enligt följande:

 klass FooBar: def __init __ (själv, värde = 42): self.somevar = värde 

Genom att göra den valfria parametern kan vi skicka ett värde, om vi inte klarar det tar det 42 som standardvärde.
Utförandet av programmet skulle vara följande:

 >>> f = FooBar ('This is a constructor argument') >>> f.somevar 'This is a constructor argument' 

På detta sätt har vi gjort vår konstruktör dynamisk så att vi kan tilldela våra objekt olika attribut beroende på våra behov inom programmet.
Skriv över konstruktören
Det finns tillfällen då vi måste ärva från superklasserna, för ibland måste vi skriva över konstruktören, låt oss se följande exempel för att förstå vad det här handlar om:

Här har vi skapat en klass som heter Bird där konstruktören definierar det hungriga attributet, vi utför följande och ser hur det fungerar:

 >>> b = Bird () >>> b.eat () Aaaah… >>> b.eat () Nej, tack! 

Vad händer nu om vi ärver från den här klassen, låt oss se följande kod:

 klass SongBird (Bird): def __init __ (self): self.sound = 'Squawk!' def sing (self): print self.sound 

Vi kör ett litet program:

 >>> sb = SongBird () >>> sb.sing () Squawk! 

Om vi ​​nu kallar eat () -metoden ser vi ett fel:

 >>> sb.eat () Traceback (senaste samtalet sist): Fil "", rad 1, i? Fil "birds.py", rad 6, in eat if self.hungry: AttributeError: SongBird -instansen har inget attribut "hungrig" 

Undantaget berättar att det hungriga attributet inte existerar, så vi måste kalla konstruktören för superklassen inom vår konstruktör:

 klass SongBird (Bird): def __init __ (self): Bird .__ init __ (self) self.sound = 'Squawk!' def sing (self): print self.sound 

Nu när koden körs kommer allt att fungera utan problem:

 >>> sb = SongBird () >>> sb.sing () Squawk! >>> sb.eat () Aaaah… >>> sb.eat () Nej, tack! 

Med detta avslutar vi handledningen, vi vet redan hur vi använder __init__ -metoden på ett grundläggande sätt och hur vi gör det när vi måste ärva från en högre klass.Gillade du och hjälpte denna handledning?Du kan belöna författaren genom att trycka på den här knappen för att ge honom en positiv poäng