Castel'Lab le Fablab MJC de Château-Renault

Outils pour utilisateurs

Outils du site

Piste :
debuter_en_python:poo

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
debuter_en_python:poo [2024/09/10 15:53] – gerardadmindebuter_en_python:poo [2024/09/10 16:26] (Version actuelle) – [Programmation Orientée Objet (POO)] gerardadmin
Ligne 3: Ligne 3:
  
 La programmation orientée objet (POO) permet de créer des entités (objets) que l'on peut manipuler . La programmation orientée objet impose des structures solides et claires. Les objets peuvent interagir entre eux, cela facilite grandement la compréhension du code et sa maintenance. On oppose souvent la programmation objet à la programmation procédurale , la première étant plus "professionnelle" que l'autre car plus fiable et plus propre. La programmation orientée objet (POO) permet de créer des entités (objets) que l'on peut manipuler . La programmation orientée objet impose des structures solides et claires. Les objets peuvent interagir entre eux, cela facilite grandement la compréhension du code et sa maintenance. On oppose souvent la programmation objet à la programmation procédurale , la première étant plus "professionnelle" que l'autre car plus fiable et plus propre.
-Les classes+ 
 +La notion la plus importante en programmation orientée objet est **le concept de classe.** Les classes sont des moules, des patrons qui permettent de créer des objets en série sur le même modèle. On peut se représenter une classe comme le schéma de construction ainsi que la liste des fonctionnalités d’un ensemble d’objets 
 +======Les classes======
  
 Une classe regroupe des fonctions et des attributs qui définissent un objet. On appelle par ailleurs les fonctions d'une classe des " méthodes ". Une classe regroupe des fonctions et des attributs qui définissent un objet. On appelle par ailleurs les fonctions d'une classe des " méthodes ".
Ligne 36: Ligne 38:
     >>> ma_voiture = Voiture()     >>> ma_voiture = Voiture()
  
-==== Les attributs de classe====+==== Les attributs de classe ====
  
 Les attributs de classe permettent de stocker des informations au niveau de la classe. Elle sont similaires aux variables. Les attributs de classe permettent de stocker des informations au niveau de la classe. Elle sont similaires aux variables.
Ligne 55: Ligne 57:
     '250'     '250'
  
-Les méthodes+====Les méthodes====
  
 Les méthodes sont des fonctions définies dans une classe. Les méthodes sont des fonctions définies dans une classe.
Ligne 61: Ligne 63:
 Créons une nouvelle méthode dans notre classe voiture: Créons une nouvelle méthode dans notre classe voiture:
  
 +<code python class002.py>
 # coding: utf-8 # coding: utf-8
  
Ligne 70: Ligne 73:
  def donne_moi_le_modele(self):  def donne_moi_le_modele(self):
  return "250"  return "250"
 +</code>
  
 Utilison cette méthode: Utilison cette méthode:
  
->>> ma_voiture=Voiture() +    >>> ma_voiture=Voiture() 
->>> ma_voiture.donne_moi_le_modele() +    >>> ma_voiture.donne_moi_le_modele() 
-'250'+    '250' 
 + 
 + 
 +====Les propriétés==== 
 + 
 +Quelque soit le langage, pour la programmation orientée objet il est de préférable de passer par des propriétés pour changer les valeurs des attributs. Alors bien que cela ne soit pas obligatoire, il existe une convention de passer par des getter (ou accesseur en francais) et des setter ( mutateurs ) pour changer la valeur d'un attribut. Cela permet de garder une cohérence pour le programmeur, si je change un attribut souvent cela peut également impacter d'autres attributs et les mutateurs permettent de faire cette modification une fois pour toute. 
 + 
 +Un exemple d'utilisation de propriétés: 
 + 
 +<code python3 class003.py> 
 +# coding: utf-8 
 + 
 +class Voiture(object): 
 + 
 +    def __init__(self): 
 +        self._roues=4 
 + 
 +    def _get_roues(self): 
 +        print "Récupération du nombre de roues" 
 +        return self._roues 
 + 
 +    def _set_roues(self, v): 
 +        print "Changement du nombre de roues" 
 +        self._roues  =  v 
 + 
 +    roues=property(_get_roues, _set_roues) 
 +</code> 
 + 
 +Quand on changera la valeur du nombre de roues, un message apparaîtra. En soi cela n'apporte rien mais au lieu de faire un simple print , vous pouvez par exemple envoyer un mail, etc. 
 + 
 +Testons notre classe: 
 + 
 +    >>> ma_voiture=Voiture() 
 +    >>> ma_voiture.roues=5 
 +Changement du nombre de roues 
 +    >>> ma_voiture.roues 
 +Récupération du nombre de roues 
 +    5 
 + 
 +Il existe une autre syntaxe en passant par des décorateurs: 
 + 
 +<code python3 class004.py> 
 +class Voiture(object): 
 + 
 +    def __init__(self): 
 +        self._roues=4 
 + 
 +    @property 
 +    def roues(self): 
 +        print "Récupération du nombre de roues" 
 +        return self._roues 
 + 
 +    @roues.setter 
 +    def roues(self, v): 
 +        print "Changement du nombre de roues" 
 +        self._roues  =  v 
 +</code> 
 + 
 +Le résultat sera le même, mais la lecture du code se trouve amélioré.  
 + 
 +==== La fonction dir==== 
 + 
 +Parfois il est intéressant de decortiquer un objet pour résoudre à un bug ou pour comprendre un script. 
 + 
 +La fonction dir vous donne un aperçu des méthodes de l'objet: 
 + 
 +    >>> dir(ma_voiture) 
 +<nowiki> 
 +    ['__doc__', '__init__', '__module__', 'donne_moi_le_modele', 'nom'] 
 +</nowiki> 
 + 
 + 
 +====    L'attribut spécial __dict__ ==== 
 + 
 + 
 +Cet attribut spécial vous donne les valeurs des attributs de l'instance: 
 + 
 +    >>> ma_voiture.__dict__ 
 +    {'nom': 'Ferrari'} 
 + 
 +====L'héritage de class==== 
 + 
 +L'héritage est un concept très utile. Cela permet de créer de nouvelles classes mais avec une base existante. 
 + 
 +Gardons l'exemple de la voiture et créons une classe VoitureSport : 
 + 
 +<code pyton3 class005.py> 
 +class Voiture: 
 + 
 + roues = 4 
 + moteur = 1 
 + 
 + def __init__(self): 
 + self.nom = "A déterminer" 
 + 
 +class VoitureSport(Voiture): 
 + 
 + def __init__(self): 
 + self.nom = "Ferrari" 
 +</code> 
 + 
 +On a indiqué que VoitureSport a hérité de classe Voiture , elle recupère donc toutes ses méthodes et ses attributs. 
 + 
 +On peut toujours instancier la classe Voiture si on le désire: 
 + 
 +    >>> ma_voiture=Voiture() 
 +    >>> ma_voiture.nom 
 +    'A déterminer' 
 +    >>> ma_voiture.roues 
 +    4 
 + 
 +Instancions maintenant la classe VoitureSport : 
 + 
 +    >>> ma_voiture_sport=VoitureSport() 
 +    >>> ma_voiture_sport.nom 
 +    'Ferrari' 
 +    >>> ma_voiture_sport.roues 
 +    4 
 + 
 +On remarque tout d'abord que l'attribut roues a bien été hérité. Ensuite on remarque que la méthode %%__init__%% a écrasé la méthode de la classe Voiture . On parle alors de surcharge de méthode. 
 + 
 +====Polymorphisme / surcharge de méthode==== 
 + 
 +Comme nous l'avons vu plus haut si une classe hérite d'une autre classe, elle hérite les méthodes de son parent . 
 + 
 +Exemple: 
 + 
 +<code pyton3 class006.py> 
 +# coding: utf-8 
 + 
 +class Voiture: 
 + 
 +    roues = 4 
 +    moteur = 1 
 + 
 +    def __init__(self): 
 +        self.nom = "A déterminer" 
 +         
 +    def allumer(self): 
 +        print "La voiture démarre" 
 + 
 +class VoitureSport(Voiture): 
 + 
 +    def __init__(self): 
 +        self.nom = "Ferrari" 
 + 
 +    ma_voiture_sport = VoitureSport() 
 +    ma_voiture_sport.allumer() 
 + 
 +</code> 
 + 
 +Le résultat: 
 + 
 +    La voiture démarre 
 + 
 +Il est cependant possible d' écraser la méthode de la classe parente en la redéfinissant. On parle alors de surcharger une méthode . 
 + 
 +<code python class007.py> 
 + 
 +# coding: utf-8 
 + 
 +class Voiture: 
 + 
 +    roues = 4 
 +    moteur = 1 
 + 
 +    def __init__(self): 
 +        self.nom = "A déterminer" 
 +         
 +    def allumer(self): 
 +        print "La voiture démarre" 
 + 
 +class VoitureSport(Voiture): 
 + 
 +    def __init__(self): 
 +        self.nom = "Ferrari" 
 +         
 +    def allumer(self): 
 +        print "La voiture de sport démarre" 
 + 
 +    ma_voiture_sport = VoitureSport() 
 +    ma_voiture_sport.allumer() 
 +</code> 
 + 
 +Le résultat: 
 + 
 +    La voiture de sport démarre 
 + 
 +Enfin dernier point intéressant: il est possible d'appeler la méthode du parent puis de faire la spécificité de la méthode. On peut d'ailleurs appeler n'importe quelle autre méthode. 
 + 
 +<code python class008.py> 
 +# coding: utf-8 
 + 
 +class Voiture: 
 + 
 +    roues = 4 
 +    moteur = 1 
 + 
 +    def __init__(self): 
 +        self.nom = "A déterminer" 
 +         
 +    def allumer(self): 
 +        print "La voiture démarre" 
 + 
 +class VoitureSport(Voiture): 
 + 
 +    def __init__(self): 
 +        self.nom = "Ferrari" 
 +         
 +    def allumer(self): 
 +        Voiture.allumer(self) 
 +        print "La voiture de sport démarre" 
 + 
 +    ma_voiture_sport = VoitureSport() 
 +    ma_voiture_sport.allumer() 
 + 
 +</code> 
 + 
 +Le résultat: 
 + 
 +    La voiture démarre 
 +    La voiture de sport démarre 
 + 
 +Les classes Voiture et VoitureSport possédent donc chacune une méthode de même nom mais ces méthodes n'éffectuent pas les mêmes tâches. On parle dans ce cas de polymorphisme . 
 +Conventions 
 + 
 +Prenez l'habitude de nommer votre classe uniquement avec des caractères alphanumériques et commençant par une majuscule. Et à l'inverse l'instance peut être nommée sans majuscule.
  
 +    voiture_sport = VoitureSport()
 +    
 +======= Programmation Orientée Objet (POO) =======
  
 +[[https://datascientest.com/programmation-orientee-objet-guide-ultime|Programmation-orientee-objet-guide-ultime]]
  
 +[[https://openclassrooms.com/fr/courses/7150616-apprenez-la-programmation-orientee-objet-avec-python|Apprenez-la-programmation-orientee-objet-avec-python]]
  
 +[[https://zestedesavoir.com/tutoriels/1253/la-programmation-orientee-objet-en-python/|la-programmation-orientee-objet-en-python : zestedesavoir.com]]
/home/chanteri/www/fablab37110/data/attic/debuter_en_python/poo.1725976385.txt.gz · Dernière modification : 2024/09/10 15:53 de gerardadmin