Inhoudsopgave
In Python er zijn zogenaamde "magische" methoden, dat wil zeggen methoden die zijn geconstrueerd en een speciale naam hebben en die alleen onder bepaalde omstandigheden worden aangeroepen, omdat de directe aanroep van deze methoden niet gebruikelijk is in het kader van een programma.Bouwers
De methode __in het__ het is verantwoordelijk voor het optreden als een constructor, dat wil zeggen dat het een reeks attributen initialiseert en de code uitvoert die we definiëren op het moment dat een object van de klasse wordt gemaakt, genaamd "__init__" met twee onderstrepingstekens aan de begin en einde van het init-woord, dan heb je daar al de juiste syntaxis voor Python neem het als een "magische" methode en weet dat het moet worden uitgevoerd bij het instantiëren van de klasse.
Wat de constructor bereikt, is dat in plaats van het volgende te doen om een object te initialiseren:
>>> f = FooBar () >>> f.init ()
Door deze code al te plaatsen, heeft het object zijn attributen alleen geïnitialiseerd met behulp van:
>>> f = FooBar ()
Zoals u kunt zien, is het een belangrijke besparing bij het coderen en een hulp voor het geval we vergeten het object te initialiseren.
De constructor maken
Maak de constructor in Python Het is vrij eenvoudig, we moeten alleen de methode definiëren en toevoegen wat er moet gebeuren wanneer het object wordt gemaakt, laten we een voorbeeld bekijken:
Wat gebeurt er als we willen dat de attributen dynamisch worden geïnitialiseerd, laten we de methode als volgt herschrijven:
klasse FooBar: def __init __ (zelf, waarde = 42): zelf.somevar = waarde
Als we de optionele parameter maken, kunnen we een waarde doorgeven, in het geval dat we deze niet doorgeven, wordt 42 als standaardwaarde gebruikt.
De uitvoering van het programma zou als volgt zijn:
>>> f = FooBar ('Dit is een constructorargument') >>> f.somevar 'Dit is een constructorargument' Op deze manier hebben we onze constructor dynamisch gemaakt, zodat we verschillende attributen aan onze objecten kunnen toewijzen, afhankelijk van onze behoeften binnen het programma.
De constructor overschrijven
Er zijn momenten waarop we moeten erven van de superklassen, hiervoor moeten we soms de constructor overschrijven, laten we het volgende voorbeeld bekijken om te begrijpen waar dit allemaal over gaat:
>>> b = Vogel () >>> b.eat () Aaaah… >>> b.eat () Nee, bedankt!
Wat gebeurt er als we van deze klasse erven, laten we de volgende code bekijken:
class SongBird (Bird): def __init __ (self): self.sound = 'Squawk!' def sing (self): print self.sound
We draaien een klein programma:
>>> sb = SongBird () >>> sb.sing () Squawk!
Als we nu de methode eat () aanroepen, zien we een fout:
>>> sb.eat () Traceback (meest recente oproep laatst): Bestand "", regel 1, in? Bestand "birds.py", regel 6, in eat if self.hungry: AttributeError: SongBird-instantie heeft geen attribuut 'hongerig'
De uitzondering vertelt ons dat het kenmerk honger niet bestaat, dus we moeten de constructor van de superklasse binnen onze constructor aanroepen:
class SongBird (Vogel): def __init __ (zelf): Bird .__ init __ (zelf) self.sound = 'Squawk!' def sing (self): print self.sound
Als u nu de code uitvoert, werkt alles zonder problemen:
>>> sb = SongBird () >>> sb.sing () Squawk! >>> sb.eat () Aaaah… >>> sb.eat () Nee, bedankt!
Hiermee ronden we de tutorial af, we weten al hoe we de __init__-methode op een basismanier moeten gebruiken en hoe we dit moeten doen als we moeten erven van een hogere klasse.Vond je deze tutorial leuk en hielp je hem?Je kunt de auteur belonen door op deze knop te drukken om hem een positief punt te geven
