Source

__init__(self,arg1,argv2...):

Constructeur, méthode appelée dans on instancie la classe.

class Exemple:
    """Un petit exemple de classe"""
    def __init__(self, nom):
        """Exemple de constructeur"""
        self.nom = nom
        self.autre_attribut = "une valeur"

__del__(self):

Destructeur, méthode appelée quand on détruit la classe.

def __del__(self):
        """Méthode appelée quand l'objet est supprimé"""
        print("C'est la fin ! On me supprime !")

def __repr__(self):

Elle affecte la façon dont est affiché l'objet quand on tape directement son nom. On la redéfinit quand on souhaite faciliter le debug sur certains objets.

class Personne:
    """Classe représentant une personne"""
    def __init__(self, nom, prenom):
        """Constructeur de notre classe"""
        self.nom = nom
        self.prenom = prenom
        self.age = 33
    def __repr__(self):
        """Quand on entre notre objet dans l'interpréteur"""
        return "Personne: nom({}), prénom({}), âge({})".format(
                self.nom, self.prenom, self.age)

>>> p1 = Personne("Micado", "Jean")
>>> p1
Personne: nom(Micado), prénom(Jean), âge(33)
>>> repr(p1)
'Personne: nom(Micado), prénom(Jean), âge(33)'
>>>

def __str__(self):

Il existe une seconde méthode spéciale, str, spécialement utilisée pour afficher l'objet avec print. Par défaut, si aucune méthode str n'est définie, Python appelle la méthode repr de l'objet. La méthode str est également appelée si vous désirez convertir votre objet en chaîne avec le constructeur str.

class Personne:
    """Classe représentant une personne"""
    def __init__(self, nom, prenom):
        """Constructeur de notre classe"""
        self.nom = nom
        self.prenom = prenom
        self.age = 33
    def __str__(self):
        """Méthode permettant d'afficher plus joliment notre objet"""
        return "{} {}, âgé de {} ans".format(
                self.prenom, self.nom, self.age)

>>> p1 = Personne("Micado", "Jean")
>>> print(p1)
Jean Micado, âgé de 33 ans
>>> chaine = str(p1)
>>> chaine
'Jean Micado, âgé de 33 ans'
>>>

__getattr__(self, var):

Python recherche l'attribut et, s'il ne le trouve pas dans l'objet et si une méthode getattr existe, il va l'appeler en lui passant en paramètre le nom de l'attribut recherché, sous la forme d'une chaîne de caractères.

>>> class Protege:
...     """Classe possédant une méthode particulière d'accès à ses attributs :
...     Si l'attribut n'est pas trouvé, on affiche une alerte et renvoie None"""
...
...     
...     def __init__(self):
...         """On crée quelques attributs par défaut"""
...         self.a = 1
...         self.b = 2
...         self.c = 3
...     def __getattr__(self, nom):
...         """Si Python ne trouve pas l'attribut nommé nom, il appelle
...         cette méthode. On affiche une alerte"""
...
...         
...         print("Alerte ! Il n'y a pas d'attribut {} ici !".format(nom))
...
>>> pro = Protege()
>>> pro.a
1
>>> pro.c
3
>>> pro.e
Alerte ! Il n'y a pas d'attribut e ici !
>>>

Cette méthode définit l'accès à un attribut destiné à être modifié.

__setattr__(self, attr, val):

def __setattr__(self, nom_attr, val_attr):
        """Méthode appelée quand on fait objet.nom_attr = val_attr.
        On se charge d'enregistrer l'objet"""
 
 
        object.__setattr__(self, nom_attr, val_attr)
        self.enregistrer()

def __delattr__(self, nom_attr):

Cette méthode spéciale est appelée quand on souhaite supprimer un attribut de l'objet, en faisant del

def __delattr__(self, nom_attr):
        """On ne peut supprimer d'attribut, on lève l'exception
        AttributeError"""
 
        raise AttributeError("Vous ne pouvez supprimer aucun attribut de cette classe")

objet = MaClasse() # On crée une instance de notre classe
getattr(objet, "nom") # Semblable à objet.nom
setattr(objet, "nom", val) # = objet.nom = val ou objet.__setattr__("nom", val)
delattr(objet, "nom") # = del objet.nom ou objet.__delattr__("nom")
hasattr(objet, "nom") # Renvoie True si l'attribut "nom" existe, False sinon