Python - konstruktører

I Python det er såkalte "magiske" metoder, det vil si metoder som er konstruert og har et spesielt navn, og som bare kalles under visse omstendigheter, siden det direkte kallet til disse metodene ikke er vanlig i et program.
Byggherrer
Metoden __i det__ den har ansvaret for å fungere som en konstruktør, det vil si at den vil initialisere en rekke attributter og utføre koden som vi definerer for øyeblikket et objekt i klassen blir opprettet, kalt "__init__" med to understreker på begynnelsen og slutten av init -ordet, så har du allerede riktig syntaks for det Python ta det som en "magisk" metode og vet at det må utføres når du starter klassen.
Det konstruktøren oppnår er at i stedet for å gjøre følgende for å initialisere et objekt:

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

Objektet har allerede plassert denne koden og har initialisert attributtene bare ved å bruke:

>>> f = FooBar ()

Som du kan se, er det en viktig besparelse ved koding og en hjelp hvis vi glemmer å initialisere objektet.
Opprette konstruktøren
Lag konstruktøren i Python Det er ganske enkelt, vi må bare definere metoden og legge til hva som må gjøres når objektet er opprettet, la oss se et eksempel:

På bildet kan du se den definerte metoden, og i hva den må utføre ser vi at den definerer attributtet somevar og er lik 42. La oss se et eksempel på hvordan et objekt i denne klassen ville kjøre:

På bildet ser vi det når vi definerer objektet f av typen FooBar Den initialiseres, og når du får tilgang til attributtet, skriver somevar ut 42, som er verdien definert i konstruktøren.
Hva skjer nå hvis vi vil at attributtene skal initialiseres dynamisk, la oss skrive om metoden som følger:

 klasse FooBar: def __init __ (self, value = 42): self.somevar = verdi 

Ved å gjøre den valgfrie parameteren kan vi passere en verdi, hvis vi ikke passerer den, vil det ta 42 som standardverdi.
Utførelsen av programmet vil være som følger:

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

På denne måten har vi gjort konstruktøren vår dynamisk slik at vi kan tilordne forskjellige attributter til objektene våre avhengig av våre behov i programmet.
Overskriver konstruktøren
Det er tider når vi må arve fra superklassene, for noen ganger må vi overskrive konstruktøren, la oss se følgende eksempel for å forstå hva dette handler om:

Her har vi opprettet en klasse kalt Bird der konstruktøren definerer den sultne attributten, vi utfører følgende og ser hvordan det fungerer:

 >>> b = Bird () >>> b.eat () Aaaah… >>> b.eat () Nei, takk! 

Hva skjer nå hvis vi arver fra denne klassen, la oss se følgende kode:

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

Vi kjører et lite program:

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

Hvis vi nå kaller eat () -metoden, ser vi en feil:

 >>> sb.eat () Traceback (siste samtale sist): Fil "", linje 1, i? Fil "birds.py", linje 6, i eat if self.hungry: AttributeError: SongBird -forekomst har ingen attributt 'sulten' 

Unntaket forteller oss at den sultne egenskapen ikke eksisterer, så vi må kalle konstruktøren av superklassen i konstruktøren vår:

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

Når koden kjøres, vil alt fungere uten problemer:

 >>> sb = SongBird () >>> sb.sing () Squawk! >>> sb.eat () Aaaah… >>> sb.eat () Nei, takk! 

Med dette fullfører vi opplæringen, vi vet allerede hvordan vi bruker __init__ -metoden på en grunnleggende måte og hvordan vi gjør det når vi må arve fra en høyere klasse.Likte og hjalp du denne opplæringen?Du kan belønne forfatteren ved å trykke på denne knappen for å gi ham et positivt poeng