====== Méthode spéciale ======
[[http://fr.openclassrooms.com/informatique/cours/apprenez-a-programmer-en-python/edition-de-l-objet-et-acces-aux-attributs|Source]]

===== __init__ =====
  __init__(self,arg1,argv2...):
  
Constructeur, méthode appelée dans on instancie la classe.

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

===== __del__ =====
  __del__(self):
  
Destructeur, méthode appelée quand on détruit la classe.

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

===== __repr__ =====
  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.

<code python>
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)
</code>

<xtermrtf>
>>> p1 = Personne("Micado", "Jean")
>>> p1
Personne: nom(Micado), prénom(Jean), âge(33)
>>> repr(p1)
'Personne: nom(Micado), prénom(Jean), âge(33)'
>>>
</xtermrtf>
   
===== __str__ =====
  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.

<code python>
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)
</code>

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

=====  __getattr__ =====
  __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.

<xtermrtf>
>>> 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 !
>>>
</xtermrtf>

=====  __setattr__ =====
Cette méthode définit l'accès à un attribut destiné à être modifié.
  __setattr__(self, attr, val):

<code python>
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()
</code>

=====  __delattr__ =====
  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 

<code python>
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")
</code>

===== Bonus =====
<xtermrtf>
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
</xtermrtf>