formations/algo/poo/cours/BasesObjet.txt

261 lines
7.4 KiB
Plaintext
Raw Normal View History

2017-10-05 09:18:23 +02:00
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
--------------
- Lintrospection est la possibilité davoir des informations sur lobjet lors de lexécution.
- `type(obj)` renvoie le type de lobjet.
- La fonction `dir(obj)` qui renvoie la liste des attributs et méthodes.
- Le module inspect contient plusieurs fonctions qui permettent davoir des informations sur les objets.
- la méthode `vars(obj)` renvoie les noms et les valeurs dun objet sous forme de
dictionnaire.
- la méthode `obj.__class__` renvoie la classe à laquelle appartient lobjet
- La fonction getattr renvoie la valeur associée à lattribut
- 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 dun nouveau type utilisateur.
Ce type de variable rassemble plusieurs données : attributs et définit des
fonctions : méthodes.
- Un objet est une instance dune classe.
(classe <=> Type, objet <=> variable).
- Syntaxe:
Création une classe:
::
>>> class Vehicule:
pass
Création dun 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 lobjet.
- La méthode `__init__` permet dinitialiser les attributs, ce nest pas le
constructeur, cest `__new__` qui crée linstance.
Premier argument dune méthode
-------------------------------
Le premier paramètre dune méthode est une référence vers linstance, on
lappelle **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 lextérieur de la classe et peuvent être modifiés.
- Un membre (attribut ou méthode) est considéré public si nest pas précédé
dunderscore.
- 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 dinstance
---------------------------------
- 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 dinstance sont accessibles après la création dun objet. Ces
attributs sont conventionnellement créés dans la méthode __init__(self).
- Exemple:
::
>>> class Vehicule:
nom = ''
def __init__(self):
self.couleur = ''
Lattribut **nom** est un attribut de classe et lattribut couleur est un
attribut dinstance.
On peut ajouter des attributs dinstance après la création de linstance.
>>> mon_vehicule.etat = 'bon'
héritage simple
---------------
- Lhéritage consiste à créer une classe dite classe fille à partir dune autre
classe dite classe mère.
- Soit B une classe qui hérite dune classe mère A
- B hérite tous les attributs et méthodes de la classe A.
- B peut avoir dautres 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 dattributs et de méthodes
------------------------------------
Surcharger un attribut est le fait de redéfinir sa valeur dans la classe
fille.
La surcharge dune 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 nest 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
------------------------
- Lhé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).