Python - konstruktører

I Python der er såkaldte "magiske" metoder, det vil sige metoder, der er konstrueret og har et særligt navn, og som kun kaldes under visse omstændigheder, da det direkte kald af disse metoder ikke er sædvanligt inden for et programs omfang.
Bygherrer
Metoden __i det__ den er ansvarlig for at fungere som en konstruktør, det vil sige, at den vil initialisere en række attributter og udføre den kode, som vi definerer i det øjeblik, et objekt i klassen oprettes, kaldet "__init__" med to understregninger på begyndelsen og slutningen af ​​init -ordet, så har du allerede den korrekte syntaks for det Python tage det som en "magisk" metode og vide, at det skal udføres, når klassen instantieres.
Hvad konstruktøren opnår er, at i stedet for at gøre følgende for at initialisere et objekt:

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

Allerede ved at placere denne kode har objektet kun initialiseret dets attributter ved hjælp af:

>>> f = FooBar ()

Som du kan se, er det en vigtig besparelse ved kodning og en hjælp, hvis vi glemmer at initialisere objektet.
Oprettelse af konstruktøren
Opret konstruktøren i Python Det er ganske enkelt, vi skal bare definere metoden og tilføje, hvad der skal gøres, når objektet oprettes, lad os se et eksempel:

På billedet kan du se den definerede metode, og i hvad den skal udføre ser vi, at den definerer attributten somevar og er lig med 42. Lad os se et eksempel på, hvordan et objekt i denne klasse ville køre:

På billedet ser vi, at når man definerer objektets f af typen FooBar Den initialiseres, og når der åbnes dens attribut, udskriver somevar 42, som er den værdi, der er defineret i konstruktøren.
Hvad sker der nu, hvis vi ønsker, at attributterne skal initialiseres dynamisk, lad os omskrive metoden som følger:

 klasse FooBar: def __init __ (selv, værdi = 42): self.somevar = værdi 

Ved at gøre den valgfrie parameter kan vi videregive en værdi, hvis vi ikke passerer den, vil det tage 42 som standardværdi.
Udførelsen af ​​programmet ville være som følger:

 >>> f = FooBar ('Dette er et konstruktørargument') >>> f.somevar 'Dette er et konstruktørargument' 

På denne måde har vi gjort vores konstruktør dynamisk, så vi kan tildele forskellige attributter til vores objekter afhængigt af vores behov inden for programmet.
Overskriver konstruktøren
Der er tidspunkter, hvor vi skal arve fra superklasserne, for nogle gange skal vi overskrive konstruktøren, lad os se følgende eksempel for at forstå, hvad dette handler om:

Her har vi oprettet en klasse kaldet Bird, hvor konstruktøren definerer den sultne attribut, vi udfører følgende og ser, hvordan det fungerer:

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

Hvad sker der nu, hvis vi arver fra denne klasse, lad os se følgende kode:

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

Vi kører et lille program:

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

Hvis vi nu kalder metoden eat (), ser vi en fejl:

 >>> sb.eat () Traceback (seneste opkald sidste): Fil "", linje 1, i? Fil "birds.py", linje 6, i eat if self.hungry: AttributeError: SongBird -forekomst har ingen attribut 'sulten' 

Undtagelsen fortæller os, at den sultne attribut ikke eksisterer, så vi må kalde konstruktøren af ​​superklassen i vores konstruktør:

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

Når koden udføres, fungerer alt uden problemer:

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

Med dette afslutter vi selvstudiet, vi ved allerede, hvordan vi bruger __init__ -metoden på en grundlæggende måde, og hvordan vi gør det, når vi skal arve fra en højere klasse.Kan du lide og hjælpe denne vejledning?Du kan belønne forfatteren ved at trykke på denne knap for at give ham et positivt punkt