Python - Costruttori

Nel Pitone esistono metodi cosiddetti "magici", cioè metodi che sono costruiti e hanno un nome speciale e che vengono chiamati solo in determinate circostanze, poiché la chiamata diretta di questi metodi non è usuale nell'ambito di un programma.
Costruttori
Il metodo __dentro__ ha il compito di agire come costruttore, cioè inizializzerà una serie di attributi ed eseguirà il codice che definiamo al momento della creazione di un oggetto della classe, chiamato "__init__" con due caratteri di sottolineatura al all'inizio e alla fine della parola init allora hai già la sintassi corretta per questo Pitone prendilo come un metodo "magico" e sappi che deve essere eseguito quando si istanzia la classe.
Ciò che il costruttore ottiene è che invece di fare quanto segue per inizializzare un oggetto:

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

Già inserendo questo codice l'oggetto ha inizializzato i suoi attributi solo usando:

>>> f = FooBar ()

Come puoi vedere, è un importante risparmio durante la codifica e un aiuto nel caso in cui ci dimentichiamo di inizializzare l'oggetto.
Creare il costruttore
Crea il costruttore in Pitone È abbastanza semplice, dobbiamo solo definire il metodo e aggiungere cosa deve essere fatto quando l'oggetto viene creato, vediamo un esempio:

Nell'immagine puoi vedere il metodo definito e in quello che deve eseguire vediamo che definisce l'attributo qualcosa di diverso ed è uguale a 42. Vediamo un esempio di come verrebbe eseguito un oggetto di questa classe:

Nell'immagine vediamo che quando si definisce l'oggetto f del tipo FooBar Viene inizializzato e quando si accede al suo attributo, somevar stampa 42, che è il valore definito nel costruttore.
Ora cosa succede se vogliamo che gli attributi vengano inizializzati dinamicamente, riscriviamo il metodo come segue:

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

Rendendo il parametro opzionale possiamo passare un valore, nel caso non lo passiamo ci vorrà 42 come valore predefinito.
L'esecuzione del programma sarebbe la seguente:

 >>> f = FooBar ('Questo è un argomento del costruttore') >>> f.somevar 'Questo è un argomento del costruttore' 

In questo modo abbiamo reso dinamico il nostro costruttore in modo da poter assegnare attributi diversi ai nostri oggetti a seconda delle nostre esigenze all'interno del programma.
Sovrascrivere il costruttore
Ci sono momenti in cui dobbiamo ereditare dalle super classi, per questo a volte dobbiamo sovrascrivere il costruttore, vediamo il seguente esempio per capire di cosa si tratta:

Qui abbiamo creato una classe chiamata Bird dove il costruttore definisce l'attributo affamato, eseguiamo quanto segue e vediamo come funziona:

 >>> b = Bird () >>> b.eat () Aaaah… >>> b.eat () No, grazie! 

Ora cosa succede se ereditiamo da questa classe, vediamo il seguente codice:

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

Eseguiamo un piccolo programma:

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

Ora se chiamiamo il metodo eat() vedremo un errore:

 >>> sb.eat () Traceback (ultima chiamata più recente): File "", riga 1, in? File "birds.py", riga 6, in eat if self.hungry: AttributeError: l'istanza di SongBird non ha attributo 'affamato' 

L'eccezione ci dice che l'attributo affamato non esiste, quindi dobbiamo chiamare il costruttore della super classe all'interno del nostro costruttore:

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

Ora durante l'esecuzione del codice tutto funzionerà senza problemi:

 >>> sb = SongBird () >>> sb.sing () Squawk! >>> sb.eat () Aaaah… >>> sb.eat () No, grazie! 

Con questo finiamo il tutorial, sappiamo già come usare il metodo __init__ in maniera basilare e come farlo quando dobbiamo ereditare da una classe superiore.Ti è piaciuto e hai aiutato questo Tutorial?Puoi premiare l'autore premendo questo pulsante per dargli un punto positivo