2018/2019

PROGRAMMATION EN PYTHON
Classes de LICENCE

UP Informatique

ESATIC
Ecole Supérieure Africaine des TIC
Table des matières
I. Calculs et variables python............................................................................................................................4
1. Python c'est quoi ?.....................................................................................................................................4
2. Que fait Python ?........................................................................................................................................4
3. Pourquoi préférer Python aux autres langages ?.....................................................................................4
4. Qui utilise Python ?....................................................................................................................................4
II. Calculs et variables python........................................................................................................................5
1. Calculs.........................................................................................................................................................5
2. Les variables...............................................................................................................................................5
3. Echapper les quotes....................................................................................................................................6
4. Nommer une variable.................................................................................................................................7
5. Les types de variables................................................................................................................................7
III. Les fonctions python................................................................................................................................14
1. Créer ma première fonction....................................................................................................................14
2. Les fonctions paramétrées.......................................................................................................................14
3. Un paramètre est obligatoire...................................................................................................................15
4. Portée des variables (variable globale et variable locale)......................................................................15
5. Procédure et fonctions..............................................................................................................................15
IV. IF ELIF ELSE Python Conditions............................................................................................................9
1. Condition if else..........................................................................................................................................9
2. Condition elif............................................................................................................................................10
3. Les comparaisons possibles.....................................................................................................................10
4. Comment fonctionnent les structures conditionnelles ?........................................................................10
5. AND / OR..................................................................................................................................................11
6. Chainer les comparateurs........................................................................................................................11
V. Les boucles for et while Python...................................................................................................................12
1. La boucle while.........................................................................................................................................12
2. La boucle for.............................................................................................................................................12
3. Range.........................................................................................................................................................13
VI. Les listes python.......................................................................................................................................16
1. Créer une liste en python.........................................................................................................................16
2. Ajouter une valeur à une liste python.....................................................................................................16
3. Afficher un item d'une liste.....................................................................................................................16
4. Supprimer une entrée avec un index......................................................................................................17
5. Supprimer une entrée avec sa valeur......................................................................................................17
6. Inverser les valeurs d'une liste................................................................................................................17
7. Compter le nombre d'items d'une liste...................................................................................................17
8. Compter le nombre d'occurrences d'une valeur....................................................................................17
 9. Trouver l'index d'une valeur...................................................................................................................17
10. Manipuler une liste...............................................................................................................................18
11. Boucler sur une liste.............................................................................................................................18
12. Copier une liste.....................................................................................................................................18
13. La fonction range.................................................................................................................................19
14. Agrandir une liste par une liste...........................................................................................................19
15. Astuces..................................................................................................................................................19
VII. Les tuples python......................................................................................................................................21
1. Créer un tuple...........................................................................................................................................21
2. Ajouter une valeur à un tuple..................................................................................................................21
3. Afficher une valeur d'un tuple................................................................................................................21
4. A quoi sert un tuple alors ?......................................................................................................................21
VIII. Les dictionnaires python.......................................................................................................................23
1. Comment créer un dictionnaire ?...........................................................................................................23
2. Comment ajouter des valeurs dans un dictionnaire ?...........................................................................23
3. Récupérer une valeur dans un dictionnaire...........................................................................................23
4. Supprimer une entrée de dictionnaire....................................................................................................23
5. Récupérer les valeurs par une boucle.....................................................................................................23

PROGRAMMATION ORIENTEE OBJET EN PYTHON

I. Introduction à la Programmation Orientée Objet.................................................................................25

1. Qu’est-ce que la Programmation Orientée Objet (POO)..................................................................25
2. Vers la Programmation Orientée Objet.............................................................................................25
2.1. Pourquoi la POO ?................................................................................................................................25
2.2. Introduction à la POO..........................................................................................................................25
3. Concepts de Classes et objets...............................................................................................................25
4. Les trois grands principes de la POO.................................................................................................26
II. Programmation de la classe et de l’objet............................................................................................27
1. Principe et syntaxe de définition d’une classe....................................................................................27
2. Définition d’une classe exemple : « Point ».........................................................................................27
3. Création d’un objet de type « Point ».................................................................................................27
4. Affectation à une variable de la référence à un objet........................................................................27
5. Définition des attributs........................................................................................................................28
6. Définition des méthodes.......................................................................................................................29
7. La notion de constructeur....................................................................................................................30
III. La notion d’encapsulation...................................................................................................................33
1. Définition d’attributs privés................................................................................................................33
 2. Accesseurs et mutateurs.......................................................................................................................34
IV. Attributs et méthodes de classe...........................................................................................................35
1. Attributs de classe................................................................................................................................35
2. Méthodes de classe...............................................................................................................................35
V. Relations entre classes..............................................................................................................................38
1. Relation d’utilisation............................................................................................................................38
2. Héritage.................................................................................................................................................39
3. Agrégation :..........................................................................................................................................43
4. Association :..........................................................................................................................................43
Héritage et polymorphisme.........................................................................................................................45
 I. Calculs et variables python
1. Python c'est quoi ?
Python est un langage de programmation inventé par Guido van Rossum. La première
version de python est sortie en 1991.

Python est un langage de programmation interprété, c'est à dire qu'il n'est pas nécessaire
de le compiler avant de l'exécuter. Si vous avez déjà touché un peu à la programmation,
vous verrez que ce langage possède une certaine poésie. Les programmeurs s'amusent
souvent à trouver la manière la plus jolie/efficace d'écrire une suite d'instructions. Rares
sont ceux qui critiquent la logique Python -contrairement à javascript par exemple-.

2. Que fait Python ?

Python est à la fois simple et puissant, il vous permet d'écrire des scripts très simples
mais grâce à ses nombreuses bibliothèques, vous pouvez travailler sur des projets plus
ambitieux.

* Web : Aujourd'hui python combiné avec le framework Django est un très bon choix
technologique pour des gros projets de sites internet.

* Système : Python est également souvent utilisé par les "admin système" pour créer des
tâches dites répétitives ou simplement de maintenance. D'ailleurs si vous voulez créer des
applications java en codant en python, c'est possible grâce au projet Jython.

3. Pourquoi préférer Python aux autres langages ?

Python est un langage facile à apprendre et son code est plus lisible, il est donc plus facile
à maintenir. Il est parfois jusqu'à 5 fois plus concis que le langage Java par exemple, ce
qui augmente la productivité du développeur et réduit mécaniquement le nombre de bugs.

Python est également utilisé dans les milieux scientifiques, par exemple la
bioinformatique. Des librairies sont disponibles pour ce domaine comme le module
biopython .

Il existe également des bibliothèques facilitant la création de jeux vidéo en 2D (et 3D)
exemple: pyGame .

4. Qui utilise Python ?

Google (Guido van Rossum a travaillé pour Google de 2005 à 2012), Yahoo, Microsoft,
la Nasa revendique l'utilisation de Python, pour ne citer qu'eux.
 II. Calculs et variables python
1. Calculs
Une des premières fonctionnalités d'un interpréteur est de faire des calculs :
>>> 1+2
3
Vous pouvez ajouter des espaces, cela n'aura pas d’incidences :
>>> 1 + 2
3
Tous les opérateurs sont utilisables :
>>> 1-10
-9
>>> 2*10
20
>>> 100/4
25
>>> 10%4
2
>>> 2**3
8
La double étoile représente l'exposant.
Il existe cependant une erreur à éviter pour les versions Python inférieures à Python 3 :
>>> 10/3
3
Surprise 10/3 = 3. Python raisonne en nombres entiers puisque nous lui avons fourni
deux nombres entiers. Pour avoir un résultat en décimales, il vous faudra utiliser cette
syntaxe :
>>> 10.0/3
3.3333333333333335
>>> 10/3.0
3.3333333333333335

2. Les variables
Une variable est une sorte de boite virtuelle dans laquelle on peut mettre une (ou
plusieurs) donnée(s). L'idée est de stocker temporairement une donnée pour travailler
avec. Pour votre machine une variable est une adresse qui indique l'emplacement de la
mémoire vive où sont stockées les informations que nous avons liées avec.

Affectons une valeur à la variable "age" que nous allons ensuite afficher :
>>> age = 30
>>> age
30
On va ensuite ajouter 10 à la valeur de cette variable :
>>> age = 30
>>> age = age + 10
>>> age
40
Il est possible de mettre une variable dans une autre variable.
>>> age = 30
>>> age2 = age
>>> age2
30
Vous pouvez mettre à peu près tout ce que vous voulez dans votre variable, y compris du
texte :
>>> age = "J'ai 30 ans"
>>> age
"J'ai 30 ans"
Il est possible de concaténer, c'est à dire d'ajouter du texte à du texte :
>>> age = age + " et je suis encore jeune !"
>>> age
"J'ai 30 ans et je suis encore jeune !"
Vous pouvez même multiplier une chaine de caractères :
>>> age = "jeune"
>>> age * 3
'jeunejeunejeune'
Evidemment, si vous essayez de faire des additions avec des variables qui sont des
chiffres et d'autres qui sont du texte, l'interpréteur va vous gronder :
>>> age = "J'ai 30 ans"
>>> age
"J'ai 30 ans"
>>> age + 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
Vous remarquez que l'interpréteur est sympa puisqu'il vous dit ce qui ne va pas : Il ne
peut pas concaténer str et int.

3. Echapper les quotes

Comment inclure le caractère quote puisqu'il indique un début de données et en fin de
données ?
>>> texte = "Bonjour je m'appelle \"Olivier\""
>>> texte
Bonjour je m'appelle "Olivier"
ou
>>> texte = 'Bonjour je m\'appelle "Olivier"'
>>> texte
'Bonjour je m\'appelle "Olivier"'
Il existe une autre manière de stocker du texte dans une variable : l'utilisation d'un triple
quote. Cela permet de ne pas échapper les caractères quotes des données
>>> texte = """
... Bonjour je m'appelle "olivier"
... """
>>> texte
'\nBonjour je m\'appelle "olivier"\n'

4. Nommer une variable

Vous ne pouvez pas nommer les variables comme bon vous semble, puisqu'il existe déjà
des mots utilisés par Python. Voici la liste des mots réservé par python :
Print in and or if del for is raise assert
elif from lambda return break else global not try class
except while continue exec import pass yield def finally

Ces mots réservés servent à faire autre chose que nous verrons quoi plus en détail dans
les prochains chapitres.
Pour nommer une variable vous devez obligatoirement utiliser les lettres de l'alphabet, les
chiffres et le caractère "_" et "-". N'utilisez pas les accents, ni les signe de ponctuation ou
le signe @. De plus les chiffres ne doivent jamais se trouver en première position dans
votre variable :
>>> 1var = 1
File "<stdin>", line 1
1var = 1
^
SyntaxError: invalid syntax
Comme vous le remarquez, python refuse ce genre de syntaxe, mais il acceptera var1 =
1.

5. Les types de variables

En python une variable est typée, c'est à dire qu'en plus d'une valeur, une variable
possède une sorte d'étiquette qui indique ce que contient cette boite virtuelle.
Voici une liste de type de variable :
 Les integer ou nombres entiers : comme son nom l'indique un entier est un chiffre
sans décimales.
 Les float ou nombre à virgules : exemple : 1.5
 Les strings ou chaine de caractères : pour faire simple tout ce qui n'est pas
chiffre.
Il en existe plein d'autres mais il est peut-être encore un peu trop tôt pour vous en parler.
Pour connaitre le type d'une variable, vous pouvez utiliser la fonction "type ()"
>>> v = 15
>>> type(v)
<type 'int'>
>>> v = "Olivier"
>>> type(v)
<type 'str'>
>>> v = 3.2
>>> type(v)
<type 'float'>
 [Link] ELIF ELSE Python Conditions
Cette notion est l'une des plus importantes en programmation. L'idée est de dire que si
telle variable a telle valeur alors faire cela sinon cela.
Prenons un exemple, on va donner une valeur à une variable et si cette valeur est
supérieure à 5, alors on va incrémenter la valeur de 1.
>>> a = 10
>>> if a > 5:
... a = a + 1
...
>>> a
11
Que se passe-t-il si la valeur était inférieure à 5 ?
>>> a = 3
>>> if a > 5:
... a = a + 1
>>> a
3
On remarque que si la condition n'est pas remplie, les instructions dans la structure
conditionnelle sont ignorées.

1. Condition if else
Il est possible de donner des instructions quel que soit les choix possibles avec le mot clé
else.
>>> a = 20
>>> if a > 5:
... a = a + 1
... else:
... a = a - 1
...
>>> a
21
Changeons uniquement la valeur de la variable a:
>>> a = 3
>>> if a > 5:
... a = a + 1
... else:
... a = a - 1
...
>>> a
2
 2. Condition elif
Il est possible d'ajouter autant de conditions précises que l'on souhaite en ajoutant le mot
clé elif, contraction de "else" et "if", qu'on pourrait traduire par "sinon".
>>> a = 5
>>> if a > 5:
... a = a + 1
... elif a == 5:
... a = a + 1000
... else:
... a = a - 1
...
>>> a
1005
Dans cet exemple, on a repris le même que les précédent mais nous avons ajouté la
condition "Si la valeur est égale à 5" que se passe-t-il ? Et bien on ajoute 1000.

3. Les comparaisons possibles

Il est possible de comparer des éléments :
== égal à
!= différent de (fonctionne aussi avec )
> strictement supérieur à
>= supérieur ou égal à
< strictement inférieur à
<= inférieur ou égal à

4. Comment fonctionnent les structures conditionnelles ?

Les mots clé if, elif et else cherchent à savoir si ce qu'on leur soumet est True. En anglais
True signifie que "Vrai". Donc si c'est la valeur est True, les instructions concernant la
condition seront exécutées.
Comment savoir si la valeur qu'on soumet à l'interpréteur est Tue ? Il est possible de le
voir directement dans l'interpréteur.
Demandons à python si 3 est égal à 4 :
>>> 3 == 4
False
Il vous répondra gentiment que c'est False, c'est à dire que c'est faux.
Maintenant on va donner une valeur à une variable est on va lui demander si la valeur
correspond bien à ce que l'on attend.
>>> a = 5
>>> a == 5
True
 5. AND / OR
Il est possible d'affiner une condition avec les mots clé AND qui signifie "ET" et OR qui
signifie "OU".
On veut par exemple savoir si une valeur est plus grande que 5 mais aussi plus petite que
10:
>>> v = 15
>>> v > 5 and v < 10
False
Essayons avec la valeur 7:
>>> v = 7
>>> v > 5 and v < 10
True
Pour que le résultat soit TRUE, il faut que les deux conditions soient remplies
Testons maintenant la condition OR
>>> v = 11
>>> v > 5 or v > 100
True
Le résultat est TRUE parce qu'au moins une des deux conditions est respectée.
>>> v = 1
>>> v > 5 or v > 100
False
Dans ce cas aucune condition n'est respectée, le résultat est donc FALSE.

6. Chainer les comparateurs

Il est également possible de chainer les comparateurs :
>>> a, b, c = 1, 10, 100
>>> a < b < c
True
>>> a > b < c
False
 IV. Les boucles for et while Python
Une boucle (ou loop ) vous permet de répéter à l'infini des instructions selon vos besoins.

1. La boucle while
En anglais "while" signifie "Tant que". Pour créer une boucle, il faut donc utiliser ce mot
clé suivi d'une indication qui dit quand la boucle s'arrête.
Un exemple sera plus parlant :
On désire écrire 100 fois cette phrase :
"Je ne dois pas poser une question sans lever la main"
Ecrire à la main prend beaucoup de temps et beaucoup de temps x 100 c'est vraiment
beaucoup de temps, et peu fiable, même pour les chanceux qui connaissent le copier-
coller. Et un bon programmeur est toujours un peu fainéant perfectionniste, il cherchera
la manière la plus élégante de ne pas répéter du code.
>>> i = 0
>>> while i < 10:
... print("Je ne dois pas poser une question sans lever la main")
... i = i +1

Je ne dois pas poser une question sans lever la main

Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main
Je ne dois pas poser une question sans lever la main

2. La boucle for
La boucle for permet de faire des itérations sur un élément, comme une chaine de
caractères par exemple ou une liste.
Exemple :
>>> v = "Bonjour toi"
>>> for lettre in v:
... print (lettre)
...
B
o
n
j
o
u
r

t
o
i

3. Range
Il est possible de créer une boucle facilement avec range :
for i in range(0,100):
print (i)

4. Stopper une boucle avec break

Pour stopper immédiatement une boucle on peut utiliser le mot clé break :
>>> liste = [1,5,10,15,20,25]
>>> for i in liste:
... if i > 15:
... print ("On stoppe la boucle")
... break
... print (i)
...
1
5
10
15
On stoppe la boucle
 V. Les fonctions python
Une fonction (ou function) est une suite d'instructions que l'on peut appeler avec un
nom.
1. Créer ma première fonction
Créons une fonction qui nous retournera un âge :
>>> def indique_mon_age():
... return 30;
...
>>> indique_mon_age()
30
Vous ne pouvez pas copier-coller ce code, vous devez entrer chaque ligne à la main et
appuyer sur entrée pour retourner à la ligne. Les 3 chevrons et les 3 points sont affichés
par l'interpréteur python.
Tout d'abord pour indiquer à l'interpréteur que vous voulez créer une fonction, on
utiliser le mot clé def suivi d'un nom puis de parenthèses et ensuite d'un double point.
On remarque également qu'il y a un espace entre les 3 points et le mot clé "return", il
s'agit d'une indentation, c'est à dire un espace qui améliore non seulement la lecture de la
fonction mais qui indique que nous sommes toujours dans la fonction. Lorsque l'action
demandée n'est plus dans la fonction, il ne faut plus indenter le texte. Pour indenter du texte, vous
devez appuyer sur la touche TAB de votre clavier (ou dans d'autres cas créer 4 espaces
manuellement).

2. Les fonctions paramétrées

Créons une autre fonction :
>>> def augmente_moi(a):
... return a + 2
...
>>> augmente_moi(1)
3

Cette fonction incrémente de 2 une valeur que l'on passe en paramètre.

Il est d'ailleurs possible d'utiliser plusieurs paramètres :

>>> def augmente_moi(a, b):

... return 30 + a + b
...
>>> augmente_moi(1, 2)
33

Si vous avez compris les principes des fonctions, vous avez compris 80% de ce qu'est la
programmation.
 3. Un paramètre est obligatoire
Lorsque vous indiquez des paramètres à une fonction, ces derniers doivent
impérativement être renseignés sans quoi une erreur apparaitra.
>>> def augmente_moi(a, b):
... return 30 + a + b
...
>>> augmente_moi(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: augmente_moi() takes exactly 2 arguments (1 given)

4. Portée des variables (variable globale et variable locale)

Une variable déclarée à la racine d'un module est visible dans tout ce module. On parle
alors de variable globale.
>>> x = "hello"
>>> def test():
... print x
...
>>> test()
hello
Et une variable déclarée dans une fonction ne sera visible que dans cette fonction. On
parle alors de variable locale.
>>> x = False
>>> def test():
... x = "hello"
...
>>> test()
>>> x
False

5. Procédure et fonctions
Pour votre culture informatique sachez qu'une fonction n'est pas obligée de renvoyer une
valeur, on parlera alors dans ce cas plutôt de procédure.
 VI. Les listes python
Les listes (ou list / array) en python sont une variable dans laquelle on peut mettre
plusieurs variables.
1. Créer une liste en python
Pour créer une liste, rien de plus simple :
>>> liste = []
Vous pouvez voir le contenu de la liste en l'appelant comme ceci :
>>> liste
<type 'list'>
2. Ajouter une valeur à une liste python
Vous pouvez ajouter les valeurs que vous voulez lors de la création de la liste python:
>>> liste = [1,2,3]
>>> liste
[1, 2, 3]
Ou les ajouter après la création de la liste avec la méthode append (qui signifie "ajouter"
en anglais):
>>> liste = []
>>> liste
[]
>>> [Link](1)
>>> liste
[1]
>>> [Link]("ok")
>>> liste
[1, 'ok']
On voit qu'il est possible de mélanger dans une même liste des variables de type
différent. On peut d'ailleurs mettre une liste dans une liste.

3. Afficher un item d'une liste

Pour lire une liste, on peut demander à voir l'index de la valeur qui nous intéresse :
>>> liste = ["a","d","m"]
>>> liste[0]
'a'
>>> liste[2]
'm'
Le premier item commence toujours avec l'index 0. Pour lire le premier item on utilise la
valeur 0, le deuxième on utilise la valeur 1, etc.
Il est d'ailleurs possible de modifier une valeur avec son index
>>> liste = ["a","d","m"]
>>> liste[0]
'a'
>>> liste[2]
'm'
>>> liste[2] = "z"
>>> liste
['a', 'd', 'z']
4. Supprimer une entrée avec un index
Il est parfois nécessaire de supprimer une entrée de la liste. Pour cela vous pouvez utiliser
la fonction del.
>>> liste = ["a", "b", "c"]
>>> del liste[1]
>>> liste
['a', 'c']
5. Supprimer une entrée avec sa valeur
Il est possible de supprimer une entrée d'une liste avec sa valeur avec la méthode
remove.
>>> liste = ["a", "b", "c"]
>>> [Link]("a")
>>> liste
['b', 'c']
6. Inverser les valeurs d'une liste
Vous pouvez inverser les items d'une liste avec la méthode reverse.
>>> liste = ["a", "b", "c"]
>>> [Link]()
>>> liste
['c', 'b', 'a']
7. Compter le nombre d'items d'une liste
Il est possible de compter le nombre d'items d'une liste avec la fonction len.
>>> liste = [1,2,3,5,10]
>>> len(liste)
5

8. Compter le nombre d'occurrences d'une valeur

Pour connaitre le nombre d'occurrences d'une valeur dans une liste, vous pouvez utiliser
la méthode count.
>>> liste = ["a","a","a","b","c","c"]
>>> [Link]("a")
3
>>> [Link]("c")
2
9. Trouver l'index d'une valeur
La méthode index vous permet de connaitre la position de l'item cherché.
>>> liste = ["a","a","a","b","c","c"]
>>> [Link]("b")
3
10. Manipuler une liste
Voici quelques astuces pour manipuler des listes :
>>> liste = [1, 10, 100, 250, 500]
>>> liste[0]
1
>>> liste[-1] # Cherche la dernière occurrence
500
>>> liste[-4:] # Affiche les 4 dernières occurrences
[500, 250, 100, 10]
>>> liste[:] # Affiche toutes les occurrences
[1, 10, 100, 250, 500]
>>> liste[2:4] = [69, 70]
[1, 10, 69, 70, 500]
>>> liste[:] = [] # vide la liste
[]
11. Boucler sur une liste
Pour afficher les valeurs d'une liste, on peut utiliser une boucle :
>>> liste = ["a","d","m"]
>>> for lettre in liste:
... print lettre
...
a
d
m
Si vous voulez en plus récupérer l'index, vous pouvez utiliser la fonction enumerate.
>>> for lettre in enumerate(liste):
... print lettre
...
(0, 'a')
(1, 'd')
(2, 'm')
Les valeurs retournées par la boucle sont des tuples.

12. Copier une liste

Beaucoup de débutants commettent l'erreur de copier une liste de cette manière
>>> x = [1,2,3]
>>> y = x
Or si vous changez une valeur de la liste y, la liste x sera elle aussi affectée par cette
modification :
>>> x = [1,2,3]
>>> y = x
>>> y[0] = 4
>>> x
[4, 2, 3]
En fait cette syntaxe permet de travailler sur un même élément nommé différemment
Alors comment copier une liste qui sera indépendante ?
>>> x = [1,2,3]
>>> y = x[:]
>>> y[0] = 9
>>> x
[1, 2, 3]
>>> y
[9, 2, 3]
Pour des données plus complexes, vous pouvez utiliser la fonction deepcopy du module
copy

>>> import copy

>>> x = [[1,2], 2]

>>> y = [Link](x)

>>> y[1] = [1,2,3]

>>> x

[[1, 2], 2]

>>> y

[[1, 2], [1, 2, 3]]

13. La fonction range

La fonction range génère une liste composée d'une simple suite arithmétique.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
14. Agrandir une liste par une liste
Pour mettre bout à bout deux listes, vous pouvez utiliser la méthode extend
>>> x = [1, 2, 3, 4]
>>> y = [4, 5, 1, 0]
>>> [Link](y)
>>> print x
[1, 2, 3, 4, 4, 5, 1, 0]
15. Astuces
Afficher les 2 premiers éléments d'une liste
>>> liste = [1,2,3,4,5]
>>> liste[:2]
[1, 2]
Afficher le dernier item d'une liste :
>>> liste = [1, 2, 3, 4, 5, 6]
>>> liste[-1]
6
Afficher le 3ème élément en partant de la fin :
>>> liste = [1, 2, 3, 4, 5, 6]
>>> liste[-3]
4
Afficher les 3 derniers éléments d'une liste :
>>> liste = [1, 2, 3, 4, 5, 6]
>>> liste[-3:]
[4, 5, 6]
Vous pouvez additionner deux listes pour les combiner ensemble en utilisant l'opérateur
+:
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> x + y
[1, 2, 3, 4, 5, 6]
Vous pouvez même multiplier une liste :
>>> x = [1, 2]
>>> x*5
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
Ce qui peut être utile pour initialiser une liste :
>>> [0] * 5
[0, 0, 0, 0, 0]
 VII. Les tuples python
Un tuple est une liste qui ne peut plus être modifiée.

1. Créer un tuple
Pour créer un tuple, vous pouvez utiliser la syntaxe suivante :
>>> mon_tuple = ()

2. Ajouter une valeur à un tuple

Pour créer un tuple avec des valeurs, vous pouvez le faire de cette façon :
>>> mon_tuple = (1, "ok", "olivier")
Les parenthèses ne sont pas obligatoires mais facilite la lisibilité du code (rappelons que
la force de python est sa simplicité de lecture):
>>> mon_tuple = 1, 2, 3
>>> type(mon_tuple)
<type 'tuple'>
Lorsque vous créez un tuple avec une seule valeur, n'oubliez pas d'y ajouter une virgule,
sinon ce n'est pas un tuple.
>>> mon_tuple = ("stop")
>>> type(mon_tuple)
<type 'str'>
>>> mon_tuple = ("stop",)
>>> type(mon_tuple)
<type 'tuple'>

3. Afficher une valeur d'un tuple

Le tuple est une sorte de liste, on peut donc utiliser la même syntaxe pour lire les données
du tuple.
>>> mon_tuple[0]
1
Et évidemment si on essaie de changer la valeur d'un index, l'interpréteur nous insulte
copieusement:
>>> mon_tuple[1] = "ok"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

4. A quoi sert un tuple alors ?

Le tuple permet une affectation multiple :
>>> v1, v2 = 11, 22
>>> v1
11
>>> v2
22
Il permet également de renvoyer plusieurs valeurs lors d'un appel d'une fonction :
>>> def donne_moi_ton_nom():
... return ("olivier", "engel")
...
>>> donne_moi_ton_nom()
('olivier', 'engel')
On utilisera un tuple pour définir des sortes de constantes qui n'ont donc pas vocation à
changer.
 [Link] dictionnaires python
Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des index, on
utilise des clés, c'est à dire des valeurs autres que numériques.

1. Comment créer un dictionnaire ?

Pour initialiser un dictionnaire, on utile la syntaxe suivante :
>>> a = {}

2. Comment ajouter des valeurs dans un dictionnaire ?

Pour ajouter des valeurs à un dictionnaire il faut indiquer une clé ainsi qu'une valeur :
>>> a = {}
>>> a["nom"] = "YAO"
>>> a["prenom"] = "olivier"
>>> a
{'nom': 'YAO', 'prenom': 'olivier'}
Vous pouvez utiliser des clés numériques comme dans la logique des listes.

3. Récupérer une valeur dans un dictionnaire

La méthode get vous permet de récupérer une valeur dans un dictionnaire et si la clé est
introuvable, vous pouvez donner une valeur à retourner par défaut :
>>> data = {"name": "Olivier", "age": 30}
>>> [Link]("name")
'Olivier'
>>> [Link]("adresse", "Adresse inconnue")
'Adresse inconnue'

4. Supprimer une entrée de dictionnaire

Il est possible de supprimer une entrée en indiquant sa clé, comme pour les listes :
>>> del a["nom"]
>>> a
{'prenom': 'olivier'}
5. Récupérer les valeurs par une boucle
Pour cela on utilise la méthode "values"
>>> fiche = {"nom":"YAO","prenom":"olivier"}
>>> for valeur in [Link]():
... print valeur
...
YAO
olivier

PROG
RAMM
ATION
ORIEN
TEE
OBJET
 I. Introduction à la Programmation Orientée Objet
1. Qu’est-ce que la Programmation Orientée Objet (POO)
La POO est un paradigme de programmation informatique élaboré par Alan Kay, dans les années 70, qui
consiste à la définition de briques logicielles (objets) et à leurs interactions entre elles. Autrement dit,
c’est un ensemble d’objets qui communiquent entre eux par échange de messages.
2. Vers la Programmation Orientée Objet

2.1. Pourquoi la POO ?

Depuis plusieurs années, le coût des dépenses informatiques ne dépend plus du matériel mais du
développement d’application qui est de plus en plus performant et complexe. Par conséquent le coût
devient de plus en plus élevé.

L’objectif de la POO est de diminuer le coût du logiciel et d’augmenter sa durée de vie, sa

réutilisabilité et sa facilité de maintenance.

2.2. Introduction à la POO

Nous avons vu plusieurs types de base en Python (int pour les entiers, float pour les flottants, str pour
les chaînes de caractères, etc.). La notion de classe va en quelque sorte nous permettre de généraliser la
notion de « type » afin de créer de nouvelles structures de données.

Une classe définit des attributs et des méthodes. Par exemple, imaginons une classe Voiture qui
servira à créer des objets qui sont des voitures. Cette classe va pouvoir définir un attribut couleur, un
attribut vitesse, etc. Ces attributs correspondent à des propriétés qui peuvent exister pour une voiture. La
classe Voiture pourra également définir une méthode rouler(). Une méthode correspond en quelque
sorte à une action, ici l’action de rouler peut-être réalisée pour une voiture. Si on imagine une classe
Avion, elle pourra définir une méthode voler(). Elle pourra aussi définir une méthode rouler(). Par
contre, la classe Voiture n’aura pas de méthode voler() car une voiture ne peut pas voler. De même, la
classe Avion pourra avoir un attribut altitude mais ce ne sera pas le cas pour la classe Voiture.

3. Concepts de Classes et objets

Une Classe est un moule pour créer des données appelées objets. La classe spécifie l’état et le
comportement des objets qui équivalent à un type équipé des opérations pour en manipuler les données.
Un Objet est une donnée créée à partir d’une classe (instance d’une classe). Un objet a :
 une identité : distinguer deux objets différents
o p1 et p2 sont deux objets différents, instances de la même classe Point
o en général, l’identité est l’adresse de l’objet en mémoire
 un état : informations propres à un objet, décrites par les attributs/champs
o exemple : l’abscisse, l’ordonnée
o propre à chaque objet : p1 et p2 ont un état différent
 un comportement : décrit les évolutions possibles de l’état d’un objet sous la forme
d’opérations (sous-programmes) qui lui sont applicables
o exemples : déplace, etc.
o une opération manipule l’état de l’objet
  Un objet est créé à partir d’une classe (en précisant les paramètres effectifs de son constructeur,
sauf self).
o Point(4, 10) # création d’un objet Point
o retourne l’identité de l’objet créé
 En Python, les objets sont soumis à la sémantique de la référence :
o la mémoire qu’ils occupent est allouée dans le tas (pas dans la pile d’exécution)
o seule leur identité permet de les désigner
 Les identités des objets sont conservées dans des variables.

Remarque : On ne sait pas dans quel ordre les opérations seront appelées. Mais il faut commencer par
initialiser l’objet : c’est le rôle du constructeur (initialiser).

4. Les trois grands principes de la POO

 Encapsulation : rassembler les données et méthodes au sein d’une structure
 en cachant l’implantation de l’objet (à l’utilisateur, au moins) ;
 protection de l’accès aux données mécanisme d’accès / modification ;
 augmentation la sécurité d’une application ;
 facilité de maintenance de l’application ;

 Héritage : permettre la création d’une classe (dérivée) à partir d’une classe existante (sper-classe)
 la classe dérivée (fille) contient sous certaines conditions les attributs et les méthodes de la classe
mère (super-classe) ;
 permet ainsi la réutilisation de code ;
 plusieurs types d’héritage : public, protégé, ou privé ;

 Polymorphisme : permettre de redéfinir dans une classe dérivée les méthodes dont elle hérite de sa
classe mère. On dit que la même méthode possède alors plusieurs formes.
 II. Programmation de la classe et de l’objet
1. Principe et syntaxe de définition d’une classe
Une classe définit :
 un Unité d’encapsulation : elle regroupe la déclaration des attributs et la définition des
méthodes associées dans une même construction syntaxique.
class NomDeLaClasse:
# Définition de ses caractéristiques
 attributs = stockage d’information (état de l’objet).
 méthodes = unités de calcul (sous-programmes : fonctions ou procédures).
C’est aussi un espace de noms :
 deux classes différentes peuvent avoir des membres de même nom
 un TYPE qui permet de :
 créer des objets (la classe est un moule, une matrice) ;
Les méthodes et attributs définis sur la classe comme « unité d’encapsulation » pourront être appliqués à
ses objets.
2. Définition d’une classe exemple : « Point »
Voici comment définir une classe appelée ici Point.

class Point:
"Définition d'un point géométrique"

Par convention en Python, le nom identifiant une classe (qu’on appelle aussi son identifiant) débute par
une majuscule. Ici Point débute par un P majuscule.
3. Création d’un objet de type « Point »
Point()
Ceci crée un objet de type Point. En POO, on dit que l’on crée une instance de la classe Point.
Une phrase emblématique de la POO consiste à dire qu’un objet est une instance de classe.
Il faut bien noter que pour créer une instance, on utilise le nom de la classe suivi de parenthèses. Nous
verrons par la suite qu’il peut y avoir des arguments entre ces parenthèses.
4. Affectation à une variable de la référence à un objet

Nous venons de définir une classe Point. Nous pouvons dès à présent nous en servir pour créer des
objets de ce type, par instanciation. Créons par exemple un nouvel objet et mettons la référence à cet
objet dans la variable p :

>>> p = Point()
Avertissement
Comme pour les fonctions, lors de l’appel à une classe dans une instruction pour créer un objet, il faut
toujours indiquer des parenthèses (même si aucun argument n’est transmis). Nous verrons un peu plus
loin que ces appels peuvent se faire avec des arguments (voir la notion de constructeur).
Remarquez bien cependant que la définition d’une classe ne nécessite pas de parenthèses (contrairement
à ce qui de règle lors de la définition des fonctions), sauf si nous souhaitons que la classe en cours de
définition dérive d’une autre classe préexistante (ceci sera expliqué plus loin).

Nous pouvons dès à présent effectuer quelques manipulations élémentaires avec notre nouvel objet dont
la référence est dans p.

Exemple :
>>> print(p)
<__main__.Point instance at 0x012CAF30>

Le message renvoyé par Python indique que p contient une référence à une instance de la classe Point,
qui est définie elle-même au niveau principal du programme. Elle est située dans un emplacement bien
déterminé de la mémoire vive, dont l’adresse apparaît ici en notation hexadécimale.

>>> print(p.__doc__)
Définition d'un point géométrique

On peut noter que les chaînes de documentation de divers objets Python sont associées à l’attribut
prédéfini _ _doc_ _:

Exemple avec deux objets :

a = Point()
b = Point()
La variable a va contenir une référence à un objet.
>>> print(a)
<__main__.Point instance at 0x012CADC8>
De même b va contenir une référence à un autre objet.
>>> print(b)
<__main__.Point instance at 0x012CAF08>

Nous avons ici 2 instances (2 objets) de la classe Point.

 la première à laquelle on fait référence au moyen de la variable a,

 la seconde à laquelle on fait référence au moyen de la variable b.

On fait bien ici la distinction entre classe et objet. Ici nous avons une seule classe Point, et deux objets
de type Point.

5. Définition des attributs

class Point:
"Définition d'un point géométrique"

p = Point()
p.x = 1
p.y = 2
print("p : x =", p.x, "y =", p.y)

La syntaxe pour accéder à un attribut est la suivante : on va utiliser la variable qui contient la référence à
l’objet et on va mettre un point «.» puis le nom de l’attribut.

Exemple :
class Point:
"Définition d'un point géométrique"

a = Point()
a.x = 1
a.y = 2
b = Point()
b.x = 3
b.y = 4
print("a : x =", a.x, "y =", a.y)
print("b : x =", b.x, "y =", b.y)

Distinction entre variable et objet

L’exemple suivant montre bien la distinction entre variable et objet :

class Point:
"Définition d'un point géométrique"

a = Point()
a.x = 1
a.y = 2
b=a
print("a : x =", a.x, "y =", a.y)
print("b : x =", b.x, "y =", b.y)
a.x = 3
a.y = 4
print("a : x =", a.x, "y =", a.y)
print("b : x =", b.x, "y =", b.y)

6. Définition des méthodes

class Point:
def deplace(self, dx, dy):
self.x = self.x + dx
self.y = self.y + dy
Cette classe possède une méthode : deplace().

- Pour définir une méthode, il faut :

1. indiquer son nom (ici deplace()).

2. indiquer les arguments entre des parenthèses. Le premier argument d’une méthode doit être
self.

- Pour accéder aux méthodes d’un objet, on indique :

1. le nom de la variable qui fait référence à cet objet

2. un point
3. le nom de la méthode

[Link](3, 5)

Avertissement

Lors de l’appel de la méthode, le paramètre self n’est pas utilisé et la valeur qu’il prend est la référence à
l’objet. Il y a donc toujours un paramètre de moins que lors de la définition de la méthode.

Exemple:
class Point:
def deplace(self, dx, dy):
self.x = self.x + dx
self.y = self.y + dy

a = Point()
a.x = 1
a.y = 2
print("a : x =", a.x, "y =", a.y)
[Link](3, 5)
print("a : x =", a.x, "y =", a.y)

NB : Quelques méthodes particulières

 _ _init_ _ : le constructeur : méthode d’initialisation nécessairement appelée quand on crée
un objet. C’est le constructeur qui devrait définir les attributs d’instance de la classe.
 _ _del_ _(self) : le destructeur, appelé quand une instance est sur le point d’être détruite.
 _ _repr_ _(self) : chaîne représentant cet objet et qui devrait correspondre (quand c’est
possible) à une expression Python valide pour créer l’objet.
 _ _str_ _(self) : utilisée par str() pour obtenir la représentation sous forme d’une chaîne de
caractères de l’objet. Elle remplace avantageusement la méthode "afficher !
 _ _new_ _(cls, ...) : méthode implicitement statique qui crée l’objet (et appelle __init__).
 _ _bool_ _(self) : utilisée quand l’objet est considéré comme booléen et avec la fonction
prédéfinie bool().
 _ _eq_ _ : définir l’égalité logique (==) entre objet
(par opposition à l’égalité physique, comparaison des identités, id(o1) == id(o2))
 7. La notion de constructeur
Si lors de la création d’un objet nous voulons qu’un certain nombre d’actions soit réalisées (par exemple
une initialisation), nous pouvons utiliser un constructeur.

Un constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, qui porte un nom imposé par
le langage Python : _ _init_ _(). Ce nom est constitué de init entouré avant et après par _ _ (deux fois le
symbole underscore _, qui est le tiret sur la touche 8). Cette méthode sera appelée lors de la création de
l’objet. Le constructeur peut disposer d’un nombre quelconque de paramètres, éventuellement aucun.

Exemple sans paramètre :

class Point:
def __init__(self):
self.x = 0
self.y = 0

a = Point()
print("a : x =", a.x, "y =", a.y)
a.x = 1
a.y = 2
print("a : x =", a.x, "y =", a.y)

Dans cet exemple, nous avons pu définir des valeurs par défaut pour les attributs grâce au constructeur.

Exemple avec paramètres :

class Point:
def __init__(self, abs, ord):
self.x = abs
self.y = ord
a = Point(1, 2)
print("a : x =", a.x, "y =", a.y)

Autre exemple avec paramètres :

Dans l’exemple suivant, on utilise les mêmes noms pour les paramètres du constructeur et les attributs.
Ceci ne pose pas de problème car ces variables ne sont pas dans le même espace de noms. Les
paramètres du constructeur sont des variables locales, comme c’est habituellement le cas pour une
fonction. Les attributs de l’objet sont eux dans l’espace de noms de l’instance. Les attributs se
distinguent facilement car ils ont self devant.
class Point:
def _ _init_ _(self, x, y):
self.x = x
self.y = y

a = Point(1, 2)
print("a : x =", a.x, "y =", a.y)

Exemple complet
class Point:
def _ _init_ _(self, x, y):
self.x = x
self.y = y

def deplace(self, dx, dy):

self.x = self.x + dx
self.y = self.y + dy

a = Point(1, 2)
b = Point(3, 4)
print("a : x =", a.x, "y =", a.y)
print("b : x =", b.x, "y =", b.y)
[Link](3, 5)
[Link](-1, -2)
print("a : x =", a.x, "y =", a.y)
print("b : x =", b.x, "y =", b.y)

Exercice1 :
Modifier le programme de façon à ajouter deux autres objets de type Point. Ils seront référencés par des
variables c et d.

Exercice2 :
Définir une classe Point3D qui sera analogue à la classe Point mais pour des points dans l’espace à 3
dimensions. Créer deux objets de type Point3D qui seront référencés par les variables a3D et b3D.
Initialiser ces points et afficher leurs coordonnées x, y, z.
 III. La notion d’encapsulation
Le concept d’encapsulation est un concept très utile de la POO. Il permet en particulier d’éviter une
modification par erreur des données d’un objet. En effet, il n’est alors pas possible d’agir directement
sur les données d’un objet ; il est nécessaire de passer par ses méthodes qui jouent le rôle d’interface
obligatoire.

1. Définition d’attributs privés

On réalise la protection des attributs de notre classe Point grâce à l’utilisation d’attributs privés. Pour
avoir des attributs privés, leur nom doit débuter par _ _ (deux fois le symbole underscore _, qui est le
tiret sur la touche 8).

Protection d'attributs :
En Python tous les attributs sont des attributs publics donc accessibles à partir d'autres classes.
L'encapsulation n'est donc pas respectée.
Mais il est possible de brouiller l'accès à un attribut en le nommant comme suit : __nomAttribut
Un attribut brouillé est renommé automatiquement à _NomClasse _NomAttribut

class Point:
def _ _init_ _(self, x, y):
self._ _x = x
self._ _y = y

Il n’est alors plus possible de faire appel aux attributs _ _x et _ _y depuis l’extérieur de la classe Point.

>>> p = Point(1, 2)
>>> p.__x

Traceback (most recent call last):

File "<pyshell#9>", line 1, in
p.__x
AttributeError: Point instance has no attribute '__x'

Il faut donc disposer de méthodes qui vont permettre par exemple de modifier ou d’afficher les
informations associées à ces variables.
class Point:
def __init__(self, x, y):
self.__x = x
self.__y = y

def deplace(self, dx, dy):

self.__x = self.__x + dx
self.__y = self.__y + dy

def affiche(self):
print("abscisse =", self.__x, "ordonnee =", self.__y)
a = Point(2, 4)
[Link]()
[Link](1, 3)
[Link]()

2. Accesseurs et mutateurs

Parmi les différentes méthodes que comporte une classe, on a souvent tendance à distinguer :
 les constructeurs ;
 les accesseurs (en anglais accessor) qui fournissent des informations relatives à l’état d’un objet,
c’est-à-dire aux valeurs de certains de ses attributs (généralement privés) sans les modifier ;
 les mutateurs (en anglais mutator) qui modifient l’état d’un objet, donc les valeurs de certains
de ses attributs.

On rencontre souvent l’utilisation de noms de la forme get_XXXX() pour les accesseurs et set_XXXX()
pour les mutateurs, y compris dans des programmes dans lesquels les noms de variable sont francisés.
Par exemple, pour la classe Point sur laquelle nous avons déjà travaillé on peut définir les méthodes
suivantes :

Exemple :
class Point:
def __init__(self, x, y):
self.__x = x
self.__y = y

def get_x(self):
return self.__x

def get_y(self):
return self.__y

def set_x(self, x):

self.__x = x

def set_y(self, y):

self.__y = y

a = Point(3, 7)
print("a : abscisse =", a.get_x())
print("a : ordonnee =", a.get_y())
a.set_x(6)
a.set_y(10)
print("a : abscisse =", a.get_x())
print("a : ordonnee =", a.get_y())

Notez qu’il n’est pas toujours prudent de prévoir une méthode d’accès pour chacun des attributs privés
d’un objet. En effet, il ne faut pas oublier qu’il doit toujours être possible de modifier l’implémentation
d’une classe de manière transparente pour son utilisateur.
 IV. Attributs et méthodes de classe
1. Attributs de classe
Un attribut de classe est un attribut au niveau de la classe dont la valeur est partagée par tous les objets
instanciés à partir de la classe.
L’accès à l’attribut de la classe est données par: [Link]

Exemple :
class A:
Résultats obtenus :
nb = 0
A : nb = 0
def __init__(self, x): Partie 1 :
print("Création objet de type A") Création objet de type A
self.x = x A : nb = 1
[Link] = [Link] + 1 a : x = 3 nb = 1
Partie 2 :
print("A : nb = ", [Link]) Création objet de type A
A : nb = 2
print("Partie 1 :")
a : x = 3 nb = 2
a = A(3) b : x = 6 nb = 2
print("A : nb = ", [Link]) Création objet de type A
print("a : x = ", a.x, " nb = ", [Link]) Partie 3 :
print("Partie 2 :") A : nb = 3
b = A(6) a : x = 3 nb = 3
print("A : nb = ", [Link]) b : x = 6 nb = 3
c : x = 8 nb = 3
print("a : x = ", a.x, " nb = ", [Link])
print("b : x = ", b.x, " nb = ", [Link])
c = A(8)
print("Partie 3 :")
print("A : nb = ", [Link])
print("a : x = ", a.x, " nb = ", [Link])
print("b : x = ", b.x, " nb = ", [Link])
print("c : x = ", c.x, " nb = ", [Link])

2. Méthodes de classe
 Une méthode d’instance est un sous-programme qui exploite l’état d’un objet (en accès et/ou en
modification). Le premier paramètre désigne nécessairement l’objet. Par convention, on l’appelle
self.
 Une méthode de classe est une méthode qui travaille sur la classe (et non l’objet).
o Elle peut s’exécuter sans instancier la classe (pas de création d’objet)
o Elle est décorée @classmethod.
o Son premier paramètre est nommé cls par convention (et non self).
@classmethod
def changer_langue(cls, langue):
if [Link] == ’fr’:
cls._directions = (’Nord’, ’Est’, ’Sud’, ’Ouest’)
else:
 cls._directions = (’North’, ’East’, ’South’, ’West’)
Robot.changer_langue(’en’) # Utilisation

Une méthode statique est une méthode définie dans l’espace de nom de la classe mais est indépendante
de cette classe. Elle est décorée @staticmethod.

class Date:
...
@staticmethod
def est_bissextile(annee):
return annee % 4 == 0 and (annee % 100 != 0 or annee % 400 == 0)

Exemple :
class A:
nb = 0

def __init__(self):
print("creation objet de type A")
[Link] = [Link] + 1
print("il y en a maintenant ", [Link])

@classmethod
def get_nb(cls):
return [Link]

print("Partie 1 : nb objets = ", A.get_nb())

a = A()
print("Partie 2 : nb objets = ", A.get_nb())
b = A()
print("Partie 3 : nb objets = ", A.get_nb())

Pour créer une méthode de classe, il faut la faire précéder d’un « décorateur » : @classmethod

Le premier argument de la méthode de classe doit être cls.

Exemple de propriété : le mois d’une Date

# -*- coding: iso-8859-1 -*-
class Date:
def __init__(self, jour, mois, annee):
self.__jour = jour
self.__mois = mois
self.__annee = annee
@property # accès en lecture à mois, comme si c’était un attribut
def mois(self):
return self.__mois
@[Link] # accès en écriture à mois, comme si c’était un attribut
def mois(self, mois):
 if mois < 1 or mois > 12:
raise ValueError
self.__mois = mois

if __name__ == "__main__":
d1 = Date(25, 4, 2013)
assert [Link] == 4
# d1.__mois # AttributeError: ’Date’ object has no attribute ’__mois’
assert d1._Date__mois == 4 # à ne pas utiliser !
[Link] = 12
assert [Link] == 12
[Link] = 13 # ValueError

class A:
ac = 10 # Attribut de classe
def __init__(self, v):
[Link] = v # ai attribut d’instance
a = A(5) #------------------------------
assert [Link] == 5
assert [Link] == 10
assert [Link] == 10 # on a accès à un attribut de classe depuis un objet
# [Link] # AttributeError: type object ’A’ has no attribute ’ai’
b = A(7) #------------------------------
assert [Link] == 7
assert [Link] == 10
[Link] = 11 #------------------------------
assert [Link] == 11 # normal !
assert [Link] == 5 # ai est bien un attribut d’instance
[Link] = 20 #------------------------------
assert [Link] == 20 # logique !
assert [Link] == 20 # l’attribut de classe est bien partagé par les instances
[Link] = 30 #-------------- Est-ce qu’on modifie l’attribut de classe ac ?
assert [Link] == 30 # peut-être
assert [Link] == 20 # mais non ! [Link] = 30 définit un nouvel attribut d’instance

assert A is type(a) and A is a.__class__ # obtenir la classe d’un objet

 V. Relations entre classes
On souhaite faire un éditeur qui permet de dessiner des points, des segments, des polygones, des cercles,
etc.

On considère la classe Point suivante.

import math
class Point:
def __init__(self, x=0, y=0):
self.x = float(x)
self.y = float(y)

def __str__(self):
return "(%s ; %s)" % (self.x, self.y)

def translater(self, dx, dy):

self.x += dx
self.y += dy

def distance(self, autre):

dx2 = (self.x - autre.x) ** 2
dy2 = (self.y - autre.y) ** 2
return [Link](dx2 + dy2)

1. Relation d’utilisation
Principe : Une classe utilise une autre classe (en général, ses méthodes).

Segment Point
Extrémité1
x
* Extrémité2 y
longueur ()
translater (dx,dy) distance (autre)
afficher () *
translater (dx,dy)
afficher ()

Exemple : La classe Segment utilise la classe Point. Un segment est caractérisé par ses deux points
extrémités :
 le translater, c’est translater les deux points extrémités
 sa longueur est la distance entre ses extrémités
 l’afficher, c’est afficher les deux points extrémités
Remarque : UML définit plusieurs niveaux de relation d’utilisation (dépendance, association,
agrégation et composition) qui caractérisent le couplage entre les classes (de faible à fort).
Programmation de la classe Segment

class Segment:
def __init__(self, e1, e2):
self.extremite1 = e1
self.extremite2 = e2

def __str__(self):
return "[%s - %s]" % (self.extremite1, self.extremite2)

def translater(self, dx, dy):

[Link](dx, dy)
[Link](dx, dy)

def longueur(self):
return [Link](self.extremite2)
Programmation du schéma donné en exemple

def exemple():
# créer les points sommets du triangle
p1 = Point(3, 2)
p2 = Point(6, 9)
p3 = Point(11, 4)
# créer les trois segments
s12 = Segment(p1, p2)
s23 = Segment(p2, p3) Le résultat obtenu :
s31 = Segment(p3, p1)
[(3.0 ; 2.0) - (6.0 ; 9.0)]
# créer le barycentre [(6.0 ; 9.0) - (11.0 ; 4.0)]
sx = (p1.x + p2.x + p3.x) / 3.0 [(11.0 ; 4.0) - (3.0 ; 2.0)]
sy = (p1.y + p2.y + p3.y) / 3.0 (6.666666666666667 ; 5.0)
barycentre = Point(sx, sy)

# construire le schéma
schema = [s12, s23, s31, barycentre];

# afficher le schéma
for elt in schema:
print(elt)

2. Héritage

 Héritage simple

Le principe consiste à définir une nouvelle classe par spécialisation d’une (ou plusieurs) classes
existantes. C’est le mécanisme qui permet de se servir d’une classe préexistante pour en créer une
nouvelle qui possèdera des fonctionnalités supplémentaires ou différentes.

Exemple : Définir une classe PointNommé sachant que la classe Point existe.
La classe PointNommé :
 hérite (récupère) tous les éléments de la classe Point
 ajoute un nom et les opérations pour manipuler le nom
 redéfinit la méthode « afficher » (pour afficher le nom et les coordonnées du point)
Point est la super-classe, PointNommé la sous-classe

Souvent associé au sous-typage : Partout où on attend un Point, on peut mettre un PointNommé.

 Attention, ceci dépend des langages !
 A priori, pas de sens en Python car on peut toujours mettre n’importe quel objet dans n’importe
quelle variable... Mais on aura certainement des erreurs à l’exécution !

 Redéfinition (surcharge):
Donner une nouvelle implantation à une méthode déjà présente dans une super-classe (override, en
anglais). Certains auteurs parlent de surcharge (overload).
Dans l’exemple suivant, nous surchargeons l’opérateur d’addition pour le type Vecteur2D. Nous
surchargeons également la méthode spéciale __str__ utilisée pour l’affichage par print ().

>>> Class Vecteur2D :

… def __init__ (self, x0, y0) :
… self.x = x0
… self.y = y0
… def __add__ (self, second) : # addition vectorielle
… return Vecteur2D (self.x + second.x, self.y + second.y)
… def __str__ (self) : # affichage d’un vecteur2D
… return "Vecteur ({ :g}, { :g})".format (self.x, self.y)
…
>>> v1 = Vecteur2D (1.2, 2.3)
>>> v2 = Vecteur2D (3.4, 4.5)
>>>
>>> print (v1 + v2)
Vecteur (4.6, 6.8)

 Polymorphisme :
Plusieurs formes pour la même méthode. Plusieurs versions de la méthode afficher dans PointNommé,
la sienne et celle de Point. C’est la faculté pour deux méthodes (ou plus) portant le même nom, mais
appartenant à des classes héritées distinctes un travail différent. Cette propriété est acquise par la
technique de la surcharge.

Exemple d’héritage et de polymorphisme :

Dans cet exemple suivant, la classe QuadrupedeDebout hérite de la classe mère Quadrupede, et la
méthode piedsAuContactDuSol () est polymorphe :
 >>> Class Quadrupede :
… def piedsAuContactDuSol (self) :
… return 4
…
>>> Class QuadrupedeDebout (Quadrupede ) :
… def piedsAuContactDuSol (self) :
… return 2
…
>>> chat = Quadrupede ()
>>> [Link] ()
4
>>> homme = QuadrupedeDebout ()
>>> [Link] ()
2

Notation et vocabulaire :
Notation UML : Point
x
Point Classe parente
y
Classe de base
Super classe distance(autre)
translater(dx,dy)
afficher()
Relation d’héritage (Python)
Spécialisation/génération (UML)

PointNommé PointNomme
Classe fille
Classe dérivée nom
Sous-classe
nommer(nouveau)
afficher()
Notation en Python :
Class PointNommé(Point) : #PointNommé hérite de Point
La classe PointNommé
class PointNomme(Point): # La classe PointNommé hérite de Point
def _ _init_ _(self, nom, x=0, y=0):
Point._ _init_ _(self, x, y) # initialiser la partie Point du PointNommé
[Link] = nom # un nouvel attribut

def _ _str_ _(self): # redéfinition

return "%s:%s" % ([Link], Point.__str__(self))
# utilisation de la version de __str__ dans Point

def nommer(nouveau_nom): # une nouvelle méthode

[Link] = nouveau_nom
Remarque :
Il y a bien redéfinition de la méthode _ _str_ _ de Point dans PointNommé.
Les méthodes de Point sont héritées par PointNommé (ex : translater, distance)
Le nouveau schéma avec les points nommés
def exemple():
# créer les points sommets du triangle
p1 = PointNomme("A", 3, 2)
p2 = PointNomme("S", 6, 9) Remarque :
 création de PointNommé au lieu de Point
p3 = Point(11, 4)
 aucune modification sur la classe Point
 aucune modification sur la classe Segment
# créer les trois segments
 ... mais on a ajouté PointNommé
s12 = Segment(p1, p2)
s23 = Segment(p2, p3)
s31 = Segment(p3, p1)

# créer le barycentre Le résultat obtenu :

sx = (p1.x + p2.x + p3.x) / 3.0
sy = (p1.y + p2.y + p3.y) / 3.0 [A:(3.0 ; 2.0) - S:(6.0 ; 9.0)]
barycentre = PointNomme("G", sx, sy) [S:(6.0 ; 9.0) - (11.0 ; 4.0)]
[(11.0 ; 4.0) - A:(3.0 ; 2.0)]
# construire le schéma G:(6.666666666666667 ; 5.0)
schema = [s12, s23, s31, barycentre];

# afficher le schéma
for elt in schema:
print(elt)Quand la classe de base fait quelque chose d’utile, on parle d’héritage.

Class compte(object) :
Compte Def afficheSolde(self) :
Print "%+10.2f" % ([Link]/100.0)
+afficherSolde (autre) #...
Class compteSurLivret(compte) :
#...
If __name __ == ‘__main __’ :
compteCourant Compte = compteSurLivret (10 000)
[Link](10 000)
[Link]()

 Héritage multiple
Python permet l’héritage multiple.
Il suffit de lister toutes les super classes séparées par des virgules

class S(A, B, C): # la classe S hérite de A, B et C

pass
L’ordre des classes à une importance et influe sur le MRO (Method Resolution Order) : linéarisation des
classes parentes pour permettre le call-next-method :
 il préserve l’ordre de gauche à droite précisé dans chaque classe
 une sous-classe apparaît avant ses superclasses
 une même classe n’apparaît qu’une fois !
 il est monotone : l’ajout de nouvelles sous-classes ne modifie par le MRO des superclasses.

3. Agrégation :
Chaque client possède un compte.

Client Class Client (objet) :

Def __init__ (self, compte) :
[Link] = Compte
compte
If __name__ == ‘__main__’ :
#Kolo possède un compte courant
« interface » Kolo = Client(CompteCourant())
Compte #Paul possède un compteSurLivret
Kolo = Client(CompteSurLivret(500 000))

Chaque client possède des comptes.

Client Class Client (objet) :

def __init__ (self) :
[Link] = [ ]
Comptes
def ajoutecompte(self, compte) :
* [Link](compte)
« interface » if __name__ == ‘__main__’ :
Compte Kolo=Client()
#Kolo possède un compte courant
[Link](CompteCourant())
#Paul possède un compteSurLivret
[Link](CompteSurLivret(500 000))

4. Association :
Une association représente un lien unissant les instances de classe. Elle repose sur la relation « a-un » ou
« utilise-un ».
L'implémentation Python utilisée est généralement l'intégration d'autres objets dans le constructeur de la
classe conteneur :

class Point :
def __init__(self, x, y) :
[Link], [Link] = x, y

class Segment :
"""Classe conteneur utilisant la classe Point."""
def __init__(self, x1, y1, x2, y2) :
[Link] = Point(x1, y1)
[Link] = Point(x2, y2)

def __str__(self) :
return ("Segment : [({ :g}, { :g}), ({ :g}, { :g})]"
.format([Link], [Link], [Link], [Link]))
s = Segment(1.0, 2.0, 3.0, 4.0)
print(s) # Segment : [(1, 2), (3, 4)]
Héritage et polymorphisme
#####
class Atome:
"""atomes simplifiés, choisis parmi les 10 premiers éléments du TP"""
table =[None, ('hydrogène',0), ('hélium',2), ('lithium',4),
('béryllium',5), ('bore',6), ('carbone',6), ('azote',7),
('oxygène',8), ('fluor',10), ('néon',10)]

def __init__(self, nat):

"le n° atomique détermine le n. de protons, d'électrons et de neutrons"
[Link], [Link] = nat, nat # nat = numéro atomique
[Link] = [Link][nat][1] # nb. de neutrons trouvés dans table

def affiche(self):
print
print ("Nom de l'élément :", [Link][[Link]][0])
print ("%s protons, %s électrons, %s neutrons" % \
([Link], [Link], [Link]))

class Ion(Atome):
"""les ions sont des atomes qui ont gagné ou perdu des électrons"""

def __init__(self, nat, charge):

"le n° atomique et la charge électrique déterminent l'ion"
Atome.__init__(self, nat)
[Link] = [Link] - charge
[Link] = charge

def affiche(self):
"cette méthode remplace celle héritée de la classe parente"
[Link](self) # ... tout en l'utilisant elle-même !
print ("Particule électrisée. Charge =", [Link])

### Programme principal : ###

a1 = Atome(5)
a2 = Ion(3, 1)
a3 = Ion(8, -2)
[Link]()
[Link]()
[Link]()

Comment peut-on, à l'intérieur de la définition d'une classe, faire appel à une méthode définie dans
une autre classe ?

Lorsque dans la définition d'une classe, on souhaite faire appel à une méthode définie dans une
autre classe, on doit lui transmettre la référence de l'instance comme premier argument.

[Link](self)

(dans cette instruction, self est bien entendu la référence de l'instance courante).

De la même manière (vous en verrez de nombreux autres exemples plus loin), la méthode constructeur de la
classe Ion() fait appel à la méthode constructeur de sa classe parente, dans :
Atome.__init__(self, nat)