constructeur et destructeur en Python

Constructeur — __init__

Les constructeurs sont utilisés pour instancier un objet. Leur rôle est d'initialiser les attributs de la classe au moment de la création de l'objet. En Python, cette tâche est assurée par la méthode spéciale __init__(), appelée automatiquement dès qu'un objet est créé.

def __init__(self, liste_parametres):
    self.attribut = valeur   # initialisation des attributs

Types de constructeurs

Exemple — Constructeur par défaut

class Personne:
    def __init__(self):
        self.nom    = "Inconnu"
        self.prenom = "Inconnu"

    def afficher(self):
        print(f"Nom : {self.nom} | Prénom : {self.prenom}")

p = Personne()
p.afficher()

Nom : Inconnu | Prénom : Inconnu

Exemple — Constructeur paramétré

class Personne:
    def __init__(self, nom, prenom, ville="Meknès"):
        self.nom    = nom
        self.prenom = prenom
        self.ville  = ville

    def afficher(self):
        print(f"Nom : {self.nom} | Prénom : {self.prenom} | Ville : {self.ville}")

p1 = Personne('ESSADDOUKI', 'Mostafa')
p2 = Personne('Kayouh', 'Mohamed', 'Rabat')

p1.afficher()
p2.afficher()

Nom : ESSADDOUKI | Prénom : Mostafa  | Ville : Meknès
Nom : Kayouh     | Prénom : Mohamed  | Ville : Rabat

Exemple — Plusieurs constructeurs avec @classmethod

class Personne:
    def __init__(self, nom, prenom):
        self.nom    = nom
        self.prenom = prenom

    @classmethod
    def depuis_chaine(cls, chaine):
        """Constructeur alternatif depuis une chaîne 'NOM Prénom'."""
        nom, prenom = chaine.split()
        return cls(nom, prenom)

p1 = Personne('ESSADDOUKI', 'Mostafa')
p2 = Personne.depuis_chaine('KAYOUH Mohamed')

print(p1.nom, p1.prenom)   # ESSADDOUKI Mostafa
print(p2.nom, p2.prenom)   # KAYOUH Mohamed

Destructeur — __del__

Les destructeurs sont appelés lorsqu'un objet est détruit, c'est-à-dire lorsque toutes ses références sont supprimées et que le ramasse-miettes (garbage collector) libère la mémoire.

def __del__(self):
    # opérations de nettoyage
    ...

Exemple 1 — Destruction explicite avec del

En utilisant le mot-clé del, on supprime toutes les références à l'objet, ce qui déclenche automatiquement l'appel au destructeur.

class Tableau:

    def __init__(self):
        self.donnee = [0] * 100    # tableau de 100 éléments
        print(f"Tableau créé ({len(self.donnee)} éléments)")

    def __del__(self):
        print("Destructeur appelé — tableau vidé")
        self.donnee.clear()

tab = Tableau()
del tab    # supprime la référence → déclenche __del__

Tableau créé (100 éléments)
Destructeur appelé — tableau vidé

Exemple 2 — Le destructeur s'exécute après la fin du programme

Le destructeur est appelé lorsque le nombre de références tombe à zéro, pas nécessairement quand l'objet sort de la portée locale. Dans l'exemple ci-dessous, l'objet est retourné par la fonction et reste référencé dans p1 jusqu'à la fin du programme.

class Personne:

    def __init__(self, nom, prenom):
        self.nom    = nom
        self.prenom = prenom

    def __del__(self):
        print(f"Destructeur appelé pour {self.nom}")

def creation():
    print("Création de l'objet...")
    p = Personne('ESSADDOUKI', 'Mostafa')
    print("Fin de création")
    return p        # l'objet est retourné → toujours référencé

print("Début du programme")
p1 = creation()
print("Fin du programme")
# __del__ est appelé ICI, après la fin de main, quand p1 est libéré

Début du programme
Création de l'objet...
Fin de création
Fin du programme
Destructeur appelé pour ESSADDOUKI

Exemple 3 — Référence circulaire

Une référence circulaire se produit quand deux objets se référencent mutuellement. Le ramasse-miettes Python détecte généralement ce cas, mais un __del__ personnalisé peut perturber ce mécanisme.

class A:
    def __init__(self, b):
        self.b = b          # A référence B

class B:
    def __init__(self):
        self.a = A(self)    # B référence A → référence circulaire

    def __del__(self):
        print("Destructeur de B appelé")

def creation():
    b = B()                 # b sort de portée ici

creation()
print("Fin de creation()")

Destructeur de B appelé
Fin de creation()

class Ressource:
    def __enter__(self):
        print("Ouverture")
        return self

    def __exit__(self, *args):
        print("Fermeture — garanti même en cas d'erreur")

with Ressource() as r:
    pass   # __exit__ appelé automatiquement

Cycle de vie d'un objet Python