Vérification des types

9.1 Fonction type()

En Python, il existe plusieurs fonctions intégrées pour vérifier les types et les classes d'objets. Ces fonctions sont utiles pour écrire du code flexible et sécurisé, capable de fonctionner avec différents types de données.

Ci-dessous, je vais te parler des plus populaires d'entre elles : type(), isinstance(), issubclass(), ainsi que des fonctions pour l'annotation des types, telles que getattr() et hasattr().

Fonction type()

La fonction type() renvoie le type d'un objet. Tu as déjà travaillé avec, n'est-ce pas ?

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

Mais ce que tu ne sais peut-être pas, c'est qu'elle permet aussi de créer de nouvelles classes !

Création d'une nouvelle classe

Si tu lui passes trois arguments, elle créera un nouveau type (classe).

La signature de cette opération :

type(name, bases, dict)

où :

• name — le nom de la classe créée (chaîne).
• bases — tuple des classes de base (parents), dont la nouvelle classe hérite.
• dict — dictionnaire contenant les attributs et méthodes de la nouvelle classe.

Création d'une classe simple :

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

# Créons une instance de la classe
instance = MyClass()
instance.say_hello()  # Output: Hello!

On peut même créer quelque chose de plus compliqué :

MyClass = type('MyClass', (), {
    'attribute': 42,
    '__init__': lambda self, value: setattr(self, 'value', value),
    'display_value': lambda self: print(self.value)
})
            
# Créons une instance de la classe
instance = MyClass(10)
print(instance.attribute)  # Output: 42
instance.display_value()  # Output: 10

Ainsi, tu peux non seulement définir le type d'un objet, mais aussi créer une classe, lui fabriquer des objets, puis déterminer leurs types.

9.2 Fonction isinstance()

Fonction isinstance() est une fonction intégrée en Python, utilisée pour vérifier si un objet appartient à une classe spécifique ou à un tuple de classes. Elle retourne True si l'objet est une instance de la classe spécifiée ou de n'importe laquelle des classes spécifiées dans le tuple, et False sinon.

Signature et paramètres :

isinstance(object, classinfo)

où :

• object — l'objet dont l'appartenance à une classe ou à des classes doit être vérifiée.
• classinfo — une classe, un type ou un tuple de classes et de types auxquels l'objet sera comparé.

Exemples d'utilisation :

Vérification d'appartenance à une seule classe

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

Vérification d'appartenance à plusieurs classes — au moins l'une d'elles :

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

Vérification d'appartenance à des classes personnalisées

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

Contrairement à la comparaison directe des types avec type(), isinstance() fonctionne correctement avec l'héritage, vérifiant l'appartenance d'un objet à n'importe quelle classe dans la hiérarchie.

9.3 Fonction issubclass()

Fonction issubclass() est une fonction intégrée en Python, utilisée pour vérifier si une classe spécifiée est un sous-classe d'une autre classe ou de n'importe quelle classe dans un tuple. Cette fonction retourne True si le premier argument est effectivement un sous-classe du second, et False sinon.

Signature et paramètres :

issubclass(class, classinfo)

où :

• class — la classe dont l'appartenance à une ou plusieurs classes doit être vérifiée.
• classinfo — la classe, le type ou le tuple de classes et de types auxquels sera comparé le premier argument.

Exemples d'utilisation :

Vérification d'appartenance à une seule classe

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

Vérification d'appartenance à plusieurs classes — au moins l'une d'elles :

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

Exemples avec des classes personnalisées

Héritage des classes intégrées

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

Hiérarchie d'héritage

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

Avantages de l'utilisation de issubclass()

Vérification de la hiérarchie des classes : issubclass() permet de vérifier la hiérarchie des classes, ce qui est utile pour assurer la correction de l'héritage et de la structure du code.

Flexibilité : La fonction prend en charge la vérification d'une seule classe ou d'un tuple de classes, ce qui la rend flexible pour une utilisation dans divers scénarios.

Pratique pour la métaprogrammation : issubclass() est souvent utilisée en métaprogrammation et lors de l'écriture de code qui fonctionne avec des types et des classes dynamiques. On en reparlera encore bien plus tard :)