Comment vérifier si un objet est une instance d'une classe en Python

Introduction

Dans ce laboratoire (lab), vous allez explorer les classes et les instances en Python et apprendre à vérifier si un objet est une instance d'une classe. Vous commencerez par créer une classe Dog avec des attributs de classe et d'instance, puis vous créerez des instances de la classe Dog et accéderez à leurs attributs.

Ensuite, vous apprendrez à utiliser la fonction isinstance() pour la vérification de type et la comparer avec la fonction type() pour des correspondances exactes. Cela vous permettra de déterminer si un objet appartient à une classe spécifique ou à une sous-classe de cette classe, offrant ainsi une compréhension plus approfondie de la programmation orientée objet en Python.

Explorer les classes et les instances

Dans cette étape, vous allez apprendre à propos des classes et des instances en Python. Les classes sont comme des modèles pour créer des objets, et les instances sont les objets réels créés à partir de ces modèles. Comprendre les classes et les instances est fondamental pour la programmation orientée objet en Python.

Tout d'abord, créons une classe simple appelée Dog.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé dog.py dans le répertoire ~/project.
```
~/project/dog.py
```
Ajoutez le code suivant à dog.py :
```
## Define a class called Dog
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age
```
Ici, nous définissons une classe nommée Dog. L'attribut species est un attribut de classe, ce qui signifie qu'il est partagé par toutes les instances de la classe Dog. La méthode __init__ est une méthode spéciale appelée constructeur. Elle est utilisée pour initialiser les attributs d'instance name et age lorsqu'un nouvel objet Dog est créé.

Maintenant, créons des instances de la classe Dog. Ajoutez le code suivant à la fin de dog.py :

## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Access instance attributes
print(f"{buddy.name} is {buddy.age} years old.")
print(f"{miles.name} is {miles.age} years old.")

## Access class attribute
print(f"{buddy.name} is a {buddy.species}.")
print(f"{miles.name} is a {miles.species}.")

Dans cette partie, nous créons deux instances de la classe Dog : buddy et miles. Nous accédons ensuite à leurs attributs d'instance (name et age) et à l'attribut de classe (species) en utilisant la notation par point (.).

Pour exécuter le script dog.py, ouvrez un terminal dans VS Code et exécutez la commande suivante :
```
python dog.py
```
Vous devriez voir la sortie suivante :
```
Buddy is 9 years old.
Miles is 4 years old.
Buddy is a Canis familiaris.
Miles is a Canis familiaris.
```
Cette sortie confirme que vous avez créé avec succès des instances de la classe Dog et accédé à leurs attributs.

Utiliser isinstance() pour la vérification de type

Dans cette étape, vous allez apprendre à utiliser la fonction isinstance() en Python pour vérifier si un objet est une instance d'une classe particulière. C'est un outil utile pour vous assurer que votre code gère correctement différents types d'objets.

En vous appuyant sur la classe Dog de l'étape précédente, créons un nouveau fichier Python pour explorer isinstance().

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé type_check.py dans le répertoire ~/project.
```
~/project/type_check.py
```
Copiez la définition de la classe Dog depuis dog.py dans type_check.py. Votre fichier type_check.py devrait maintenant ressembler à ceci :
```
class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age
```
Maintenant, ajoutons du code pour utiliser la fonction isinstance(). Ajoutez le code suivant à la fin de type_check.py :
```
## Create instances of the Dog class
buddy = Dog("Buddy", 9)
miles = Dog("Miles", 4)

## Check if buddy is an instance of the Dog class
print(isinstance(buddy, Dog))

## Check if miles is an instance of the Dog class
print(isinstance(miles, Dog))

## Check if a string is an instance of the Dog class
print(isinstance("Hello", Dog))
```
Ici, nous créons deux instances de la classe Dog, buddy et miles. Nous utilisons ensuite la fonction isinstance() pour vérifier si ces instances sont de type Dog. Nous vérifions également si une chaîne de caractères "Hello" est une instance de la classe Dog.
Pour exécuter le script type_check.py, ouvrez un terminal dans VS Code et exécutez la commande suivante :
```
python type_check.py
```
Vous devriez voir la sortie suivante :
```
True
True
False
```
La sortie montre que buddy et miles sont effectivement des instances de la classe Dog, tandis que la chaîne de caractères "Hello" ne l'est pas.

Comparer avec type() pour des correspondances exactes

Dans cette étape, vous allez apprendre à utiliser la fonction type() en Python et la comparer avec isinstance() pour la vérification de type. Alors que isinstance() vérifie si un objet est une instance d'une classe ou de ses sous-classes, type() retourne le type exact d'un objet.

Pour illustrer la différence, créons une sous-classe de la classe Dog puis utilisons à la fois isinstance() et type() pour vérifier le type des instances.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Modifiez le fichier type_check.py dans le répertoire ~/project.
```
~/project/type_check.py
```

Ajoutez une nouvelle classe appelée GermanShepherd qui hérite de la classe Dog. Votre fichier type_check.py devrait maintenant ressembler à ceci :

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, age):
        self.name = name
        self.age = age

class GermanShepherd(Dog):
    def __init__(self, name, age, training_level):
        super().__init__(name, age)
        self.training_level = training_level

Ici, GermanShepherd est une sous-classe de Dog. Elle hérite des attributs name et age de la classe Dog et ajoute un nouvel attribut training_level.

Maintenant, ajoutons du code pour utiliser les fonctions isinstance() et type(). Ajoutez le code suivant à la fin de type_check.py :

## Create instances of the Dog and GermanShepherd classes
buddy = Dog("Buddy", 9)
sparky = GermanShepherd("Sparky", 3, "Advanced")

## Check types using isinstance()
print(f"buddy isinstance Dog: {isinstance(buddy, Dog)}")
print(f"sparky isinstance Dog: {isinstance(sparky, Dog)}")
print(f"sparky isinstance GermanShepherd: {isinstance(sparky, GermanShepherd)}")

## Check types using type()
print(f"type(buddy) == Dog: {type(buddy) == Dog}")
print(f"type(sparky) == Dog: {type(sparky) == Dog}")
print(f"type(sparky) == GermanShepherd: {type(sparky) == GermanShepherd}")

Dans cette partie, nous créons une instance de la classe Dog (buddy) et une instance de la classe GermanShepherd (sparky). Nous utilisons ensuite isinstance() et type() pour vérifier leurs types.

Pour exécuter le script type_check.py, ouvrez un terminal dans VS Code et exécutez la commande suivante :
```
python type_check.py
```
Vous devriez voir la sortie suivante :
```
buddy isinstance Dog: True
sparky isinstance Dog: True
sparky isinstance GermanShepherd: True
type(buddy) == Dog: True
type(sparky) == Dog: False
type(sparky) == GermanShepherd: True
```
La sortie montre que isinstance(sparky, Dog) retourne True car sparky est une instance de la classe GermanShepherd, qui est une sous-classe de Dog. Cependant, type(sparky) == Dog retourne False car type(sparky) retourne le type exact, qui est GermanShepherd, et non Dog.

Résumé

Dans ce laboratoire (lab), vous avez exploré les bases des classes et des instances en Python. Vous avez appris à définir une classe, y compris les attributs de classe et les attributs d'instance initialisés dans le constructeur __init__.

Vous avez ensuite créé des instances de la classe Dog, en assignant des valeurs à leurs attributs spécifiques. Enfin, vous avez accédé à la fois aux attributs d'instance (nom, âge) et à l'attribut de classe (espèce) en utilisant la notation par point, démontrant ainsi comment récupérer les informations associées aux objets et à leurs classes.