Tutorial sul controllo dei tipi in Python

L'Interpreter stesso di Python aiuta nel controllo dei tipi. Poiché Python è un linguaggio dinamico, non obbliga l'utente a imporre il tipo degli oggetti, il che può portare a bug e rende gli errori difficili da trovare. Per ovviare a questo, Python può essere usato insieme a vari altri strumenti e implementare funzionalità di controllo statico dei tipi insieme al suo Duck Typing.

Esistono due tipi diversi di sistemi di tipi adottati da vari linguaggi di programmazione, mostrati qui sotto.

1. Linguaggi a tipizzazione statica
2. Linguaggi a tipizzazione dinamica

Linguaggi a tipizzazione statica

Il controllo del tipo della variabile avviene in fase di compilazione. Inoltre, il sistema di tipi del linguaggio impone di dichiarare esplicitamente il "tipo di dato" della variabile prima del suo utilizzo. I linguaggi di programmazione con tipizzazione statica includono: Scala, Java, C++, ecc.
Per esempio, la dichiarazione di una String in Scala è definita di seguito:
var myCar:String = "Mercedes";
Il codice sopra mostra che la variabile 'myCar' è dichiarata esplicitamente come tipo di dato 'String' con valore 'Mercedes'.

Linguaggi a tipizzazione dinamica

Il controllo del tipo della variabile avviene a runtime. Inoltre, il sistema di tipi del linguaggio non impone di dichiarare esplicitamente il "tipo di dato" della variabile prima del suo utilizzo. I linguaggi di programmazione con tipizzazione dinamica includono: Python, Javascript, Ruby, ecc.
Per esempio, la String in Python è definita di seguito:
myCar = "Mercedes"
Il codice sopra mostra che la variabile 'myCar' non ha bisogno di essere dichiarata esplicitamente.

"type()" e "isinstance()" in Python

I tipi delle variabili possono essere conosciuti usando la funzione "type()" di Python. "type()" può essere usata a runtime per scopi di debug per identificare i tipi esatti delle variabili nel programma. Vediamo il tipo di alcune variabili nell'esempio qui sotto.

my_var = 12
print(type(my_var))
Offerto da

Il codice sopra restituirà come output 'int'. Poiché il tipo di dato della variabile è intero, "type()" serve a identificarlo.

La funzione "insinstance('obj','class')" di Python può essere usata per sapere se 'obj', cioè l'oggetto, è istanza della classe oppure no. Il valore restituito è booleano e può essere True o False.

my_var = "Hello"
print(isinstance(my_var,str))
Offerto da

Il codice sopra restituirà come output True. Poiché il tipo di dato della variabile è una stringa, "isinstance()" serve a identificarlo.

Duck typing in Python

C'è un principio famoso in Python: "Se sembra un'anatra, nuota come un'anatra e starnazza come un'anatra, allora probabilmente è un'anatra." In sostanza il principio dice che i tipi dell'oggetto o della classe non contano: se l'oggetto contiene metodi e proprietà simili, allora può essere usato per uno scopo particolare.
Vediamo un esempio per chiarire meglio l'affermazione sopra.

Considera l'esempio seguente, in cui ci sono due classi 'Duck' e 'Human'. Duck è una classe che contiene i metodi quack e fly. Allo stesso modo, Human è una classe con la propria serie di metodi 'quack' e 'fly'. Duck e Human sono classi diverse e anche oggetti o tipi diversi. Tuttavia, Human contiene metodi simili a 'fly' e 'quack' presenti in Duck. C'è anche una funzione 'fly_quack', che assomiglia per lo più a 'Duck' più che a 'Human' perché può volare e starnazzare.

class Duck:
    def quack(self):
        print('Quack')
    def fly(self):
        print('Flap')
class Human:
    def quack(self):
        print('Trying to Quack like a duck')
    def fly(self):
        print('Spreading my arm to flap like a duck')      
def fly_quack(thing):
    thing.quack()
    thing.fly()
Offerto da

Creiamo un'istanza di 'Duck' come du e passiamola alla funzione 'fly_quack(du)'. Allo stesso modo, per Human si crea l'istanza 'h' e la si passa alla funzione 'fly_quack(h)'.

du = Duck()
fly_quack(du)
h = Human()
fly_quack(h)
Offerto da

L'output del codice sopra è il seguente:

Trying to Quack like a duck
Spreading my arm to flap like a duck
Quack
Flap
Offerto da

Anche se la classe 'Human' è diversa da 'Duck', Python chiama comunque la funzione 'fly_quack' anche per l'umano. Pur essendo diversi i tipi di oggetto, poiché 'Human' ha metodi simili a quack e fly, si comporta e fornisce i metodi richiesti.

Type hint e mypy

C'è un aspetto potente dei linguaggi a tipizzazione dinamica come Python, che aiuta il codice a essere accessibile e leggibile, ma esistono anche degli svantaggi. Uno di questi è individuare gli errori a runtime, perché Python non impone il tipo della variabile, essendo un linguaggio dinamico. Il risultato può essere la produzione di errori e bug, difficili da trovare quando il codice diventa sempre più lungo.

Python ha introdotto i Type Hint dalla versione 3.5. Le versioni precedenti potrebbero non supportare la funzionalità dei Type Hint.

Vedrai un semplice esempio senza type hinting e mypy.

La funzione seguente serve per la sottrazione di un valore intero: sottrae due interi e restituisce il valore.

def sub_this(x,y):
    return 'Subtraction'
print(sub_this(8,'hello'))
Offerto da

Qui la funzione sopra dovrebbe accettare due interi 'x' e 'y', ma poiché le regole non sono imposte, può accettare qualsiasi tipo di dato. Inoltre, il valore di ritorno può essere qualsiasi cosa: viene restituita una 'str' ('Subtraction'), mentre ci si aspettava un 'int'.

Vediamo un'implementazione simile del programma sopra, ma usando i type hint e 'mypy', che possono aiutare a implementare il controllo statico dei tipi e ridurre errori e bug nel programma con facilità.

'mypy' è un modulo Python che aiuta nel controllo statico dei tipi, sfruttando il controllo dinamico di Python, ovvero il duck typing, insieme ai type hint.

Devi installare il pacchetto 'mypy'
pip install mypy

Puoi creare un file chiamato 'mypy_example.py' sulla tua macchina locale e scrivere il codice seguente.
Il codice qui sotto è un semplice programma che accetta due interi come input nei parametri e, dopo '->', mostra il tipo di dato restituito, che è anch'esso un 'int'. Tuttavia, la funzione dovrebbe restituire un int, ma viene restituita la stringa 'Subtracted two integers'.

def sub_this(x:int,y:int) -> int:
    return 'Subtracted two integers'
print(sub_this(8,4))
Offerto da

Esegui il codice sopra nel terminale con il seguente comando.

mypy mypy_example.pyOfferto da

Verrà quindi mostrato l'errore, che indica che è stato trovato un valore di ritorno imprevisto "str" e che deve essere corretto con "int".

Cambiamo il valore di ritorno in modo che sia la sottrazione dei due interi, così da restituire un valore intero.

def sub_this(x:int,y:int) -> int:
    return x - y
print(sub_this(8,4))
Offerto da

I risultati sopra mostrano che viene stampato il messaggio di successo e non sono stati riscontrati problemi.

Congratulazioni

Congratulazioni, sei arrivato alla fine di questo tutorial!

In questo tutorial hai imparato il controllo dei tipi, le diverse tipologie di sistemi di tipi nei vari linguaggi con i metodi di Python ("type()" e "isinstance()"), insieme al duck typing in Python e ai type hint combinati con 'mypy'.

Se vuoi saperne di più su Python, segui il corso di DataCamp Software Engineering for Data Scientists in Python.

Riferimenti:

1. Video di Corey su YouTube: Duck Typing