Sommario[Nascondere][Spettacolo]
In questa lezione impareremo le classi, i costruttori e l'ereditarietà in Python.
Questi concetti sono davvero importanti in un programma di grandi dimensioni in cui è necessario definire tipi diversi.
Classi
Le lezioni sono essenziali nella programmazione e non sono specifiche di Python. Molti altri linguaggi di programmazione sostenere la nozione di classi. Usiamo le classi per definire nuovi tipi di dati.
Finora, abbiamo appreso i tipi di dati di base in Python come numeri, stringhe e booleani. Questi sono i tipi di dati di base o semplici in Python. Abbiamo anche visto un paio di tipi di dati complessi come elenchi e dizionari.
Sebbene questi tipi siano estremamente utili, non possono essere sempre utilizzati per modellare concetti complessi. Ad esempio, pensa all'idea di un punto o di un carrello della spesa. Un carrello non è un booleano o un elenco. È un tipo di dati diverso. Quindi possiamo usare le classi per definire nuovi tipi per modellare concetti reali.
Ora definiamo un nuovo tipo di dati chiamato punto. Questo nuovo tipo avrà metodi come abbiamo verificato in precedenza.
Ecco come lo farai:
Iniziamo definendo una classe usando la parola chiave “class” e subito dopo diamo un nome alla nostra classe.
class Point
Ora, guarda la convenzione di denominazione che ho usato qui. Ho messo in maiuscolo la prima lettera qui, questo è ciò che chiamiamo convenzione di denominazione pascal. Questa convenzione è diversa da quella che usiamo per nominare le nostre variabili e funzioni per le quali usiamo sempre lettere minuscole e separiamo più parole usando un trattino basso. Ma quando denominiamo le classi, non usiamo un trattino basso per separare più parole, mettiamo in maiuscolo la prima lettera di ogni parola.
Dopo aver definito la nostra classe, vengono utilizzati i due punti, il che significa che ora è definito un blocco.
class Point:
def move (self):
In questo blocco possiamo definire tutte le funzioni o metodi che appartengono ai punti. Ad esempio, possiamo definire una funzione chiamata "sposta" per spostare un punto. Nota che non appena scriviamo parentesi aperte, PyCharm aggiunge automaticamente "self" qui. Questa è una parola chiave speciale e vorrei tornare su questo a breve. Stampiamo "move" sul terminale.
print("move")
Definiamo un altro metodo come "disegna" e stampalo sul terminale.
def draw(self):
print("draw")
Abbiamo finito con la definizione della nostra classe “punto”. Con questo nuovo tipo, possiamo creare nuovi oggetti. Una classe definisce semplicemente il progetto o il modello per la creazione di oggetti che sono le istanze effettive basate su quel progetto. Per creare un oggetto, scriviamo il nome della nostra classe e poi lo chiamiamo proprio come una funzione. Questo crea un nuovo oggetto e poi lo restituisce. Quindi possiamo memorizzare quell'oggetto in una variabile. Lascia che ti mostri:
Qui abbiamo definito un “punto1” che è un punto tridimensionale. Puoi vedere che possiamo stampare le singole coordinate sul terminale.
Possiamo usare i due metodi "disegna" e "sposta" con questo punto.
Quindi, per ricapitolare, utilizziamo le classi per definire nuovi tipi e questi tipi possono avere metodi che definiamo nel corpo della classe. Le classi possono avere attributi che possiamo impostare ovunque nei nostri programmi.
Costruttori
Finora, abbiamo imparato come creare nuovi tipi usando le classi. Ora c'è un piccolo problema con questa implementazione. Possiamo creare un oggetto punto senza una coordinata x o y usando le classi e questo non è l'ideale. Lascia che ti mostri.
Creiamo un punto e lo stampiamo prima di impostare la coordinata x. L'esecuzione del nostro programma provoca un errore di attributo come questo:
Significa che l'oggetto punto non ha alcun attributo chiamato x. Ora il problema è che è possibile avere un oggetto punto senza coordinate x o y. Questo non ha senso perché ogni volta che parliamo di un punto, dobbiamo sapere dove si trova quel punto. Per risolvere questo problema, utilizziamo un costruttore. Un costruttore è una funzione che viene chiamata al momento della creazione di un oggetto.
Ecco come utilizziamo un costruttore. Per prima cosa, passiamo i valori delle coordinate xey nel programma sopra.
point = Point(10, 20)
print(point.x)
Ora, abbiamo bisogno di aggiungere un metodo speciale in questa classe chiamato costruttore. La sua sintassi è questa:
def __init__(self, x, y):
init
è l'abbreviazione di initialized e questa è la funzione o il metodo che viene chiamato quando viene creato un nuovo oggetto punto. Le x e le y vengono aggiunte subito dopo self
per aggiungere due parametri extra.
Dopodiché, dovremmo mappare xey sui valori passati, ovvero 10 e 20
self.x = x
self.y = y
Usiamo il self
per fare riferimento all'oggetto corrente e quindi impostiamo l'attributo x sull'argomento x passato alla funzione “x”. In questo modo, utilizzando init
metodo, possiamo inizializzare i nostri oggetti. Questo metodo è denominato costruttore. Eseguiamo il nostro programma.
Ora possiamo cambiare le coordinate xey in seguito. Aggiorniamo la coordinata x:
point = Point(10, 20)
point.x = 11
print(point.x)
Ora, la coordinata x viene aggiornata al valore 11.
Esercitare
Ecco un esercizio interessante per te.
Voglio che tu definisca un nuovo tipo chiamato persona. Questi oggetti "Persona" dovrebbero avere un "name
” e un “talk()
" metodo.
È un compito semplice e non dovrebbe richiedere più di un paio di minuti.
Soluzione
Inizia con la definizione della classe "Persona" in questo modo:
class Person:
self.name = name
Definiremo il costruttore in seguito. Ora possiamo creare l'oggetto "Persona". Chiamiamolo Giovanni
john = Person("John Smith")
print(john.name)
john.talk()
Ora vai alla prima parte del codice e crea un costruttore.
def __init__(self, name):
Il codice finale sarà simile a questo:
Puoi anche usare stringhe formattate e altri concetti insieme a classi e costruttori.
Eredità
L'ereditarietà è un altro concetto associato alle classi che consentono di riutilizzare un codice.
Considera questo pezzo di codice.
class Dog:
def walk(self):
print("walk")
Abbiamo creato una classe “Dog” con un metodo “walk”. In questo metodo, stiamo semplicemente stampando il messaggio di camminata sul terminale. Diciamo che, in un programma reale, ci sono 10 righe di codice invece di una sola riga qui. In futuro, se è necessaria un'altra classe per avere il metodo "walk", dovremo ripetere tutto quel codice. Questo non è l'ideale.
Nella programmazione, abbiamo un principio chiamato DRY che è l'abbreviazione di non ripetere. Diciamo che in futuro scopriamo un problema con il nostro metodo "cammina" e se abbiamo ripetuto o duplicato questo metodo in molti altri posti, dovremo tornare e risolvere quel problema in ogni singolo posto in cui lo abbiamo duplicato codice. Ecco perché nella programmazione non dovremmo definire qualcosa due volte.
Esistono diversi approcci per porre rimedio a questo problema, ma qui impareremo quello che è più facile per i principianti e si chiama ereditarietà. In questo caso, creeremo un'altra classe "mammifero" e definiremo il nostro attributo "camminata" in quella classe.
class Mammal:
def walk(self):
print("walk")
Dopo aver definito la nostra classe "Mammifero" possiamo usare l'ereditarietà per passare gli attributi in questo modo:
Entrambe le classi cane e gatto ereditano tutti i metodi di classe definiti nella loro classe padre. Ora possiamo aggiungere metodi specifici per cani come questo:
class Dog:
def bark(self):
print("bark")
Incartare!
Si trattava di classi, costruttori e riutilizzo del codice in classi con concetti di ereditarietà. Ora ci stiamo avvicinando alla fine della nostra serie. A questo punto, dovresti essere in grado di produrre codici buoni, leggibili e concisi in Python.
Vedremo il concetto di moduli e pacchetti nella prossima lezione.
Lascia un Commento