Programmation orientée objets avec Python

Cette section n'est qu'un ébauche, permettant de se familiariser avec quelques concepts simples de POO

Contrairement à ce que le titre de ce document laisse entendre, l'objet de ce document n'est pas de traiter les différents aspects de la POO, mais plutôt de détailler les différentes notations (et qques concepts) de POO qui sont utiles dans le cadre de l'utilisation du binding PySide (utilisé pour réaliser des interfaces graphiques). Il s'agit juste d'un bref survol, rapide et absolument pas exhaustif, de quelques éléments utiles à la compréhension du document [[stu:python_gui:pyqt|Interfaces graphiques avec Python et Qt]].

- Des points et des droites

- Une classe Point

Nous désirons manipuler des points du plan, en utilisant la POO. Pour cela, nous créons une nouvelle classe, qui servira de moule à la création des nouveaux points :

class Point :
    pass

Une fois ces lignes entrées, la classe Point existe est nous pouvons créer de nouveaux objets ainsi :

>>> p=Point()
>>> p
<__main__.Point object at 0x7f0354113a50>

Notre classe ne sert encore à rien. Une des premières choses à faire est de recenser :

les caractéristiques de chaque objet (ce seront les attributs)
les manipulations que nous leur appliquerons ou qu'ils s'appliqueront (ce seront les méthodes)

Nous devons aussi définir de quelle manière seront créés et initialisés nos objets.

Manifestement, un point du plan est bien représenté par ses coordonnées. Les coordonnées seront les attributs. Une des premières manipulations nécessaires est l'affichage. Enfin, nos objets seront créés en indiquant leurs coordonnées.

- Méthode spéciale d'initialisation

La méthode spéciale ''__init__ est appelée à l'initialisation des nouveaux objets (pour ceux qui connaissent la POO, c'est presque comme un constructeur, mais pas exactement). Elle prend en paramètre l'objet à initialiser, ainsi que les paramètres qu'on utilise lors de l'initialisation (x et ydans notre cas). En Python, la référence à l'objet est toujours le premier paramètre passé aux méthodes. Par convention, on l'appelleself: <code python> class Point : def init(self,x,y) : self.x=x self.y=y </code>




Dans le code qui précède : self.x=x signifie : l'attribut x de l'objet self (self est l'objet que nous initialisons) doit valoir ce que valait x (le paramètre).





Voyons comment utiliser cet objet :
<code python>
»> p=Point()
Traceback (most recent call last):
  File “<pyshell#20>”, line 1, in <module>
    p=Point()
TypeError: init() takes exactly 3 arguments (1 given)
</code>
En effet, lors de la création d'un nouvel objet, il faut donner une référence à l'objet (ce qui est fait automatiquement par Python ainsi que 2 entiers (ce qui fait bien au total 3 paramètres) :

<code python>
»> p=Point(2,3)
»> p
<main.Point object at 0x7f8e80113b90>
»> p.x
2
»> p.y
3
»> p.x=42
»> p.x
42
</code>



Nous voyons que les 2 attributs ont bien été initialisés aux valeurs passées lors de la création.
Nous voyons aussi que ces valeurs peuvent être changées sans précaution (c'est un point parfois critiqué de Python).

==== - Une première méthode ==== Nous allons maintenant rajouter une méthode d'affichage : <code python> class Point : def init(self,x,y) : self.x=x self.y=y def affiche(self) : print(“Point(”,self.x,',',self.y,“)”) </code> Voyons comment cela fonctionne : <code python> »> p=Point(2,3) »> p.affiche() Point( 2 , 3 ) </code> ==== - Une classe Droite ==== Créons maintenant une autre classe, pour représenter des droites du plan, non verticales. Ces droites sont assimilables aux équations de type y=ax+b. Les attributs représentant nos objets droite seront donca et b: <code python> class Droite : def init(self,a,b) : self.a=a self.b=b </code> Nous pouvons maintenant rajouter une méthode à nos droites, permettant par exemple de savoir si un point est dessus : <code python> class Droite : def init(self,a,b) : self.a=a self.b=b def appartient(self,p) : if p.y==self.a*p.x+self.b : return True return False </code> Voyons si cela fonctionne : <code python> »> d=Droite(2,-3) »> p1=Point(5,7) »> p2=Point(5,8) »> d.appartient(p1) True »> d.appartient(p2) False »> d.appartient(Point(4,5)) True </code> Ajoutons encore une méthode à la classeDroitepermettant, connaissant l'abcisse d'un point, de renvoyer le point de cette droite ayant cette abcisse (il y en a toujours un puisque les droites ne sont pas verticales) : <code python> class Droite … def prendPoint(self,x) : y=self.a*x+self.b return Point(x,y) </code> Testons notre nouvelle methode : <code python> »> d=Droite(2,3) »> d=Droite(2,-3) »> p=d.prendPoint(5) »> p.affiche() Point( 5 , 7 ) »> d.prendPoint(5).affiche() Point( 5 , 7 ) </code> Inversement, ajoutons à la classePointune méthode qui renvoie la droite médiatrice (on fournit le second point en paramètre). Comme nous avons besoin des coordonnées du milieu, nous ajoutons la méthode qui fait ce travail : <code python> def milieu(self,p) : return Point¹⁾



¹⁾ 
self.x+p.x)/2,(self.y+p.y)/2)  
  def mediatrice(self,p) :
      if self.y==p.y : return None
       m=self.milieu(p)
       co=(p.x-self.x)/(p.y-self.y)
       a=-co
       b=m.x*co+m.y
       return Droite(a,b)
</code>
Il aurait été envisageable de créer une classe Segment contenant comme attributs les 2 points extrêmes et d'implanter les méthodes mediatrice et milieu dans la classe Segment.Faites ce travail en exercice.
==== - Méthodes magiques pour afficher les objets ====

Pour avoir un affichage plus simple des objets, nous utilisons une des méthodes magiques de Python (ces méthodes sont encadrées par ''__, et __init__ en était un example).

Cette méthode, nommée __repr__ est utilisée automatiquement par Python pour fournir une représentation exécutable de l'objet.
Une méthode un peu similaire __str__ fournit une représentation pour l'utilisateur, pas forcément exécutable.
Dans notre cas, si le point de coordonnées 5,3 s'affiche ainsi :
Point(5,3) nous avons à la fois une représentation lisible et exécutable.

Cet ajout nous permet de supprimer la méthode affiche devenue inutile.
</WRAP>

<code python>
class Point
   …
   def repr(self) :
       return 'Point('+str(self.x)+','+str(self.y)+')'
</code>

La méthode ''__repr__, comme __str__ ne doit pas afficher mais doit retourner une chaîne de caractères.
</WRAP>

Voyons ce que nous pouvons faire à présent :
<code python>
»> p=Point(5,3)
»> p
Point(5,3)
»> print(p)
Point(5,3)
»> p1=Point(5,3)
»> p1
Point(5,3)
»> p2=Point(2,6)
»> p3=p1.milieu(p2)
»> p3
Point(3.5,4.5)
»> d=p1.mediatrice(p3)
»> d
<main.Droite object at 0x7fc12c1139d0>
»> d.a,d.b
(1.0, -0.5)
</code>

C'est l'occasion de rajouter une méthode __repr__ à la classe Droite aussi :
<code python>
class Droite :
    def repr(self) :
        return 'Droite('+str(self.a)+','+str(self.b)+')'
</code>

==== - Quelques méthodes en plus ====

Le cinquième postulat d'Euclide nous indique que par un point donné, il ne passe qu'une droite parallèle à une autre droite donnée.
C'est l'occasion pour nous d'écrire une nouvelle méthode dans la classe Droite. 

<code python>
class Droite 
    …   
    def parallele(self,p) :
        d=Droite(self.a,self.b)
        d.b=p.y-d.a*p.x
        return d
</code>

Ajoutez des méthodes permettant de trouver :
 la perpendiculaire à une droite passant par un point 

 l'intersection de deux droites.


(Solution)

vous pourrez ensuite vérifier que tout fonctionne correctement :
<code python>
»> d1=Droite(2,-3)
»> p1=d1.prendPoint(2)
»> p1
Point(2,1)
»> p2=Point(8,-3)
»> d3=d1.perpendiculaire(p2)
»> d3
Droite(-0.5,1.0)
»> d2=d3.perpendiculaire(p2)
»> d2
Droite(2.0,-19.0)
»> d1.parallele(p2)
Droite(2,-19)
»> p3=d1.intersection(d3)
»> p3
Point(1.6,0.20000000000000018)
»> m=p2.mediatrice(p3)
»> m
Droite(2.0,-11.0)
»> p2.milieu(p3)
Point(4.8,-1.4)
»> d1.parallele(p2.milieu(p3))
Droite(2,-11.0)
</code>

==== - Héritage ====
En plus des points du plan, nous désirons générer les points colorés. La couleur sera représentée par un triplet (r,v,b).
Tout ce que peut faire un point, un point coloré peut le faire : un point coloré est donc un cas particulier de point. C'est dans ce cas précis que nous utilisons l'héritage :
<code python>
class PointCouleur(Point) :
    def init(self,x,y,col) :
        super().init(x,y)
        self.col=col
        
</code>
La classe PointCouleur hérite de la classe Point car c'est mentionné sur la ligne de déclaration de la classe.Nous écrivons une nouvelle méthode d'initialisation pour PointCouleur et appelons à l'intérieur la méthode d'initialisation de la classe mère (grâce à super())

Voyons comment utiliser cette nouvelle classe :
<code python>
»> p1=PointCouleur(2,3,(255,0,0))
»> p2=PointCouleur(-5,1,(0,255,0))
»> p1.mediatrice(p2)
Droite(-3.5,-3.25)
</code>

La classe PointCouleur hérite de la classe Point et donc la méthode mediatrice est disponible aussi pour les PointCouleur.

En revanche l'affichage n'est pas satisfaisant :
<code python>
»> p1=PointCouleur(2,3,(255,0,0))
»> p1
Point(2,3)
</code>

Nous redéfinissons donc la méthode __repr__ de la classe PointCouleur :
<code python> 
class PointCouleur(Point) :
    def init(self,x,y,col) :
        super().init(x,y)
        self.col=col
    def repr(self) :
        return 'PointCouleur('+repr(self.x)+','+repr(self.y)+','+repr(self.col)+')'
</code>

L'affichage est maintenant différent selon le type de point :
<code python>
»> p1=PointCouleur(2,3,(255,0,0))
»> p2=PointCouleur(-5,1,(0,255,0))
»> p1
PointCouleur(2,3,(255, 0, 0))
»> p2
PointCouleur(-5,1,(0, 255, 0))
»> p1.milieu(p2)
Point(-1.5,2.0)
</code>
===== - Copie =====
Attention, l'affectation ne crée pas une copie d'un objet, mais une nouvelle référence sur l'objet :
<code python>
»> p=Point(1,2)
»> p1=p
»> p1
Point(1,2)
»> p1.x=42
»> p
Point(42,2)
</code>
Modifier p ou p1 c'est la même chose. Si on souhaite copier l'objet et en avoir deux versions, il faut utiliser le module copy :
<code python>
»> import copy
»> p=Point(42,2)
»> p2=copy.copy(p)
»> p2
Point(42,2)
»> p2.x=99999
»> p2
Point(99999,2)
»> p
Point(42,2)
</code>
 
===== - Héritage ou non =====
Il est important de différencier si un objet fait partie d'un autre, ou si un objet est un cas particulier d'un autre. Lors de la conception de la classe B, et si on dispose déjà de la classe A, on se demande :
  * si B est une sorte de A (comme un rectangle est un quadrilatère ou un point coloré est un point), alors B doit probablement être une classe qui hérite de A
  * si B possède un A (comme un cercle possède un centre ou un segment deux points extrémités), alors B doit probablement avoir un objet de type A comme attribut

===== - Code pour démarrer les exercices =====
<file python geom.py>

class Point :
    def milieu(self,p) :
        return Point((self.x+p.x)/2,(self.y+p.y)/2)
    def repr(self) :
       return 'Point('+str(self.x)+','+str(self.y)+')'	
 
    def mediatrice(self,p) :
        if self.y==p.y : return None
        m=self.milieu(p)
        co=(p.x-self.x)/(p.y-self.y)
        a=-co
        b=m.x*co+m.y
        return Droite(a,b)
    def init(self,x,y) :
        self.x=x
        self.y=y
 

class Droite :
    def init(self,a,b) :
        self.a=a
        self.b=b
    def appartient(self,p) :
        if p.y==self.a*p.x+self.b : return True
        return False
    def prendPoint(self,x) :
        y=self.a*x+self.b
        return Point(x,y)
    def repr(self) :
        return 'Droite('+str(self.a)+','+str(self.b)+')'
    def parallele(self,p) :
        d=Droite(self.a,self.b)
        d.b=p.y-d.a*p.x
        return d	

class PointCouleur(Point) :
    def init(self,x,y,col) :
        super().init(x,y)
        self.col=col
    def repr(self) :
        return 'PointCouleur('+repr(self.x)+','+repr(self.y)+','+repr(self.col)+')'

</file>
===== - Tips =====
la méthode mro() (method resolution order) utilisable sur une classe indique l'ordre dans lequel les classes (celle utilisée et ses ancètres) sont parcourues pour trouver la méthode à exécuter :>>> PointCouleur.mro() 
[<class '__main__.PointCouleur'>, <class '__main__.Point'>, <class 'object'>]


===== - Documentation =====
Il est important de bien documenter les classes et méthodes grâce aux docstrings. Voici le type de renseignements qu'on obtient ensuite avec help'' :>>> help(poogeom)
Help on module poogeom:

NAME
    poogeom

DESCRIPTION
    Module poogeom : illustration de quelques concepts
    de programmation orientée objets avec des objets géométriques

CLASSES
    builtins.object
        Droite
        Point
            PointCouleur
        Segment
    
    class Droite(builtins.object)
     |  Classe représentant des droites non verticales du plan
     |  
     |  Methods defined here:
     |  
     |  __init__(self, a, b)
     |      Une droite non verticale est définie pas son coefficient
     |      directeur et l'ordonnée à l'origine
     |  
     |  __repr__(self)
     |  
     |  contient(self, p)
     |      Indique si le point p appartien à self
     |  
     |  intersection(self, d)
     |      Renvoie le point d'intersection de self et d
     |  
     |  parallele(self, p)
     |      Renvoie la droite parallèle à self passant par p
     |  
     |  perpendiculaire(self, p)
     |      Renvoie la droite perpendiculaire à self passant par p
     |  
     |  prendPoint(self, x)
     |      Renvoie le point d'abcisse x situé sur self
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class Point(builtins.object)
     |  Classe pour représenter un point du plan
     |  
     |  Methods defined here:
     |  
     |  __init__(self, x, y)
     |      Un point est défini par ses deux coordonnées
     |  
     |  __repr__(self)
     |  
     |  mediatrice(self, p)
     |      Renvoie la médiatrice de self et p
     |  
     |  milieu(self, p)
     |      Renvoie le point milieur de self et p
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class PointCouleur(Point)
     |  Classe représentant un point du plan d'une certains couleur
     |  
     |  Method resolution order:
     |      PointCouleur
     |      Point
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __init__(self, x, y, col)
     |  
     |  __repr__(self)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Point:
     |  
     |  mediatrice(self, p)
     |      Renvoie la médiatrice de self et p
     |  
     |  milieu(self, p)
     |      Renvoie le point milieur de self et p
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Point:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
    
    class Segment(builtins.object)
     |  Classe pour représenter un segment de droite
     |  
     |  Methods defined here:
     |  
     |  __init__(self, p1, p2)
     |      Un segment est défini par ses deux extrémités
     |  
     |  mediatrice(self)
     |      Droite médiatrice d'un segment
     |  
     |  milieu(self)
     |      Milieu d'un segment
     |  
     |  support(self)
     |      Renvoie la droite support du segment
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)



                    
                                    


                stu/python/pypoo.txt · Dernière modification: 2014/03/31 16:45 (modification externe)

Informatique, Programmation, Python, Enseignement...

Outils pour utilisateurs

Outils du site

Table des matières

Programmation orientée objets avec Python

- Des points et des droites

- Une classe Point

- Méthode spéciale d'initialisation

Outils de la page