GoupillWiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Classes en Python ======

On reprend l'idée de l'[[classes_exo_preparation|exercice]] concernant les calculs géométriques.

Ci-dessous, un début d'implémentation.

<code python linenums>
# module triangle.py

class Triangle:
    """
    Commentaires utiles pour la lisibilité et la documentation
    """
    def __init__(self, x1, y1, x2, y2, x3, y3):
        """
        Constructeur - Gère l'initialisation de l'objet
        x1, y1: coordonnées du premier point
        x2, y2: coordonnées du deuxième point
        x3, y3: coordonnées du troisième point
        """
        self.x1 = x1
        self.y1 = y1
        self.x2 = x2
        self.y2 = y2
        self.x3 = x3
        self.y3 = y3

    def aire(self):
        """
        Renvoie l'aire du triangle
        """
        # formule de maths...
        return abs((self.x2 - self.x1)*(self.y3 - self.y1) - (self.y2 - self.y1)*self(x3 - self.x1))/2
</code>

===== Instanciation =====

Une classe définit un modèle. Quand on utilise ce modèle pour réaliser un objet concret, on parle d'instanciation. L'objet est une instance du modèle.

Par exemple, nous sommes des instances du concept abstrait “Humain”. Nous avons toutes les caractéristiques qui font un Humain et pourtant nous sommes différents. La classe définit les attributs à posséder mais pas la valeur de ces attributs.

===== self =====

La classe définit le comportement d'un objet. Quand on a besoin de désigner l'objet dont on parle, en Python, on utilise ''self''. Beaucoup de langages préfèrent ''this'' mais c'est le même principe.

Toutes les méthodes ordinaires d'une classe Python ont comme premier argument ''self''.

> Il existe des méthodes spéciales qui fonctionnent autrement.

<code python>
>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> mon_triangle.aire()
7.0
</code>

Vous notez qu'à l'appel de ''aire'', on a pas précisé d'argument alors qu'il en fallait un.
Quand on appelle ''mon_triangle.aire()'', ''mon_triangle'' passera automatiquement comme premier argument. ''self'' désignera alors ''mon_triangle''.

<code python>
>>> tA.aire() # dans ce cas self = tA
>>> tB.aire() # dans ce cas self = tB
</code>

===== attributs =====

En tant objet, un ''Triangle'' a des attributs.

<code python>
>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> mon_triangle.x2
5
</code>

''mon_triangle.x2'' désigne l'attribut ''x2'' de l'objet ''mon_triangle''.

===== type =====

On peut vérifier qu'un objet à le type attendu.

<code python>
>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> type(mon_triangle) == Triangle
True
</code>

===== Méthode init =====

Ligne 7 est définie la fonction ''%%__init__%%'' qui mérite un peu d'attention.

C'est la fonction spéciale d'initialisation. Détaillons le fonctionnement de la création d'un objet.

<code python>
>>> mon_triangle = Triangle(0,0,5,2,3,4)
</code>

L'appelle à ''%%Triangle(...)%%'' crée un objet ''Triangle'' (instancie) en mémoire puis aussitôt, avec cet objet, appelle la fonction ''%%__init__%%''. L'argument ''self'' est automatiquement ajouté et désigne l'objet ''Triangle'' qui vient d'être créé.

Dans ''%%__init__%%'', par exemple ligne 14, vous voyez ''%%self.x1 = x1%%''.
  * le ''x1'' à droite désigne le ''x1'' transmis en argument, c'est à dire ''0'' dans l'exemple.
  * ''self.x1'' désigne l'attribut ''x1'' lié à l'objet ''Triangle'' en cours.

La ligne indique donc que l'on veut que l'attribut ''x1'' de l'objet en cours soit égal au ''x1'' que l'on a fournit à la création de l'objet.



<WRAP important>
== clones ==
<code python>
>>> tA = Triangle(0,0,5,2,3,4)
>>> tB = Triangle(0,0,5,2,3,4)
>>> tA == tB
False
</code>

Bien que les deux triangles sont identiques, ''tA'' désigne la case mémoire où est stocké l'objet, idem pour ''tB''. Les deux objets ont beau avoir les mêmes attributs, ils sont stockés à des endroits différents et donc ''tA == tB'' renvoie ''False''.

Autrement dit, deux voitures peuvent être de même marque, de la même année, de même modèle... mais ce ne sont pas les même voitures.
</WRAP>

===== Objet responsable =====

<code python>
>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> mon_triangle.aire()
7.0
</code>

Ici il est clair que la fonction ''aire'' s'applique à un objet ''Triangle''. Il n'y a aucune confusion possible. De plus, c'est un objet ''Triangle'' qui lance la fonction, il en est responsable, la fonction est définie à l'intérieur de la classe.