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

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

# 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

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.

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.

>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> mon_triangle.aire()
7.0

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.

>>> tA.aire() # dans ce cas self = tA
>>> tB.aire() # dans ce cas self = tB

En tant objet, un Triangle a des attributs.

>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> mon_triangle.x2
5

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

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

>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> type(mon_triangle) == Triangle
True

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.

>>> mon_triangle = Triangle(0,0,5,2,3,4)

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.

>>> tA = Triangle(0,0,5,2,3,4)
>>> tB = Triangle(0,0,5,2,3,4)
>>> tA == tB
False

>>> mon_triangle = Triangle(0,0,5,2,3,4)
>>> mon_triangle.aire()
7.0

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.