La fonction isinstance() en Python

Contenu du cours

Introduction à isinstance() - Syntaxe et principe de base
Utilisation pratique de isinstance() pour la validation de données
isinstance() et l'héritage de classes
Usage avancé de la fonction isinstance()

Ce tutoriel explique en détail comment utiliser la fonction isinstance() en Python pour vérifier le type d'un objet. Vous apprendrez à l'utiliser pour valider des données, gérer l'héritage de classes et écrire du code plus robuste.

1. Introduction à isinstance() - Syntaxe et principe de base

La fonction isinstance() permet de vérifier si un objet est une instance d'une classe spécifique ou d'un type donné. Elle retourne True si l'objet est du type spécifié, sinon False. Sa syntaxe est : isinstance(objet, type).

# Syntaxe de base de isinstance()
nombre = 42
chaine = "Bonjour"
liste = [1, 2, 3]

# Vérifications simples
print("Est-ce que 'nombre' est un int?", isinstance(nombre, int))
print("Est-ce que 'chaine' est un str?", isinstance(chaine, str))
print("Est-ce que 'liste' est une list?", isinstance(liste, list))
print("Est-ce que 'nombre' est un str?", isinstance(nombre, str))

# Vérification avec plusieurs types (tuple de types)
print("\nEst-ce que 'nombre' est un int ou float?", isinstance(nombre, (int, float)))
print("Est-ce que 'chaine' est un str ou list?", isinstance(chaine, (str, list)))

# Sortie attendue :
# Est-ce que 'nombre' est un int? True
# Est-ce que 'chaine' est un str? True
# Est-ce que 'liste' est une list? True
# Est-ce que 'nombre' est un str? False
# 
# Est-ce que 'nombre' est un int ou float? True
# Est-ce que 'chaine' est un str ou list? True

# Syntaxe de base de isinstance()

nombre = 42

chaine = "Bonjour"

liste = [1, 2, 3]

# Vérifications simples

print("Est-ce que 'nombre' est un int?", isinstance(nombre, int))

print("Est-ce que 'chaine' est un str?", isinstance(chaine, str))

print("Est-ce que 'liste' est une list?", isinstance(liste, list))

print("Est-ce que 'nombre' est un str?", isinstance(nombre, str))

# Vérification avec plusieurs types (tuple de types)

print("\nEst-ce que 'nombre' est un int ou float?", isinstance(nombre, (int, float)))

print("Est-ce que 'chaine' est un str ou list?", isinstance(chaine, (str, list)))

# Sortie attendue :

# Est-ce que 'nombre' est un int? True

# Est-ce que 'chaine' est un str? True

# Est-ce que 'liste' est une list? True

# Est-ce que 'nombre' est un str? False

# Est-ce que 'nombre' est un int ou float? True

# Est-ce que 'chaine' est un str ou list? True

2. Utilisation pratique de isinstance() pour la validation de données

isinstance() est particulièrement utile pour valider les paramètres d'une fonction et s'assurer qu'ils sont du type attendu, évitant ainsi des erreurs d'exécution.

2.1 Validation de paramètres dans une fonction

def calculer_moyenne(nombres):
    """
    Calcule la moyenne d'une liste de nombres.
    Valide que l'argument est bien une liste.
    """
    if not isinstance(nombres, list):
        raise TypeError("L'argument doit être une liste")
    
    if not nombres:
        return 0
    
    # Vérification supplémentaire que tous les éléments sont numériques
    for element in nombres:
        if not isinstance(element, (int, float)):
            raise TypeError("Tous les éléments doivent être des nombres")
    
    return sum(nombres) / len(nombres)

# Tests de la fonction
try:
    resultat1 = calculer_moyenne([10, 20, 30, 40])
    print(f"Moyenne 1: {resultat1}")
    
    resultat2 = calculer_moyenne((10, 20, 30))  # Tuple au lieu de liste
    print(f"Moyenne 2: {resultat2}")
except TypeError as e:
    print(f"Erreur: {e}")

# Test avec type incorrect
try:
    resultat3 = calculer_moyenne([10, "vingt", 30])  # Chaîne dans la liste
    print(f"Moyenne 3: {resultat3}")
except TypeError as e:
    print(f"Erreur: {e}")

# Test avec autre type
try:
    resultat4 = calculer_moyenne("10,20,30")  # Chaîne au lieu de liste
    print(f"Moyenne 4: {resultat4}")
except TypeError as e:
    print(f"Erreur: {e}")

# Sortie attendue :
# Moyenne 1: 25.0
# Erreur: L'argument doit être une liste
# Erreur: Tous les éléments doivent être des nombres
# Erreur: L'argument doit être une liste

def calculer_moyenne(nombres):

"""

Calcule la moyenne d'une liste de nombres.

Valide que l'argument est bien une liste.

"""

if not isinstance(nombres, list):

raise TypeError("L'argument doit être une liste")

if not nombres:

return 0

# Vérification supplémentaire que tous les éléments sont numériques

for element in nombres:

if not isinstance(element, (int, float)):

raise TypeError("Tous les éléments doivent être des nombres")

return sum(nombres) / len(nombres)

# Tests de la fonction

try:

resultat1 = calculer_moyenne([10, 20, 30, 40])

print(f"Moyenne 1: {resultat1}")

resultat2 = calculer_moyenne((10, 20, 30)) # Tuple au lieu de liste

print(f"Moyenne 2: {resultat2}")

except TypeError as e:

print(f"Erreur: {e}")

# Test avec type incorrect

try:

resultat3 = calculer_moyenne([10, "vingt", 30]) # Chaîne dans la liste

print(f"Moyenne 3: {resultat3}")

except TypeError as e:

print(f"Erreur: {e}")

# Test avec autre type

try:

resultat4 = calculer_moyenne("10,20,30") # Chaîne au lieu de liste

print(f"Moyenne 4: {resultat4}")

except TypeError as e:

print(f"Erreur: {e}")

# Sortie attendue :

# Moyenne 1: 25.0

# Erreur: L'argument doit être une liste

# Erreur: Tous les éléments doivent être des nombres

# Erreur: L'argument doit être une liste

2.2 Traitement conditionnel basé sur le type

def formater_donnee(donnee):
    """
    Formate une donnée différemment selon son type.
    Utilise isinstance() pour déterminer le traitement approprié.
    """
    if isinstance(donnee, str):
        return f"Chaîne: '{donnee.upper()}'"
    
    elif isinstance(donnee, (int, float)):
        return f"Nombre: {donnee * 2}"
    
    elif isinstance(donnee, list):
        return f"Liste [{len(donnee)} éléments]: {donnee}"
    
    elif isinstance(donnee, dict):
        return f"Dictionnaire avec clés: {list(donnee.keys())}"
    
    else:
        return f"Type non géré: {type(donnee)}"

# Tests avec différents types
donnees_test = [
    "python",
    42,
    3.14,
    [1, 2, 3, 4],
    {"nom": "Alice", "age": 30},
    True,  # bool
    None   # NoneType
]

for donnee in donnees_test:
    resultat = formater_donnee(donnee)
    print(resultat)

# Sortie attendue :
# Chaîne: 'PYTHON'
# Nombre: 84
# Nombre: 6.28
# Liste [4 éléments]: [1, 2, 3, 4]
# Dictionnaire avec clés: ['nom', 'age']
# Type non géré: <class 'bool'>
# Type non géré: <class 'NoneType'>

def formater_donnee(donnee):

"""

Formate une donnée différemment selon son type.

Utilise isinstance() pour déterminer le traitement approprié.

"""

if isinstance(donnee, str):

return f"Chaîne: '{donnee.upper()}'"

elif isinstance(donnee, (int, float)):

return f"Nombre: {donnee * 2}"

elif isinstance(donnee, list):

return f"Liste [{len(donnee)} éléments]: {donnee}"

elif isinstance(donnee, dict):

return f"Dictionnaire avec clés: {list(donnee.keys())}"

else:

return f"Type non géré: {type(donnee)}"

# Tests avec différents types

donnees_test = [

"python",

42,

3.14,

[1, 2, 3, 4],

{"nom": "Alice", "age": 30},

True, # bool

None # NoneType

]

for donnee in donnees_test:

resultat = formater_donnee(donnee)

print(resultat)

# Sortie attendue :

# Chaîne: 'PYTHON'

# Nombre: 84

# Nombre: 6.28

# Liste [4 éléments]: [1, 2, 3, 4]

# Dictionnaire avec clés: ['nom', 'age']

# Type non géré: <class 'bool'>

# Type non géré: <class 'NoneType'>

3. isinstance() et l'héritage de classes

Contrairement à type() qui vérifie l'égalité exacte des types, isinstance() prend en compte l'héritage. Elle retourne True si l'objet est une instance de la classe spécifiée ou d'une de ses sous-classes.

# Définition d'une hiérarchie de classes
class Animal:
    def __init__(self, nom):
        self.nom = nom
    
    def parler(self):
        return "???"

class Chien(Animal):
    def parler(self):
        return "Woof!"

class Chat(Animal):
    def parler(self):
        return "Miaou!"

class ChienDeRace(Chien):
    def __init__(self, nom, race):
        super().__init__(nom)
        self.race = race

# Création d'instances
animal = Animal("Générique")
rex = Chien("Rex")
felix = Chat("Félix")
buddy = ChienDeRace("Buddy", "Labrador")

# Tests avec isinstance()
print("=== Tests d'instance ===")
print(f"rex est-il un Chien? {isinstance(rex, Chien)}")
print(f"rex est-il un Animal? {isinstance(rex, Animal)}")
print(f"rex est-il un Chat? {isinstance(rex, Chat)}")
print()

print(f"buddy est-il un ChienDeRace? {isinstance(buddy, ChienDeRace)}")
print(f"buddy est-il un Chien? {isinstance(buddy, Chien)}")
print(f"buddy est-il un Animal? {isinstance(buddy, Animal)}")
print(f"buddy est-il un Chat? {isinstance(buddy, Chat)}")
print()

# Comparaison avec type()
print("=== Comparaison avec type() ===")
print(f"type(rex) == Chien? {type(rex) == Chien}")
print(f"type(rex) == Animal? {type(rex) == Animal}")  # False avec type()
print(f"isinstance(rex, Animal)? {isinstance(rex, Animal)}")  # True avec isinstance

# Vérification avec tuple de classes
print("\n=== Vérification multiple ===")
print(f"felix est-il un Chien ou Chat? {isinstance(felix, (Chien, Chat))}")
print(f"buddy est-il un Animal ou Chat? {isinstance(buddy, (Animal, Chat))}")

# Sortie attendue :
# === Tests d'instance ===
# rex est-il un Chien? True
# rex est-il un Animal? True
# rex est-il un Chat? False
# 
# buddy est-il un ChienDeRace? True
# buddy est-il un Chien? True
# buddy est-il un Animal? True
# buddy est-il un Chat? False
# 
# === Comparaison avec type() ===
# type(rex) == Chien? True
# type(rex) == Animal? False
# isinstance(rex, Animal)? True
# 
# === Vérification multiple ===
# felix est-il un Chien ou Chat? True
# buddy est-il un Animal ou Chat? True

# Définition d'une hiérarchie de classes

class Animal:

def __init__(self, nom):

self.nom = nom

def parler(self):

return "???"

class Chien(Animal):

def parler(self):

return "Woof!"

class Chat(Animal):

def parler(self):

return "Miaou!"

class ChienDeRace(Chien):

def __init__(self, nom, race):

super().__init__(nom)

self.race = race

# Création d'instances

animal = Animal("Générique")

rex = Chien("Rex")

felix = Chat("Félix")

buddy = ChienDeRace("Buddy", "Labrador")

# Tests avec isinstance()

print("=== Tests d'instance ===")

print(f"rex est-il un Chien? {isinstance(rex, Chien)}")

print(f"rex est-il un Animal? {isinstance(rex, Animal)}")

print(f"rex est-il un Chat? {isinstance(rex, Chat)}")

print()

print(f"buddy est-il un ChienDeRace? {isinstance(buddy, ChienDeRace)}")

print(f"buddy est-il un Chien? {isinstance(buddy, Chien)}")

print(f"buddy est-il un Animal? {isinstance(buddy, Animal)}")

print(f"buddy est-il un Chat? {isinstance(buddy, Chat)}")

print()

# Comparaison avec type()

print("=== Comparaison avec type() ===")

print(f"type(rex) == Chien? {type(rex) == Chien}")

print(f"type(rex) == Animal? {type(rex) == Animal}") # False avec type()

print(f"isinstance(rex, Animal)? {isinstance(rex, Animal)}") # True avec isinstance

# Vérification avec tuple de classes

print("\n=== Vérification multiple ===")

print(f"felix est-il un Chien ou Chat? {isinstance(felix, (Chien, Chat))}")

print(f"buddy est-il un Animal ou Chat? {isinstance(buddy, (Animal, Chat))}")

# Sortie attendue :

# === Tests d'instance ===

# rex est-il un Chien? True

# rex est-il un Animal? True

# rex est-il un Chat? False

# buddy est-il un ChienDeRace? True

# buddy est-il un Chien? True

# buddy est-il un Animal? True

# buddy est-il un Chat? False

# === Comparaison avec type() ===

# type(rex) == Chien? True

# type(rex) == Animal? False

# isinstance(rex, Animal)? True

# === Vérification multiple ===

# felix est-il un Chien ou Chat? True

# buddy est-il un Animal ou Chat? True

4. Usage avancé de la fonction isinstance()

Cette section présente des cas d'usage avancés de isinstance() et les bonnes pratiques associées pour écrire du code Pythonique.

# Exemple 1: Vérification de types avec les classes de base abstraites (ABC)
from collections.abc import Iterable, Sequence, Mapping

def traiter_structure(structure):
    """Traite différentes structures de données de manière générique."""
    
    if isinstance(structure, str):
        print(f"Chaîne de caractères: {structure[:20]}...")
    
    elif isinstance(structure, Sequence):
        print(f"Séquence de {len(structure)} éléments")
        if len(structure) > 0:
            print(f"Premier élément: {structure[0]}")
    
    elif isinstance(structure, Mapping):
        print(f"Dictionnaire avec {len(structure)} paires clé-valeur")
        if structure:
            premiere_cle = next(iter(structure))
            print(f"Première clé: {premiere_cle}")
    
    elif isinstance(structure, Iterable):
        print(f"Itérable (non-séquence)")
        compteur = 0
        for _ in structure:
            compteur += 1
            if compteur > 3:
                break
        print(f"Au moins {min(compteur, 3)} éléments")
    
    else:
        print(f"Type non itérable: {type(structure)}")

# Tests
print("=== Tests avec différentes structures ===")
traiter_structure("Une longue chaîne de caractères")
traiter_structure([1, 2, 3, 4, 5])
traiter_structure({"a": 1, "b": 2, "c": 3})
traiter_structure((x for x in range(10)))  # générateur
traiter_structure(42)  # int non itérable

# Exemple 2: Gestion des types numériques complexes
import numbers

def est_nombre(val):
    """Vérifie si une valeur est un nombre (y compris complexe)."""
    return isinstance(val, numbers.Number)

print("\n=== Tests de détection de nombres ===")
print(f"42 est un nombre? {est_nombre(42)}")
print(f"3.14 est un nombre? {est_nombre(3.14)}")
print(f"2+3j est un nombre? {est_nombre(2+3j)}")
print(f"'123' est un nombre? {est_nombre('123')}")
print(f"True est un nombre? {est_nombre(True)}")  # bool est une sous-classe de int

# Exemple 3: Bonne pratique - Éviter la sur-utilisation
def additionner(a, b):
    """
    Bonne pratique: Duck typing plutôt que vérification stricte.
    On essaie d'abord, on gère l'exception si ça échoue.
    """
    try:
        return a + b
    except TypeError:
        # Fallback avec vérification plus précise si nécessaire
        if isinstance(a, str) or isinstance(b, str):
            return str(a) + str(b)
        raise

print("\n=== Tests d'addition avec duck typing ===")
print(f"5 + 3 = {additionner(5, 3)}")
print(f"'Bon' + 'jour' = {additionner('Bon', 'jour')}")
print(f"'Nombre: ' + 42 = {additionner('Nombre: ', 42)}")

# Sortie attendue :
# === Tests avec différentes structures ===
# Chaîne de caractères: Une longue chaîne de...
# Séquence de 5 éléments
# Premier élément: 1
# Dictionnaire avec 3 paires clé-valeur
# Première clé: a
# Itérable (non-séquence)
# Au moins 3 éléments
# Type non itérable: <class 'int'>
# 
# === Tests de détection de nombres ===
# 42 est un nombre? True
# 3.14 est un nombre? True
# 2+3j est un nombre? True
# '123' est un nombre? False
# True est un nombre? True
# 
# === Tests d'addition avec duck typing ===
# 5 + 3 = 8
# 'Bon' + 'jour' = Bonjour
# 'Nombre: ' + 42 = Nombre: 42

# Exemple 1: Vérification de types avec les classes de base abstraites (ABC)

from collections.abc import Iterable, Sequence, Mapping

def traiter_structure(structure):

"""Traite différentes structures de données de manière générique."""

if isinstance(structure, str):

print(f"Chaîne de caractères: {structure[:20]}...")

elif isinstance(structure, Sequence):

print(f"Séquence de {len(structure)} éléments")

if len(structure) > 0:

print(f"Premier élément: {structure[0]}")

elif isinstance(structure, Mapping):

print(f"Dictionnaire avec {len(structure)} paires clé-valeur")

if structure:

premiere_cle = next(iter(structure))

print(f"Première clé: {premiere_cle}")

elif isinstance(structure, Iterable):

print(f"Itérable (non-séquence)")

compteur = 0

for _ in structure:

compteur += 1

if compteur > 3:

break

print(f"Au moins {min(compteur, 3)} éléments")

else:

print(f"Type non itérable: {type(structure)}")

# Tests

print("=== Tests avec différentes structures ===")

traiter_structure("Une longue chaîne de caractères")

traiter_structure([1, 2, 3, 4, 5])

traiter_structure({"a": 1, "b": 2, "c": 3})

traiter_structure((x for x in range(10))) # générateur

traiter_structure(42) # int non itérable

# Exemple 2: Gestion des types numériques complexes

import numbers

def est_nombre(val):

"""Vérifie si une valeur est un nombre (y compris complexe)."""

return isinstance(val, numbers.Number)

print("\n=== Tests de détection de nombres ===")

print(f"42 est un nombre? {est_nombre(42)}")

print(f"3.14 est un nombre? {est_nombre(3.14)}")

print(f"2+3j est un nombre? {est_nombre(2+3j)}")

print(f"'123' est un nombre? {est_nombre('123')}")

print(f"True est un nombre? {est_nombre(True)}") # bool est une sous-classe de int

# Exemple 3: Bonne pratique - Éviter la sur-utilisation

def additionner(a, b):

"""

Bonne pratique: Duck typing plutôt que vérification stricte.

On essaie d'abord, on gère l'exception si ça échoue.

"""

try:

return a + b

except TypeError:

# Fallback avec vérification plus précise si nécessaire

if isinstance(a, str) or isinstance(b, str):

return str(a) + str(b)

raise

print("\n=== Tests d'addition avec duck typing ===")

print(f"5 + 3 = {additionner(5, 3)}")

print(f"'Bon' + 'jour' = {additionner('Bon', 'jour')}")

print(f"'Nombre: ' + 42 = {additionner('Nombre: ', 42)}")

# Sortie attendue :

# === Tests avec différentes structures ===

# Chaîne de caractères: Une longue chaîne de...

# Séquence de 5 éléments

# Premier élément: 1

# Dictionnaire avec 3 paires clé-valeur

# Première clé: a

# Itérable (non-séquence)

# Au moins 3 éléments

# Type non itérable: <class 'int'>

# === Tests de détection de nombres ===

# 42 est un nombre? True

# 3.14 est un nombre? True

# 2+3j est un nombre? True

# '123' est un nombre? False

# True est un nombre? True

# === Tests d'addition avec duck typing ===

# 5 + 3 = 8

# 'Bon' + 'jour' = Bonjour

# 'Nombre: ' + 42 = Nombre: 42

Younes Derfoufi
CRMEF OUJDA

Post Views: 52

La fonction isinstance() en Python

1. Introduction à isinstance() - Syntaxe et principe de base

2. Utilisation pratique de isinstance() pour la validation de données

2.1 Validation de paramètres dans une fonction

2.2 Traitement conditionnel basé sur le type

3. isinstance() et l'héritage de classes

4. Usage avancé de la fonction isinstance()

Coolid Mini Vidéoprojecteur Portable 4K/1080P - App Intégrée, WiFi 6, Bluetooth 5.4, Rotation 270°

Norton 360 Deluxe 2026 | Antivirus IA + VPN + Contrôle Parental | Licence 5 Appareils 1 An

Vidéoprojecteur Android Portable 1080P/4K avec WiFi 6 et Télécommande Souris - Système Android TV Intégré

Leave a Reply Cancel reply

Epson Imprimante Multifonction jet d'encre EcoTank ET-2856 - avec Réservoirs d'Encre (3 ans d'encre inclus)

Routeur Tenda avec Carte SIM 4G09 AC1200 Bi- bandd 4G + Cat6 300Mbps, Connectivité Jusqu'à 64 Appareils

Dell Latitude 7430 Reconditionné - Portable Pro 14" i7-1265U, 16 Go RAM, 512 Go SSD, Win 11 Pro