261 lines
7.4 KiB
Plaintext
261 lines
7.4 KiB
Plaintext
Objets en python
|
||
=================
|
||
|
||
un object est une entité possédant une identité, un état, et un comportement.
|
||
|
||
Un object correspondant généralement à une entité du monde réel, mais
|
||
cette entité peut être abstraite.
|
||
|
||
On parle aussi d'instance.
|
||
|
||
.. glossary::
|
||
|
||
état d'un objet
|
||
ensemble de propriétés auxquelles sont associées des
|
||
valeurs.
|
||
|
||
Les variables de l'objet sont appelées des attributs.
|
||
le comportement d'un objet :
|
||
|
||
- des actions effectuées sur l'objet
|
||
- des demandes de services faites à l'objet
|
||
|
||
des envois de messages à l'objet = appel de méthodes
|
||
|
||
classes d'objets
|
||
-----------------
|
||
|
||
encapsulation (cacher les attributs (variables d'état)) d'un objet).
|
||
interfaces : chaque aspect d'une classe peut être vu comme une interface.
|
||
Une interface décrit un ensemble de comportements.
|
||
on peut considérer une interface comme un protocole d'utilisation d'un objet
|
||
dans un contexte donné.
|
||
|
||
on peut alors créer des outils qui sauront traiter n'importe quel objet
|
||
pourvu qu'il respecte une ensemble d'interfaces.
|
||
|
||
héritage (est une sorte de)
|
||
---------------------------
|
||
|
||
Polymorphisme (un objet apparait comme une instance d'une classe parente)
|
||
(exemple un courrier (postal, colis, lettre) est représenté par une classe
|
||
abstraite ``Pli``::
|
||
|
||
class Pli:
|
||
get_prix(self):
|
||
raise NotImplementedError
|
||
|
||
class Lettre(Pli):
|
||
get_prix(self):
|
||
return 3
|
||
|
||
class Colis(Pli):
|
||
get_prix(self):
|
||
return 10
|
||
|
||
def genere_facture(pli):
|
||
return "prix : {0}".format(pli.get_prix())
|
||
|
||
la méthode ``get_prix`` selar appelée indépendamment du type de l'objet.
|
||
|
||
Méthode de modélisation (UML), réutilisation de code.
|
||
Mise en oeuvre de design patterns en python.
|
||
|
||
introspection
|
||
--------------
|
||
|
||
- L’introspection est la possibilité d’avoir des informations sur l’objet lors de l’exécution.
|
||
- `type(obj)` renvoie le type de l’objet.
|
||
- La fonction `dir(obj)` qui renvoie la liste des attributs et méthodes.
|
||
- Le module inspect contient plusieurs fonctions qui permettent d’avoir des informations sur les objets.
|
||
|
||
- la méthode `vars(obj)` renvoie les noms et les valeurs d’un objet sous forme de
|
||
dictionnaire.
|
||
- la méthode `obj.__class__` renvoie la classe à laquelle appartient l’objet
|
||
- La fonction getattr renvoie la valeur associée à l’attribut
|
||
- La fonction setattr est équivalente à obj.att = v.
|
||
- La fonction isinstance(obj, class) renvoie True si obj est une instance de class et
|
||
renvoie False sinon.
|
||
|
||
définition et syntaxe
|
||
----------------------
|
||
|
||
Une classe est la définition d’un nouveau type utilisateur.
|
||
Ce type de variable rassemble plusieurs données : attributs et définit des
|
||
fonctions : méthodes.
|
||
|
||
- Un objet est une instance d’une classe.
|
||
(classe <=> Type, objet <=> variable).
|
||
|
||
- Syntaxe:
|
||
|
||
Création une classe:
|
||
|
||
::
|
||
|
||
>>> class Vehicule:
|
||
pass
|
||
Création d’un objet de type Vehicule:
|
||
>>> mon_vehicule = Vehicule()
|
||
|
||
attributs et méthodes
|
||
---------------------
|
||
|
||
- Les attributs permettent de stocker les informations au niveau de la classe.
|
||
- Les méthodes sont des fonctions définies dans une classe.
|
||
- Syntaxe:
|
||
|
||
::
|
||
|
||
>>> class Vehicule:
|
||
def __init__(self):
|
||
self.couleur = ''
|
||
self.vitesse = 0
|
||
def avancer(self):
|
||
self.vitesse = self.vitesse + 1
|
||
|
||
Les méthodes "__init__" et " __new__"
|
||
-------------------------------------
|
||
|
||
- La méthode `__init__` est une méthode qui est appelée automatiquement après
|
||
la création de l’objet.
|
||
|
||
- La méthode `__init__` permet d’initialiser les attributs, ce n’est pas le
|
||
constructeur, c’est `__new__` qui crée l’instance.
|
||
|
||
Premier argument d’une méthode
|
||
-------------------------------
|
||
|
||
Le premier paramètre d’une méthode est une référence vers l’instance, on
|
||
l’appelle **self** par convention.
|
||
|
||
.. ifconfig: exercice
|
||
|
||
Définir une classe Étudiant qui a comme
|
||
attributs: nom, prenom et age et qui a
|
||
comme méthode Infos() qui affiche le nom,
|
||
le prénom et l’âge de l’étudiant comme suit:
|
||
nom: [Prenom]
|
||
prenom: [NOM]
|
||
Age: [age]
|
||
|
||
attributs et méthodes privés
|
||
----------------------------
|
||
|
||
- En python, tout est publc. Toutes les méthodes et attributs sont
|
||
accessibles de l’extérieur de la classe et peuvent être modifiés.
|
||
|
||
- Un membre (attribut ou méthode) est considéré public si n’est pas précédé
|
||
d’underscore.
|
||
- Si le membre est précédé par un seul underscore il est considéré comme
|
||
protégé.
|
||
- Si le membre est précédé par deux underscores et qui se termine au plus par
|
||
un underscore, il est considéré comme "méthode spéciale".
|
||
|
||
|
||
attributs de classe et d’instance
|
||
---------------------------------
|
||
|
||
- Les attributs de classe sont accessibles sans avoir à créer une instance
|
||
de cette classe. Ce sont des variables appartenant à la classe elle-même.
|
||
- Les attributs d’instance sont accessibles après la création d’un objet. Ces
|
||
attributs sont conventionnellement créés dans la méthode __init__(self).
|
||
- Exemple:
|
||
|
||
::
|
||
|
||
>>> class Vehicule:
|
||
nom = ''
|
||
def __init__(self):
|
||
self.couleur = ''
|
||
|
||
L’attribut **nom** est un attribut de classe et l’attribut ‘couleur’ est un
|
||
attribut d’instance.
|
||
|
||
On peut ajouter des attributs d’instance après la création de l’instance.
|
||
|
||
|
||
>>> mon_vehicule.etat = 'bon'
|
||
|
||
héritage simple
|
||
---------------
|
||
|
||
- L’héritage consiste à créer une classe dite classe fille à partir d’une autre
|
||
classe dite classe mère.
|
||
- Soit B une classe qui hérite d’une classe mère A
|
||
- B hérite tous les attributs et méthodes de la classe A.
|
||
- B peut avoir d’autres attributs et méthodes.
|
||
- Quelques méthodes peuvent être redéfinies dans la classe B.
|
||
- Les classes B et A sont reliées par la relation ‘est-un’ ( B est un A).
|
||
|
||
Syntaxe :
|
||
|
||
::
|
||
|
||
class B(A)
|
||
- Exemple:
|
||
>>> class Vehicule:
|
||
def __init__(self):
|
||
self.couleur = ''
|
||
self.vitesse = 0
|
||
>>> class Voiture(Vehicule):
|
||
pass
|
||
|
||
surcharge d’attributs et de méthodes
|
||
------------------------------------
|
||
|
||
Surcharger un attribut est le fait de redéfinir sa valeur dans la classe
|
||
fille.
|
||
La surcharge d’une méthode est la modification de son comportement. Il
|
||
suffit alors de redéfinir la méthode au sein de la classe. comment
|
||
appeler la méthode de la classe parente ?
|
||
Exemple:
|
||
|
||
Redéfinition de la méthode __init__:
|
||
|
||
::
|
||
|
||
>>> class Rectangle(object):
|
||
def __init__(self, a, b):
|
||
self.long = a
|
||
self.larg = b
|
||
>>> class Carre(Rectangle):
|
||
def __init__ (self, a):
|
||
self.long = a
|
||
self.larg = a
|
||
|
||
La méthode __init__ de la classe ‘Rectangle’ n’est appelée que si on
|
||
utilise la fonction super : super(Carre, self).__init__(a,a) appelle
|
||
automatiquement la méthode de la classe mère.
|
||
Exemple :
|
||
|
||
::
|
||
|
||
>>> class carre(Rectangle):
|
||
def __init__(self, a):
|
||
super().__init__(a, a)
|
||
|
||
|
||
héritage vs. composition
|
||
------------------------
|
||
|
||
- L’héritage lie deux objets par une relation de type «est-un» alors que
|
||
la composition lie deux objets par une relation de type «a-un»
|
||
|
||
- Exemple:
|
||
|
||
::
|
||
|
||
|
||
>>> class Moteur:
|
||
pass
|
||
>>> class MoteurElectrique(Moteur):
|
||
pass
|
||
>>> class Voiture:
|
||
moteur = Moteur()
|
||
|
||
La classe MoteurElectrique est un Moteur (héritage).
|
||
La classe Voiture a un moteur (Composition).
|
||
|
||
|