Verifica dei tipi

9.1 La funzione type()

In Python ci sono alcune funzioni integrate per controllare i tipi e le classi degli oggetti. Queste funzioni sono utili per scrivere codice flessibile e sicuro, che può funzionare con vari tipi di dati.

Di seguito ti parlerò delle più popolari: type(), isinstance(), issubclass(), e funzioni per annotazioni di tipi come getattr() e hasattr().

La funzione type()

La funzione type() restituisce il tipo di un oggetto. Ci hai già lavorato, vero?

x = 10
print(type(x))  # Output: <class 'int'>

Ma ecco cosa probabilmente non sai ancora, che puoi usarla per creare nuove classi!

Creare una nuova classe

Se le passi tre argomenti, creerà un nuovo tipo (classe).

La firma di questa operazione:

type(name, bases, dict)

dove:

• name — il nome della classe creata (stringa).
• bases — una tupla di classi base (parenti), da cui la nuova classe eredita.
• dict — un dizionario che contiene attributi e metodi della nuova classe.

Creare una classe semplice:

MyClass = type('MyClass', (), {'say_hello': lambda self: print("Hello!")})

# Creiamo un'istanza della classe
instance = MyClass()
instance.say_hello()  # Output: Hello!

Puoi anche creare qualcosa di più complesso:

MyClass = type('MyClass', (), {
    'attribute': 42,
    '__init__': lambda self, value: setattr(self, 'value', value),
    'display_value': lambda self: print(self.value)
})
            
# Creiamo un'istanza della classe
instance = MyClass(10)
print(instance.attribute)  # Output: 42
instance.display_value()  # Output: 10

Quindi ora puoi non solo definire il tipo di un oggetto, ma anche creare una classe, crearne oggetti e poi definire i loro tipi.

9.2 La funzione isinstance()

La funzione isinstance() è una funzione integrata in Python, usata per verificare la appartenenza di un oggetto a una certa classe o tupla di classi. Restituisce True se l'oggetto è un'istanza della classe specificata o di qualsiasi delle classi specificate nella tupla, e False altrimenti.

Firma e parametri:

isinstance(object, classinfo)

dove:

• object — l'oggetto di cui si vuole verificare la appartenenza alla classe o classi.
• classinfo — la classe, tipo o tupla di classi e tipi contro cui verrà verificato l'oggetto.

Esempi di utilizzo:

Verifica dell'appartenenza a una classe

x = 10
print(isinstance(x, int))  # Output: True
            
y = "Hello"
print(isinstance(y, str))  # Output: True

Verifica dell'appartenenza a più classi — almeno una di queste:

x = 10
print(isinstance(x, (int, float)))  # Output: True
            
y = "Hello"
print(isinstance(y, (int, str)))  # Output: True
            
z = 3.14
print(isinstance(z, (int, str)))  # Output: False

Verifica dell'appartenenza a classi personalizzate

class Animal:
    pass
        
class Dog(Animal):
    pass
        
dog = Dog()
        
print(isinstance(dog, Dog))  # Output: True
print(isinstance(dog, Animal))  # Output: True

A differenza del confronto diretto dei tipi tramite type(), isinstance() funziona correttamente con l'ereditarietà, verificando l'appartenenza di un oggetto a qualsiasi classe nella gerarchia.

9.3 La funzione issubclass()

La funzione issubclass() è una funzione integrata in Python, usata per controllare se una classe specificata è una sottoclasse di un'altra classe o di qualsiasi classe in una tupla. Questa funzione restituisce True se il primo argomento è davvero una sottoclasse del secondo, e False altrimenti.

Firma e parametri:

issubclass(class, classinfo)

dove:

• class — la classe di cui si vuole verificare l'appartenenza alla classe o classi.
• classinfo — la classe, tipo o tupla di classi e tipi contro cui verrà verificato il primo argomento.

Esempi di utilizzo:

Verifica dell'appartenenza a una classe

class Animal:
    pass
         
class Dog(Animal):
    pass
        
print(issubclass(Dog, Animal))  # Output: True
print(issubclass(Animal, Dog))  # Output: False 

Verifica dell'appartenenza a più classi — almeno una di queste:

class Animal:
    pass
        
class Dog(Animal):
    pass
        
class Cat(Animal):
    pass
        
print(issubclass(Dog, (Animal, Cat)))  # Output: True
print(issubclass(Dog, (Cat,)))  # Output: False

Esempi con classi personalizzate

Ereditarietà da classi integrate

class MyInt(int):
    pass
        
print(issubclass(MyInt, int))  # Output: True
print(issubclass(int, MyInt))  # Output: False

Gerarchia di eredità

class A:
    pass
        
class B(A):
    pass
        
class C(B):
    pass
        
print(issubclass(C, A))  # Output: True
print(issubclass(C, B))  # Output: True
print(issubclass(B, A))  # Output: True
print(issubclass(A, C))  # Output: False

Vantaggi dell'uso di issubclass()

Verifica della gerarchia delle classi: issubclass() consente di verificare la gerarchia delle classi, utile per garantire la correttezza dell'ereditarietà e della struttura del codice.

Flessibilità: La funzione supporta la verifica di una classe singola o una tupla di classi, rendendola flessibile per l'uso in diversi scenari.

Comodità per la metaprogrammazione: issubclass() è spesso utilizzata nella metaprogrammazione e quando si scrive codice che lavora con tipi e classi dinamici. Ne parleremo più avanti :)