formations/algo/poo/cours/BasesObjet.txt

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).