Langage Python

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

constructeur et destructeur en Python

Constructeur

Les constructeurs sont généralement utilisés pour instancier un objet. La tâche des constructeurs consiste à initialiser (attribuer des valeurs) aux attributs de la classe lorsqu'un objet de la classe est créé.
En Python, la méthode __init __ () est appelée le constructeur et est toujours appelée. quand un objet est créé.

Syntaxe
            def __init__(self, liste_parameters):
                # Initialisiation
        
Types de constructeurs:
  • constructeur par défaut: le constructeur par défaut est un constructeur simple qui n’accepte aucun argument. Sa définition n’a qu’un seul argument qui soit une référence à l’instance en cours de construction.
  • constructeur paramétré: Le constructeur paramétré prend son premier argument en tant que référence à l'instance en cours de construction, appelée self, et le reste des arguments est fourni par le programmeur.
En python, on ne peut définir qu'un seul constructeur
    class Personne:
        nom=''
        prenom=''
    
        # constructeur de la classe
        def __init__(self, nom, prenom):      
            self.nom=nom
            self.prenom=prenom

Destructeur

Les destructeurs sont appelés lorsqu'un objet est détruit. En Python, les destructeurs ne sont pas aussi nécessaires que en C++, car Python dispose d'un ramasse-miettes qui gère automatiquement la gestion de la mémoire.

La méthode __del __ () est une méthode appelée destructeur en Python. Il est appelé lorsque toutes les références à l’objet ont été supprimées, c’est-à-dire lorsqu’un objet est nettoyé.

Syntaxe
                def __del__(self):
                    # actions 
            
Exemple 1

Voici un exemple simple de destructeur. En utilisant le mot-clé del, nous avons supprimé toutes les références de l’objet «tab».
Le destructeur est donc invoqué automatiquement.

                class Tableau:
                    donnee=[]
                    # constructeur de la classe
                    def __init__(self):
                        
                        #initialiser le tableau avec 100 éléments
                        self.donnee=[0]*100
                    
                    def __del__(self): 
                        print("je suis le destructeur")
                
                        # vider le tableau
                        self.donnee.clear()
                
                tab=Tableau()
                del tab
            
            je suis le destructeur
        
Note :
Le destructeur est appeler à la fin du programme ou lorsque toutes les références à l'objet ont été supprimées. C'est-à-dire que le nombre de références devient zéro, et non lorsque l'objet est sorti de la portée.
Exemple 2

Cet exemple donne une explication de la note. Notez que le destructeur est appelé après l'affichage de «Fin du programme…»

            class Personne:

                # constructeur de la classe
                def __init__(self, nom, prenom):      
                    self.nom=nom
                    self.prenom=prenom
            
                def __del__(self): 
                    print("je suis le destructeur")
            
            def creation():
                print("creation de l'objet")
                p=Personne('ESSADDOUKI','Mostafa')
                print('fin de création')
                return p
            
            print("Début du programme")
            p1=creation()
            print("fin du programme")
        
            Début du programme
            creation de l'objet
            fin de création
            fin du programme
            je suis le destructeur
        
Exemple 3
class A: 
    def __init__(self, bb): 
        self.b = bb 
  
class B: 
    def __init__(self): 
        self.a = A(self) 

    def __del__(self): 
        print("je suis le destructeur") 
  
def creation(): 
    b = B() 
  
creation() 
            
            je suis le destructeur
        

Dans cet exemple, lorsque la fonction fun () est appelée, elle crée une instance de classe B qui se transmet à la classe A, qui définit ensuite une référence à la classe B et donne une référence circulaire.

En règle générale, le ramasse-miettes de Python qui est utilisé pour détecter ces types de références cycliques le supprime, mais dans cet exemple, l'utilisation d'un destructeur personnalisé marque cet élément comme "non récupérable". Simplement, il ne sait pas dans quel ordre détruire les objets, il les laisse donc. Par conséquent, si vos instances sont impliquées dans des références circulaires, elles resteront en mémoire aussi longtemps que l'application s'exécutera.

POO

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :