08 DECEMBRE 2020

PROGRAMMATION EN PYTHON
CLASSES DE LICENCE

UP INFORMATIQUE
ESATIC
Ecole Supérieure Africaine des TIC
Table des matières
I. Présentation de Python .................................................................................................................................... 5
1. Python c'est quoi ? ....................................................................................................................................... 5
2. Que fait Python ?.......................................................................................................................................... 5
3. Pourquoi préférer Python aux autres langages ? ...................................................................................... 5
4. Comment utiliser Python ? .......................................................................................................................... 5
II. Calculs et variables python ......................................................................................................................... 6
1. Les opérateurs .............................................................................................................................................. 6
2. Calculs ........................................................................................................................................................... 6
3. Les variables ................................................................................................................................................. 7
4. Echapper les quotes ...................................................................................................................................... 7
5. Nommer une variable .................................................................................................................................. 8
6. Les types de variables .................................................................................................................................. 8
7. Le transtypage ou conversion de type ........................................................................................................ 9
ValueError: invalid literal for int() with base 10: 'bonjour' .................................. 9
III. Les instructions ..........................................................................................................................................10
IV. Les fonctions python ..................................................................................................................................16
1. Créer ma première fonction ......................................................................................................................16
2. Les fonctions paramétrées .........................................................................................................................16
3. Un paramètre est obligatoire.....................................................................................................................17
4. Portée des variables (variable globale et variable locale) .......................................................................17
5. Procédure et fonctions ...............................................................................................................................17
V. IF ELIF ELSE Python Conditions ........................................................................ Erreur ! Signet non défini.
1. Condition if else ................................................................................................... Erreur ! Signet non défini.
2. Condition elif ....................................................................................................... Erreur ! Signet non défini.
3. Les comparaisons possibles ................................................................................ Erreur ! Signet non défini.
4. Comment fonctionnent les structures conditionnelles ? .................................. Erreur ! Signet non défini.
5. AND / OR ............................................................................................................. Erreur ! Signet non défini.
6. Chainer les comparateurs................................................................................... Erreur ! Signet non défini.
VI. Les boucles for et while Python .......................................................................... Erreur ! Signet non défini.
1. La boucle while .................................................................................................... Erreur ! Signet non défini.
2. La boucle for ........................................................................................................ Erreur ! Signet non défini.
3. Range .................................................................................................................... Erreur ! Signet non défini.
VII. Les listes python .........................................................................................................................................18
1. Créer une liste en python...........................................................................................................................18
2. Ajouter une valeur à une liste python ......................................................................................................18
3. Afficher un item d'une liste .......................................................................................................................18
4. Supprimer une entrée avec un index ........................................................................................................19

1
 5. Supprimer une entrée avec sa valeur .......................................................................................................19
6. Inverser les valeurs d'une liste ..................................................................................................................19
7. Compter le nombre d'items d'une liste ....................................................................................................19
8. Compter le nombre d'occurrences d'une valeur .....................................................................................19
9. Trouver l'index d'une valeur.....................................................................................................................19
10. Manipuler une liste ................................................................................................................................20
11. Boucler sur une liste ...............................................................................................................................20
12. Copier une liste .......................................................................................................................................20
13. La fonction range ...................................................................................................................................21
14. Agrandir une liste par une liste.............................................................................................................21
15. Astuces.....................................................................................................................................................21
VIII. Les tuples python ....................................................................................................................................23
1. Créer un tuple.............................................................................................................................................23
2. Ajouter une valeur à un tuple ...................................................................................................................23
3. Afficher une valeur d'un tuple ..................................................................................................................23
4. A quoi sert un tuple alors ? .......................................................................................................................23
IX. Les dictionnaires python ............................................................................................................................25
1. Comment créer un dictionnaire ? .............................................................................................................25
2. Comment ajouter des valeurs dans un dictionnaire ? ............................................................................25
3. Récupérer une valeur dans un dictionnaire.............................................................................................25
4. Supprimer une entrée de dictionnaire......................................................................................................25
5. Récupérer les valeurs par une boucle.......................................................................................................25
X. Les programmes python - les modules .........................................................................................................26
I. Introduction à la Programmation Orientée Objet ..................................................................................29
1. Qu’est-ce que la Programmation Orientée Objet (POO) ...................................................................29
2. Vers la Programmation Orientée Objet ...............................................................................................29
2.1. Pourquoi la POO ? ..................................................................................................................................29
2.2. Introduction à la POO ............................................................................................................................29
3. Concepts de Classes et objets ................................................................................................................29
4. Les trois grands principes de la POO ...................................................................................................30
II. Programmation de la classe et de l’objet .............................................................................................31
1. Principe et syntaxe de définition d’une classe .....................................................................................31
2. Définition d’une classe exemple : « Point » ..........................................................................................31
3. Création d’un objet de type « Point »...................................................................................................31
4. Affectation à une variable de la référence à un objet .........................................................................31
5. Définition des attributs ..........................................................................................................................32
6. Définition des méthodes .........................................................................................................................33
7. La notion de constructeur .....................................................................................................................34

2
III. La notion d’encapsulation .....................................................................................................................37
1. Définition d’attributs privés ..................................................................................................................37
2. Accesseurs et mutateurs ........................................................................................................................38
IV. Attributs et méthodes de classe .............................................................................................................39
1. Attributs de classe ..................................................................................................................................39
2. Méthodes de classe .................................................................................................................................39
V. Relations entre classes ...............................................................................................................................42
1. Relation d’utilisation..............................................................................................................................42
2. Héritage ...................................................................................................................................................43
3. Agrégation : ............................................................................................................................................47
4. Association : ............................................................................................................................................48
Héritage et polymorphisme ...........................................................................................................................49

3
INTRODUCTION
Traduire les algorithmes en un langage de programmation et les faire fonctionner sur un ordinateur est
certainement une nécessité pour rendre l’apprentissage de l’algorithmique plus vivant et plus attractif. La
possibilité pour l’étudiant de tester son algorithme, de le corriger, favorise son autonomie et participe à
l’apprentissage d’une démarche scientifique. Ce document, propose une initiation au langage Python. Pour
compléter votre formation sur Python, voici une liste de sites francophones sur lesquels vous trouverez la
documentation nécessaire :

- Le site Developpez.com : http://python.developpez.com/

Sur ce site vous trouverez l’excellent ouvrage de Gérard Swinnen « Apprendre à programmer avec Python
» https://python.developpez.com/cours/apprendre-python3/
Et aussi un cours pour débuter au lycée : https://python.developpez.com/tutoriels/debuter-avec-python-
au-lycee/

- Un complément à l’ouvrage de Gérard Swinnen : http://www.apprendre-en-ligne.net/python3/

4
 I. Présentation de 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é (pseudo-interprété), c'est à dire qu'il n'est pas
nécessaire de le compiler avant de l'exécuter. Il est portable, libre, ouvert et gratuit. De nombreuses
bibliothèques sont disponibles sur Internet.

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 (moteur de recherche Google, YouTube, …).

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

Python est utilisé :

- dans des laboratoires de recherche (CNRS, INRIA, Universités, …),
- dans des agences spatiales (NASA …),
- pour des jeux vidéo en 2D et 3D avec pyGame, cinéma,
- pour la bioinformatique avec la bibliothèque biopython,
- dans les finances, etc.

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.

4. Comment utiliser Python ?

Il y a deux façons de travailler avec python : l’interpréteur et l’éditeur.
On peut utiliser Python depuis:
 une fenêtre de terminal (ou console),
 un environnement de développement (IDE : Interactive Development Environment) c’est-à-dire
un éditeur de texte muni de différentes pour faciliter la programmation :
o IDLE qui a l’avantage d’être installé par défaut avec Python sous Windows
o Pyzo,
o PyCharm,
o IPython/Jupyter,
o WingIDE,…

5
 II. Calculs et variables python
1. Les opérateurs
Afin de pouvoir effectuer des opérations sur des données, on utilise des opérateurs :
+, -, *, /, //, %, **, <, >, ==, <=, >=, !=, and, or, not (… etc)

NB : L'action d'un opérateur dépend du type des données utilisées.

Voici quelques opérateurs python qui sont destinés à des données nombres entiers ou nombres flotants :

• + addition de nombres
• - soustraction de nombres
• * multiplication
• ** élévation à la puissance
• / division décimale
• // quotient d'une division entière
• % reste d'une division entière

Et pour les chaînes de caractères :

• + concaténation de deux chaînes de caractères

• * répétition d'une chaîne de caractères (chaîne * entier).

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

6
3.3333333333333335

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

4. Echapper les quotes

Comment inclure le caractère quote puisqu'il indique un début de données et en fin de données ?

7
>>> 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'

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

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

8
<type 'str'>
>>> v = 3.2
>>> type(v)
<type 'float'>

L’on peut formater le type de la variable:

>>> an=int(input("Saisissez le nombre d'années de placement(entre 0 et 50)\n"))
>>> n=float(input("Quel est votre note d’algo ?\n")
>>> nom=str(input("Entrez le nom du prof de la matière.\n ")

7. Le transtypage ou conversion de type

On peut changer le type d'une donnée en l'indiquant entre parenthèses, précédée du nom du nouveau type
souhaité.

>>> float(3)
3.0
>>> str(3)
'3'
>>> int(3.7)
3
>>> str(3.4)
'3.4'
>>> float("3.4")
3.4
>>> bool(0)
False
>>> int(True)
1
Ce changement de type est appelé transtypage (ou conversion de type, ou cast en anglais).

Certains transtypages ne sont pas autorisés (la valeur affectée à la variable ne peut pas être convertie vers
le type désiré) :
>>> int("bonjour")
ValueError: invalid literal for int() with base 10: 'bonjour'

9
 III. Les instructions
On distingue les instructions simples et les instructions complexes (composées).
1. Instructions simples :
L’invite de commande >>> signifie que Python est prêt à exécuter une commande.
En python, une instruction simple est formée d’une seule ligne :
>>> 2+3
>>> 35 / 5
>>> 10 * 3
>>> "Bonjour" * 4
>>> pi=3.1415
>>> R=3
>>> # Ceci est un commentaire en python

Les instructions de base

ECRIRE ("Hello Word") print() >>> print("Hello World !")

ECRIRE ("L'aire d'un disque de >>> print("L'aire d'un disque de
rayon",R,"cm est égale à", rayon",R,"cm est égale à",
pi*R**2,"cm²") pi*R**2,"cm²")
ECRIRE (“Bonjour“,prenom) >>> print(“Bonjour“,prenom)

ECRIRE("Quel est votre prénom input() >>> prenom=input("Quel est votre

SVP ?") prénoms ?\n")
LIRE(prenom)

AFFECTATION (y  10) = Y = 10

2. Instructions complexes :
En python, la structuration des blocs d’instructions se fait grâce à l’indentation (décalage
visuel avec des espaces) : les lignes consécutives qui ont la même indentation appartiennent
au même bloc ; une ligne ayant une indentation moindre (ou fin du programme) termine le
bloc d’instructions constitué par les lignes qui la précèdent.
Une instruction composée est formée d’une instruction d’introduction terminée par le
caractère deux-points (:), suivi par un bloc d’instructions simples (ou elles-mêmes
structurées) indentées par rapport à cette instruction d’introduction.
Instruction d’introduction :
Instruction 1
…
Instruction n
Autre instruction

10
Les principales instructions composées sont l’instruction conditionnelle SI (if en Python),
l’instruction pour (for en python), et l’instruction de boucle conditionnelle TANTQUE
(while en python).
2.1. Instruction conditionnelle si
SI condition alors :
Instruction 1 (ou bloc d’instructions 1)
SINON :
Instruction 2 (ou bloc d’instructions 2)
FINSI
On peut imbriquer plusieurs instructions conditionnelles.
Exemple : résultat d’un semestre
SI (moyenneUE1 ≥ 8 et moyenneUE2 ≥ 8) ALORS:
SI moyenneGenerale ≥ 10 ALORS:
ECRIRE("Le semestre est validé!")
SINON:
SI (moyenneGenerale +
moyenneSemestrePrecedent)/2 ≥ 10 ALORS:
ECRIRE("Le semestre est validé par
compensation avec le semestre précédent.")
SINON:
ECRIRE("La compensation est impossible. Le
semestre n'est pas validé.")
FINSI
FINSI
SINON:
ECRIRE("Le semestre n'est pas validé car au moins
l'une des UE est inférieure à 8.")
FINSI
En langage python, cette instruction s'utilise ainsi :
if condition1 :
bloc d'instructions 1
elif condition2 :
bloc d'instructions 2
elif condition3 :
bloc d'instructions 3
else :
bloc d'instructions 4

11
Le mot clé if signife « si », le mot clé elif signife « sinon si » et le mot clé else signife «
sinon ».
Exemple : résultat d’un semestre en python
if (moyenneUE1 >= 8 et moyenneUE2 >= 8):
if moyenneGenerale >= 10:
print("Le semestre est validé!")
elif (moyenneGenerale + moyenneSemestrePrecedent)/2
>= 10:
print("Le semestre est validé par compensation
avec le semestre précédent.")
else:
print("La compensation est impossible. Le
semestre n'est pas validé.")
else:
print("Le semestre n'est pas validé car au moins
l'une des UE est inférieure à 8.")

2.1.1 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

12
 2.1.2 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.

2.1.3 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

2.2. Instruction de boucle pour

Cette instruction permet d'exécuter un bloc secondaire plusieurs fois de suite.
Exemple : (en algorithmique)
POUR n DE 1 A 10 FAIRE
u  n*n
ECRIRE("le carré de ", n, " est ", u)
FINPOUR

13
Exemple : (en python)
for n in range(10):
u = n*n
print("le carré de ", n, " est ", u)
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
2.2.1 Range
Il est possible de créer une boucle facilement avec range :
for i in range(0,100):
print (i)

2.2.2 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

14
... print (i)
...
1
5
10
15
On stoppe la boucle

2.3. Instruction de boucle tant que

Elle permet d'exécuter un bloc secondaire tant qu'une certaine condition reste vraie.
Exemple : (en algorithmique)
ECRIRE("entrez un nombre strictement positif")
LIRE(n)1
TANTQUE n < 0 :
ECRIRE("erreur, le nombre n'était pas strictement
positif. Recommencez svp.")
LIRE(n)
FINTANTQUE
Exemple : (en python)
n = int(input("entrez un nombre strictement positif"))
while n < 0 :
n = int(input("erreur, le nombre n'était pas
strictement positif. Recommencez svp."))

15
 IV. 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.

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

17
 V. 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
[]
>>> liste.append(1)
>>> liste
[1]
>>> liste.append("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'

18
>>> 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"]
>>> liste.remove("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"]
>>> liste.reverse()
>>> 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"]
>>> liste.count("a")
3
>>> liste.count("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"]
>>> liste.index("b")
3

19
 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 font 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

20
>>> 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 = copy.deepcopy(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]
>>> x.extend(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]

21
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]

22
 VI. 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 = ("ok")
>>> type(mon_tuple)
<type 'str'>
>>> mon_tuple = ("ok",)
>>> 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

23
>>> 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", "Kouassi")
...
>>> donne_moi_ton_nom()
('olivier', 'Kouassi')
On utilisera un tuple pour définir des sortes de constantes qui n'ont donc pas vocation à
changer.

24
 VII. Les 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}
>>> data.get("name")
'Olivier'
>>> data.get("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 fiche.values():
... print valeur
...
YAO
olivier

25
 VIII. Les programmes python - les modules
Un fchier script python, d'extension .py, se nomme aussi un module.
Un module python fait généralement appel à des éléments qui sont présents dans d'autres
modules python ; un programme python peut donc se composer d'un ou de plusieurs
modules.
Nos programmes utiliseront généralement des modules déjà écrits par d'autres auteurs,
comme les modules math, cmath, random, turtle, matplotlib, numpy, etc (soit ces modules
font déjà partie du langage python14, soit on peut les trouver sur internet).

1. Exemples
a. Exemple 1 - calculs
On va calculer et afficher à l'écran, l'aire d'un disque et le volume d'une sphère ayant pour
rayon un entier choisi aléatoirement.

1. import random # on veut utiliser le module random

2. from math import pi # on veut utiliser la valeur du nombre pi qui est
enregistrée dans le module math
3. rayon = random.randrange(1,100) # choix d'un entier au hasard entre 1 et 99
4. aire_disque = pi*rayon**2 # calcul de l'aire d'un disque et affectation du
résultat à la variable aire_disque
5. vol_sphere = 4/3*pi*rayon**3 # calcul du volume d'une sphère et affectation du
résultat à la variable vol_sphere
6. # on affiche les résultats à l'écran
7. print("La surface d'un disque de rayon", rayon, "m est de", aire_disque,"m2")
8. print("Le volume d'une sphère de rayon", rayon, "m est de", vol_sphere,"m3")

b. Exemple 2 - graphisme
On va dessiner à l'écran un cercle dont le rayon sera un nombre flotant choisi au hasard,
puis, on va le colorier en vert.

1. from random import randrange# on veut utiliser le module random

2. import turtle# on veut utiliser le module turtle ("tortue")
3. monrayon = randrange(1,100) # choix d'un entier au hasard entre 1 et 99
4. print("le rayon choisi au hasard est", monrayon) #on affiche la valeur du rayon
choisi
5. turtle.color('black','green') #le curseur écrira en noir et le coloriage sera vert
6. turtle.begin_fill() #on indique que la forme choisie devra être remplie
7. turtle.circle(monrayon) #on trace un cercle ayant comme rayon, le nombre flottant
choisi au hasard précédemment
8. turtle.end_fill() #on termine le coloriage

26
 2. Présenter un module : en-tête, commentaires, résultats d'exécution
Au début du module doit fgurer un en-tête de module qui contient le nom du fchier, le nom
des auteurs, la date ainsi qu'une documentation c'est à dire une explication sur ce que fait
le script :

1. #!/usr/bin/python3
2. # -*- coding: UTF-8 -*-
3. """
4. Documentation du module(appelée aussi DocString)
5. Il s'agit d'expliquer ce que le module contient et à quoi il sert.
6. Il peut être affiché avec help(nommodule) ou help("nommodule"),
7. ou bien utilisé par un outil de génération de documentation
8. externe (produisant du html, du pdf…).
9. """
10. # fichier: nom_du_fichier.py (indiquer le nom du fichier)
11. # auteurs : (indiquer les noms des auteurs du module)
12. # date : (indiquer la date)

Ensuite vient le programme proprement dit, c'est à dire les instructions de l'algorithme
traduites en langage python :

13. # programme principal

14.
15. import random# on veut utiliser le module random
16. from math import pi# on veut utiliser la valeur du nombre pi qui est enregistrée dans le
module math
17. rayon = random.randrange(1,100) # choix d'un entier au hasard entre 1 et 99
18. aire_disque = pi*rayon**2 # calcul de l'aire d'un disque et affectation du résultat à la
variable aire_disque
19. vol_sphere = 4/3*pi*rayon**3 # calcul du volume d'une sphère et affectation du résultat à
la variable vol_sphere
20. # on affiche les résultats à l'écran
21. print("La surface d'un disque de rayon", rayon, "m est de", aire_disque,"m2")
22. print("Le volume d'une sphère de rayon", rayon, "m est de", vol_sphere,"m3")

27
28
 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

29
  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.

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

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

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

33
- 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

a.deplace(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)
a.deplace(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.

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

35
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)
a.deplace(3, 5)
b.deplace(-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.

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

37
a.affiche()
a.deplace(1, 3)
a.affiche()

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.

38
 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: nomDeClasse.nomAttribut

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
A.nb = A.nb + 1 a : x = 3 nb = 1
Partie 2 :
print("A : nb = ", A.nb) 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 = ", A.nb) Création objet de type A
print("a : x = ", a.x, " nb = ", a.nb) Partie 3 :
print("Partie 2 :") A : nb = 3
b = A(6) a : x = 3 nb = 3
print("A : nb = ", A.nb) b : x = 6 nb = 3
c : x = 8 nb = 3
print("a : x = ", a.x, " nb = ", a.nb)
print("b : x = ", b.x, " nb = ", b.nb)
c = A(8)
print("Partie 3 :")
print("A : nb = ", A.nb)
print("a : x = ", a.x, " nb = ", a.nb)
print("b : x = ", b.x, " nb = ", b.nb)
print("c : x = ", c.x, " nb = ", c.nb)

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 langue.lower == ’fr’:
cls._directions = (’Nord’, ’Est’, ’Sud’, ’Ouest’)
else:

39
 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")
A.nb = A.nb + 1
print("il y en a maintenant ", A.nb)

@classmethod
def get_nb(cls):
return A.nb

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
@mois.setter # accès en écriture à mois, comme si c’était un attribut

40
 def mois(self, mois):
if mois < 1 or mois > 12:
raise ValueError
self.__mois = mois

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

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

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

41
 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 math.sqrt(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).

42
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):

self.extremite1.translater(dx, dy)
self.extremite2.translater(dx, dy)

def longueur(self):
return self.extremite1.distance(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é :

43
  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 :

44
 >>> Class Quadrupede :
… def piedsAuContactDuSol (self) :
… return 4
…
>>> Class QuadrupedeDebout (Quadrupede ) :
… def piedsAuContactDuSol (self) :
… return 2
…
>>> chat = Quadrupede ()
>>> chat.piedsAuContactDuSol ()
4
>>> homme = QuadrupedeDebout ()
>>> homme.piedsAuContactDuSol ()
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é
self.nom = nom # un nouvel attribut

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

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

45
 def nommer(nouveau_nom): # une nouvelle méthode
self.nom = 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 :
p3 = Point(11, 4)  création de PointNommé au lieu de Point
 aucune modification sur la classe Point
# créer les trois segments  aucune modification sur la classe Segment
s12 = Segment(p1, p2)  ... mais on a ajouté PointNommé
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
barycentre = PointNomme("G", sx, sy)
# construire le schéma
schema = [s12, s23, s31, barycentre];
[A:(3.0 ; 2.0) - S:(6.0 ; 9.0)]
[S:(6.0 ; 9.0) - (11.0 ; 4.0)]
[(11.0 ; 4.0) - A:(3.0 ; 2.0)]
G:(6.666666666666667 ; 5.0)

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

46
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" % (self.solde/100.0)
+afficherSolde (autre) #...
Class compteSurLivret(compte) :
#...
If __name __ == ‘__main __’ :
compteCourant Compte = compteSurLivret (10 000)
Compte.crediter(10 000)
Compte.afficher()

 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) :
Self.Compte = 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) :
self.Compte = [ ]
Comptes 47
def ajoutecompte(self, compte) :
 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) :
self.px, self.py = x, y

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

def __str__(self) :
return ("Segment : [({ :g}, { :g}), ({ :g}, { :g})]"
.format(self.orig.px, self.orig.py, self.extrem.px, self.extrem.py))
s = Segment(1.0, 2.0, 3.0, 4.0)
print(s) # Segment : [(1, 2), (3, 4)]

48
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"
self.np, self.ne = nat, nat # nat = numéro atomique
self.nn = Atome.table[nat][1] # nb. de neutrons trouvés dans table

def affiche(self):
print
print ("Nom de l'élément :", Atome.table[self.np][0])
print ("%s protons, %s électrons, %s neutrons" % \
(self.np, self.ne, self.nn))

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)
self.ne = self.ne - charge
self.charge = charge

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

### Programme principal : ###

a1 = Atome(5)
a2 = Ion(3, 1)
a3 = Ion(8, -2)
a1.affiche()
a2.affiche()
a3.affiche()

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.

Atome.affiche(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)

49
50