COURS DE PYTHON

ISIGK

2023-2024

1
 Plan du cours

■ Chapitre I - Le langage Python : Notions de bases

■ Chapitre II - Les collections d’objets et les fonctions en Python
■ Chapitre III- La programmation Orientée Objet en Python

2
Chapitre 1 –Le langage Python : Notions
de base

3
Qu’est ce que Python ?

➢ Python est un langage de programmation développé depuis 1989 par le

développeur néerlandais Guido Van Rossum et de nombreux collaborateurs.
La première version publique de ce langage a été publiée en 1991.
➢ La dernière version de Python est la version 3. Plus précisément, la version
3.12.1 a été publiée en décembre 2023
➢ La version 2 de Python est obsolète et n’est plus maintenue, évitez de
l’utiliser.
➢ La Python Software Foundation est l’association qui organise le
développement de Python. Sa mission est de promouvoir et de protéger le
langage afin d'étendre la communauté d'utilisateurs.

4
Qu’est ce que Python ?

➢ Usage :
▪ Scripts pour automatiser des tâches
▪ Analyse de données
▪ Calcul numérique
▪ Développement web
▪ Instagram, YouTube,

5
 Présentation générale de Python

▪ Python inclut tous les types de données, les branchements

conditionnels, les boucles, l’organisation du code en procédures et
fonctions, objets et classes.
▪ Mode d’exécution : transmettre à l’interpréteur Python le fichier script
«.py».
▪ Python est associé à de très nombreuses librairies très performantes,
notamment des librairies de calcul scientifique (Numpy, Pandas, etc.).
De ce fait, il est de plus en plus populaire, y compris auprès des
analyste de données (data- scientists). Il est plus généraliste que R
qui est vraiment tourné vers les statistiques.

6
Présentation générale de Python

■ Python est un langage de programmation interprété c'est à dire que les

instructions que vous lui envoyez sont « transcrites » en langage machine
au fur et à mesure de leur lecture.
■ D'autres langages (comme le C, C++) sont appelés « langages compilés »
car, avant de pouvoir les exécuter, un logiciel spécialisé se charge de
transformer le code du programme en langage machine. On appelle cette
étape la « compilation » : À chaque modification du code, il faut rappeler
une étape de compilation et cela génère un exécutable.

7
 Présentation générale de Python
▪ De nombreux langages vous obligent ▪ Python est plutôt directement
à compiler (traduire) votre programme interprété en instructions machine.
sous une forme que la machine
comprend.

8
 Avantages de Python (1)
▪ C’est un langage interprété. Un script Python n’a pas besoin d’être compilé pour être
exécuté, contrairement à des langages comme le C ou le C++.
▪ Python est un langage portable (peut fonctionner sur différentes plateformes OS
(operating system);
▪ Python convient aussi bien à des scripts d'une dizaine de lignes qu'à des projets
complexes de plusieurs dizaines de milliers de lignes;
▪ La syntaxe de Python est très simple et, combinée à des types de données évolués
(listes, dictionnaires,…), conduit à des programmes à la fois très compacts et très
lisibles;
▪ Python est un Langage de haut niveau. Il demande relativement peu de
connaissance sur le fonctionnement d’un ordinateur pour être utilisé.
▪ Il permet de faire beaucoup avec peu de code, un programme python est 3 à 5
fois moins court qu’un programme C ou java.
9
Présentation générale de Python
Un exemple!

10
 Avantages de Python
➢ Python est Dynamiquement typé:
▪ tout objet manipulable par le programmeur possède un type bien défini à l'exécution, qui n'a pas
besoin d'être déclaré à l'avance.

➢ Python est un langage interopérable.

➢ Python gère ses ressources (par exemple la mémoire) sans intervention du
programmeur,
▪ par un mécanisme de comptage de références,

▪ il intègre un système de gestion de mémoire automatique (ramasse miette ou garbage

collector en anglais)

➢ Il est gratuit. Vous pouvez l’installer sur autant d’ordinateurs que vous voulez
(même sur votre téléphone !).
11
Avantages de Python
➢ Python intègre, comme Java ou les versions récentes de C++, un
système d'exceptions,
▪ permettant de simplifier considérablement la gestion des erreurs,
▪ lorsqu'une exception se produit, l'exécution normale du programme est interrompue
et l'exception est traitée !!

➢ Multi paradigmes, supportant les principaux styles de programmation :

▪ impératif, procédural, orienté objet...

➢ Evolutif, Python est un langage qui continue à évoluer, grâce à une

communauté d’utilisateurs très actifs
➢ Langage polyvalent : nous pouvons presque tout faire avec Python grâce à
ses bibliothèques variées.
12
 IDE de Python

➢ Plusieurs IDE (Environnement de développement intégré) sont disponibles.

➢ IDLE : est un environnement de développement intégré fourni avec Python
(bon choix pour débutant), IDLE propose un certain nombre d'outils :
▪ un éditeur de texte (pour l’écriture de script) avec une coloration syntaxique, une indentation
automatique et l’auto-complétion*.
▪ un interpréteur (pour exécuter le programme)

▪ un débogueur (pour tester le programme)

➢ C’est l’IDE Le plus populaire, soit 23% des utilisateurs de python

*: Auto-complétion – ou complément automatique – est une fonctionnalité d’un logiciel qui propose à l’utilisateur des compléments
de réponses pouvant convenir aux premières mots ou aux premières phrases qu’il a commencé à taper dans le champ de saisie.
13
Environnement de développement intégré
➢ Il existe d'autres IDE pour Python :
▪ Eclipse/Pydev,
▪ NetBeans,
▪ Spyder,
▪ Eric...

➢ Pour les non débutants d’autres IDE complet :

▪ winPython ,
▪ anaconda V3,
▪ Python(x,y)..
14
Mode interactif & mode script :
Mode interactif
Les instructions tapées sont exécutées directement par l’interpréteur python,
c’est aussi le mode calculette .

15
Mode interactif & mode script :
Mode script (1)

Une nouvelle fenêtre s’ouvre , vous écrivez votre code Python. Il faut
l’enregistrer dans un fichier d’extension « .py »

16
 Mode interactif & mode script
Mode script (2)

Exécution :

17
 Commentaires, Aide et modules en Python :
Commentaires
➢ Les commentaires rendent votre programme plus facile à comprendre.
Lorsque vous regardez votre code ou que d'autres veulent collaborer avec
vous, ils peuvent lire vos commentaires et facilement comprendre ce que fait
votre code.
▪ Le signe # est pour les commentaires. Un commentaire est une ligne de
texte que Python n'essaiera pas d'exécuter en tant que code. C'est juste
pour les humains à lire.
▪ Vous pouvez écrire un commentaire multi-ligne, en commençant chaque
ligne avec #, cela peut être une douleur.
▪ Au lieu de cela, pour les commentaires sur plusieurs lignes, vous pouvez
inclure le bloc entier dans un ensemble de guillemets (" " " )
18
 Commentaires, Aide et modules en Python :
Utilisation de l’aide
➢ L’utilisation de l’aide en ligne se fait par la commandehelp(identificateur)
➢ Exemple :
>>>help(int)
Help on class int in module builtins: class int(object)
| int(x=0) -> integer
| int(x, base) -> integer
….
Methods defined here:
| abs (...)
| x. abs () <==> abs(x)
| add (...)
| x. add (y) <==> x+y
| and (...)
| x. and (y) <==> x&y
| bool (...)
| x. bool () <==> x != 0 19
Commentaires, Aide et modules en Python :
Import de modules (1)
Trois manières d’import de modules :
❖ 1ère manière:
>>>import math
>>>dir(math)
[' doc ', ' name ', ' package ', 'acos', 'acosh', 'asin', 'asinh', 'atan',
'atan2', 'atanh', 'ceil', 'copysign', 'cos',………, 'pi', 'pow', 'radians',
'sin', 'sinh','sqrt', 'tan', 'tanh', 'trunc']
>>> math.ceil(7.8989) #partie entière supérieure
8
>>> math.floor(7.8989) #partie entière inférieure
7
>>>help(math.ceil)
Help on built-in function ceil in module math:
ceil(...)
ceil(x)
Return the ceiling of x as an int.
This is the smallest integral value >= x. 20
 Commentaires, Aide et modules en Python :
Import de modules (2)

❖ 2ème manière: Utilisation d’unalias

>>>import math as m
>>>dir(m)
[' doc ', ' name ', ' package ', 'acos', 'acosh', 'asin', 'asinh',
'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos',………, 'pi', 'pow',
'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>> m.sqrt(2)
1.4142135623730951
>>> m.tan(m.pi)
-1.2246467991473532e-16

21
Commentaires, Aide et modules en Python :
Import de modules (3)

❖ 3ème Manière : Importation de toutes les fonctions d’unmodule

>>>from math import *

>>>dir(math)
->Erreur
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
dir(math)
NameError: name 'math' is not defined
Mais les fonctions du module sont directement accessibles
>>>sqrt(2)
1.4142135623730951
>>>help(abs)
Help on built-in function abs in module builtins: abs(...)
abs(number) -> number
Return the absolute value of the argument.
22
Commentaires, Aide et modules en Python :
Import de modules (4)

La troisième manière représente l’avantage d’accéder directement aux fonctions

mais représente également l’inconvénient:
▪ d’encombrement de l’espace de noms réservés et,
▪ la possibilité de conflit entre deux fonctions ayant le même identificateur
provenant de deux modules différents !!!
Exemple:
>>>from math import *
>>>from numpy import *
▪ Les deux contiennent la fonction sqrt , l’une définie pour les réels l’autre sur les
tableaux!
▪ Laquelle sera utilisée ????
23
Commentaires, Aide et modules en Python :
Module math
Parmi les fonctions les plus utiles du module math, on trouve :
▪ Racine carrée : sqrt
▪ Factorielle : factorial
▪ Fonctions trigonométriques : cos, sin, tan,
▪ Conversion des angles :degrees, radians
▪ log, exp : log, log10, log2
▪ fonctions d’arrondissement : floor, ceil
▪ troncature : trunc
NB : Le module math stocke aussi la valeur de π et de e.
24
Les types sous Python
Les types sous Python

Les types Les

élémentaires conteneurs

Non
Mutables
Mutables

Non
Ordonnés Ordonnés
Ordonnés

-Tuples
-Ensembles
-Chaînes de Les listes
-Dictionnaires
caractères

25
Les Types sous Python
Python est un langage dont le typage est automatique. Cela signifie que bien qu’il gère
différents types, lorsqu'une variable est affectée, l'interpréteur trouvera automatiquement
son type.

26
Les types élémentaires
Affectation des variables
En Python comme dans de nombreux autres langages, l'opération d'affectation est représentée
par le signe égal :

>>> n = 7 # donner à n la valeur 7

>>> msg = "Quoi de neuf ?" # affecter la valeur "Quoi de neuf ?" à msg
>>> pi = 3.14159 # assigner sa valeur à la variable pi

Mémoire
@
n 7 en binaire
@
msg « quoi de neuf » en binaire…
@ 3,14159 en binaire
Pi .

27 27
 Les types élémentaires
Affectation des variables : référence → objet
L’affectation opère de droite à gauche :
– le terme de droite est une expression évaluée, qui crée ou référence un objet
– le terme de gauche est un identificateur (référence, nom, étiquette)

C’est l’objet qui porte le type et les données (la valeur, pour un objet numérique).
– Un objet ne peut pas changer d’identité (≈ adresse mémoire), ni de type.
– Un objet peut avoir plusieurs noms (alias).
– Un identificateur associé d’abord à un objet peut ensuite référencer un nouvel objet !
28
 Les types élémentaires
Affectation des variables

▪ Un même objet peut être référencé sous plusieurs noms (alias).

>>>x=5 x
>>>y=5 5
>>>x,id(x),type(x) y
(5, 505626168, <class 'int'>) 505626168
>>>y,id(y),type(y)
(5, 505626168, <class 'int'>)

29
Les types élémentaires
Affectation des variables

– Quand un objet n’a plus de nom (nombre de références nul), il est détruit
(mécanisme automatique de "ramasse-miettes", garbage collector).

30
 Les types élémentaires
Nom des variables et mots réservés
▪ Les noms de variables sont des noms qu’on choisit assez librement.
▪ Quelques règles pour les noms de variables sous Python :

1. Un nom de variable est une séquence de lettres (a à z , A à Z) et de chiffres, qui doit

toujours commencer par une lettre.
2. Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux tels que $, #, @,
etc. sont interdits, à l'exception du caractère _ (souligné).
3. La casse est significative, Attention : Mariem, mariem , MARIEM sont donc des variables
différentes. Soyez attentifs !
4. Prenez l'habitude d'écrire l'essentiel des noms de variables en caractères minuscules (y
compris la première lettre). Il s'agit d'une simple convention, mais elle est largement
respectée. N'utilisez les majuscules qu'à l'intérieur même du nom, pour en augmenter
éventuellement la lisibilité, comme dans tableDesMatieres.

31
Les types élémentaires
Nom des variables et mots réservés

En plus de ces règles, il faut encore ajouter que vous ne pouvez pas
utiliser comme noms de variables les 29 « mots réservés » au langage ci-
dessous :

and assert break class continue def

del elif else except exec finally
for from global if import in
is lambda not or
print
raise return try while yield pass

32 32
Les types élémentaires

Les types élémentaire intrinsèques (ou built-in)

▪ Le NONETYPE : seule valeur possible None
➢ c’est la valeur retournée par une fonction qui ne retourne rien,
▪ Le type bool : deux valeurs possible True et False (1/0)
▪ Les types numériques int, float, complex :
➢ Le type int x = 898, Le type float x = 8.98
➢ Le type complex z = 8+1j
Le type d’un objet détermine :
▪ les valeurs : domaine de définition
▪ les opérations possibles (+, -, /, …)
33
 Les types élémentaires
Le type entier : <class int>
>>> x=3
>>> y=6
>>> type(x),type(y)
(<class 'int'>, <class 'int'>)
Les opérations arithmétiques +, -, *, **, /, //, %
>>> z=x+y #z= x. add (y)
9
>>> z
9
>>> z=x-y # z= x. sub (y)
-3
>>> x*y # x. mul (y)
18
>>> x**y # puissance
729

34
Les types élémentaires :
Le type entier : <class int>
>>> pow(x,y) # calcul de x à la puissance y
729
>>> x/y # division réelle
0.5
>>> x//y #quotient de la division entière
0
>>> x%y #reste de la division entière
3
Les opérateurs de comparaison <, <=, !=, ==, >, >= :
>>>x==y
False
>>>x>=y
False
>>>x<=y
True
>>>x!=y
True

35
 Les types élémentaires
Le type réel: <class float>
>>> x=12/7; y=4.
>>> x;y
1.7142857142857142
4.0
>>> type(x); type(y)
<class 'float'>
<class 'float’>
▪ Les opérations arithmétiques :
>>> x+y
5.714285714285714
>>> x-y
-2.2857142857142856
>>> x*y
6.857142857142857
>>> x/y
0.42857142857142855
36
Les types élémentaires
Le type réel: <class float>
>>> x**y
8.636401499375259
>>> x//y
0.0
>>> x%y
1.7142857142857142
>>> x=12/5
>>> x
2.4
>>>int(x) #Passage de réel en entier, l’objet retourné est un nouvel objet
2

37
 Les types élémentaires
Le type booléen : <class bool>
La classe « bool » hérite de la classe « int »

>> x=3 ; y=4 ; z=3

>>> B=x==y >>>int(True)
>>> B 1
False >>>int(False)
>>> E=x<y 0
>>> E
True
>>> B and E Les opérations logiques utilisés:
False and, or, not…
>>> B or E
True
38
Les opérations d’entrée/sortie
Opération d’affichage : print()
Opération d’affichage : print()
>>> print('ceci est un message')
ceci est un message
>>> print("ceci est un message")
ceci est un message
>>> print("ceci un message \n avec retour à la
ligne")
ceci un message
avec retour à la ligne
>>> print(""" Ceci est un message
sur plusieurs lignes
avec beaucoup d'espaces et des sauts de ligne""")
Ceci est un message
sur plusieurs lignes
avec beaucoup d'espaces et des sauts de ligne
39
Les opérations d’entrée/sortie
Opération d’affichage : print()
>>> x=10;y=10;z=10;
>>> print (x, y, z, sep=' ');
10 10 10
>>> print (x, y, z, sep=';');
10;10;10
>>> print (x, y, z , sep='\n');
10
10
10
>>> print ('x =',x,'y =',y, 'z =', z, sep= ' ' , end =';');
x = 10 y = 10 z = 10;

sep: désigne le caractère de séparation

end: désigne le caractère de marquage de fin
40
Les opérations d’entrée/sortie
Opération de lecture : input()
Opération de lecture : input()
>>> x=input("saisir : ")
Saisir : 3498392483
>>> print("la saisie",x, "est de type",type(x))
la saisie 3498392483 est de type <class 'str'>

41
Les opérations d’entrée/sortie
Opération de lecture : input()
Il est toutefois possible de convertir la quantité saisie en entier, réel ou même
booléen au moyen de int(), float(), et bool()

>>> x=int(input("saisir un entier"))

saisir un entier 12
>>> print(x, "de type", type(x))
12 de type <class 'int'>
#Ou encore en réel
>>> x=float(input("saisir un réel"))
saisir un réel 23
>>> print(x, "de type", type(x))
23.0 de type <class 'float'>
42
Structures conditionnelles & Itératives
Principe d’indentation
De manière générale, un bloc contient tout le code avec une même indentation.

# flux parent
if conditionA:
#bloc d'instructions exécuté si la valeur de conditionA est True
if conditionB:
#bloc d'instructions imbriqué, exécuté si conditionA est True
# et si conditionB est True
# retour au flux parent

43
Structures conditionnelles & Itératives
Les structures conditionnelles
Syntaxe: (Attention à l’indentation !!! )

if condition1:
instruction 1
elif condition2:
L'indentation après le ":" est obligatoire.
instruction 2
elif condition3:
instruction 3
instruction 4
else :
instruction 5
instruction 6
44
Structures conditionnelles & Itératives
Les structures conditionnelles
Ecrire un programme qui saisit un nombre et teste si l’entier est nul, pair ou impair

45
Structures conditionnelles & Itératives
Les structures itératives : Boucle For
Syntaxe:
for i in range(a): for i in range(a,b,c):
instructions
instructions
for i in range(a,b): For i in iter:
instructions
instructions

range (a): désigne l’intervalle [0,a[

range (a,b): désigne l’intervalle [a,b[
range (a,b,c): désigne l’intervalle [a,b[ par pas entier égal à c
Le quatrième « iter » cas est un parcours par élément que nous pourrons effectuer avec les
itérables tels que les listes, les tuples, les chaînes de caractères ou même les fichiers…
46
Structures conditionnelles & Itératives
Boucle For
Exemples:

(a) (b)

(c) (d) 47
 Structures conditionnelles & Itératives
Boucle For
L’instruction for… in : permet d’itérer sur le contenu d’une liste, d’un tuple, les caractères d’une chaîne ou
même un fichier …
>>>L=list(range(5))
>>>L
[0,1,2,3,4] >>> a = [‘Zero', ‘Un', ‘Deux',
>>>L1=[] ‘Trois', ‘Quatre']
>>>for k in L:
L1.append(k**2) >>> for i in range(len(a)):
>>>L1 print(i, a[i])
[0, 1, 4, 9, 16] ...
>>>ch=”azerty” 0 Zero
>>>ch1='' 1 Un
>>>for c in ch: 2 Deux
ch1=ch1+c*2 3 Trois
aazzeerrttyy 4 Quatre
48
 Structures conditionnelles & Itératives
Boucle For
Construction de listes par compréhension:

>>>L= [i for i in range(1,21,2)]

>>>L
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>>L=[(i,j) for i in range (1,5) for j in range (1,5)]
>>>L
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3,
1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4)]
>>>L=[(i,j) for i in range (1,5) for j in range (1,5) if (i+j)%2 ==0]
>>>L
[(1, 1), (1, 3), (2, 2), (2, 4), (3, 1), (3, 3), (4, 2), (4, 4)]

49
Structures conditionnelles & Itératives
Boucle tant que

▪ Syntaxe: Exemple :

i=1
while condition:
instructions1 while i<=5:
print(i)
else:
i +=1
instructions2 else:
print("Fin boucle")

50
 Structures conditionnelles & Itératives
Utilisation du break, continue, pass

Les instructions "break", "continue" et "pass" permettent à l’utilisateur d’avoir

un plus grand contrôle de la boucle.
▪ Comme en C, l’instruction « break » permet de sortir de la boucle
instantanément et de passer à la suite. Elle annule le passage dans la
boucle else.
▪ L’instruction « continue » vous donne la possibilité d'ignorer la partie d'une
boucle où une condition externe est déclenchée, mais de continuer pour
terminer le reste de la boucle. C'est-à-dire que l'itération actuelle de la
boucle sera interrompue, mais le programme reviendra au début de la
boucle.

51 55
 Structures conditionnelles & Itératives
Utilisation du break, continue, pass
▪ « pass » : Si à un endroit on a syntaxiquement besoin d'un bloc mais qu'il n'y a
rien à faire, on peut utiliser l'instruction pass, qui justement ne fait rien. pass a
une valeur nulle et sert à éviter les erreurs lors de l'implémentation de boucles,
fonctions ou méthodes car ces structures doivent contenir au minimum une
instruction.
▪ Exemple :
if condition:
pass
else:
instruction ...

52 55
 Structures conditionnelles & Itératives
Utilisation du break, continue, pass
#utilisation de l’instruction « continue »
for num in range(2, 10):
if num % 2 == 0:
print("Un nombre paire", num)
continue
print("Un nombre impaire", num)
#utilisation de l’instruction « break» et « else »
for n in range(2, 10):
print("n=",n)
for x in range(2, n):
print("x=",x)
if n % x == 0:
print(n, "=", x, "*", n//x)
break
else: # exécuté à la fin normale de la boucle
print(n, "est un nombre premier")
53
Exercice 1: Jeu de devinette (1/2)
▪ Ecrire un programme devinette qui permet de deviner un entier généré
par le programme de façon aléatoire (compris entre 1 et 100). On
indiquera à l’utilisateur si l’entier introduit est plus grand ou plus petit
que l’entier caché.
▪ Un bravo sera affiché lorsqu’il aurait deviné l’entier, on lui indiquera
également au bout de combien de tentatives il est parvenu à trouver le
nombre.
Remarque:
Pour générer un entier aléatoire il faut importer le package random, puis
utiliser la fonction randint(a,b) où a et b désigne l’intervalle [a,b] dans
lequel l’entier aléatoire sera tiré.

54
 Exercice 1: Jeu de devinette (2/2)
print("Jeu de devinette")
from random import *
c=randint(1,100)
x=int(input("devinez un entier entre 1 et 100: "))
i=1
while x!=c:
if x<c:
print("votre entier est plus petit que l'entier caché")
else:
print("votre entier est plus grand que l'entier caché")
i+=1
x=int(input("devinez un entier entre 1 et 100:"))
print("Bravoooo, vous avez deviné au bout de ", i, "tentatives")

55
Exercice 2 : (1/2)

▪ Modifier le programme précédant en ajoutant 3 niveaux de difficulté

(difficile (4 tentatives), moyen (7 tentatives) ou facile (12 tentatives))
▪ Le joueur choisi un niveau de difficulté, un nombre d’essai lui est alors
attribué, si ce dernier épuise ses essais il aurait échoué et un
message sera affiché.
▪ Remarque: On lui indiquera à chaque fois le nombre de tentatives
restantes

56
 Exercice 2: (2/2)
print ("devinette 2")
while x!=c and i<=tentatives:
from random import*
print ("il vous reste ", tentatives-i, "tentatives")
c=randint(1,100)
if x<c:
rep= input("niveau: F, M ou D: ")
print("votre entier est plus petit que l'entier caché")
while rep!="F" and rep!="M" and rep!="D" :
else:
rep= input("niveau: F, M ou D: ")
print("votre entier est plus grand que l'entier caché")
if rep=='F':
i+=1
tentatives=12
x=int(input("devinez un entier entre 1 et 100:"))
elif rep=='M':
if x==c:
tentatives=7
print("Bravoooo, vous avez deviné au bout de ", i,
else:
"tentatives")
tentatives=4
else:
print("vous avez ", tentatives, "tentatives")
print("Game over, vous avez épuisés vos tentatives, c'est
x=int(input("devinez un entier entre 1 et 100: "))
le :", c)
i=1

57/76
Chapitre 2 – Les Objets et les Fonctions
en Python

58
1) Les objets en Python
Python est un Langage Orienté Objet
▪Tout est objet : les données ordinaires comme les nombres ou les
chaînes de caractère sont des objets ; les fonctions sont des objets ; les
modules sont des objets ; et même les classes sont des objets....
Un objet B possède:
▪identité id(B)
▪Un type type(B): (intrinsèque : int, float, str, bool ... ou définit par
l’utilisateur à l’aide d’une classe)
▪contient des données (valeur).
▪L’opérateur « is » compare l’identité de 2 objets (adresses)
▪L’opérateur « == » compare le contenu de deux objets

59
1) Les conteneurs sous Python :
Objet Composite

Un conteneur est un objet composite destiné à contenir d’autres objets:

▪ nous distinguons les séquences, les tableaux associatifs, les
ensembles et les fichiers textuels.
▪ Les conteneurs sont des objets itérables.
Deux classements sont possibles :
1) Mutables et Non Mutables
▪ mutable : modification autorisée
▪ non mutable: modification non autorisée
2) Ordonnés et Non ordonnés

60
1) Les conteneurs sous Python
Les séquences (1/2)
Une séquence est un conteneur ordonné d’éléments indexés par
des entiers indiquant leur position dans le conteneur.
Les indices commencent par 0.
Si « S » est une séquence :
▪ S[i] : retourne l’élément d’indice i de S
▪ S[ :a] : sous séquence d’éléments de début jusqu’à l’élément d’indice « a » exclu
▪ S[a: ] : sous séquence d’éléments de l’indice « a » inclus jusqu’à la fin
▪ S[ : ] : toute la séquence

61
1) Les conteneurs sous Python
Les séquences (2/2)

▪S[a:b] : sous séquence d’éléments allant de l’indice « a » inclus jusqu’à

l’élément d’indice « b » exclu
▪S[a:b:c] : sous séquence d’éléments de l’indice « a » inclus jusqu’à
indice « b » exclu par pas égal à « c »
Il existe trois types de séquences :
▪Les listes
▪Les chaînes
▪Les tuples

62
1) Les conteneurs sous Python

A. Les listes
Une liste est une collection ordonnée et modifiable d’objets
éventuellement hétérogènes séparés par des virgules et définis
entre crochets [ ].
▪len(L) : nombre d’éléments .
▪L[i] :élément d’indice « i ». Le premier élément d'une liste est
celui d'indice 0, le deuxième celui d'indice 1
Un indice négatif permet d'accéder aux éléments à partir de la fin
(dernier L[-1] et son premier L[-len(L)])

63
 A. Les listes : Indexation et Slicing
Exemple :
Création et Accès Slicing
>>> L=[1, 2, 3, 6, 1.3, "hello", "bb"] >>> L[3:]
>>>len(L) [6, 1.3, 'hello', 'bb']
7 >>> L[:5]
>>L[0] [1, 2, 3, 6, 1.3]
1 >>> L[2:5]
>>>L[len(L)-1] [3, 6, 1.3]
‘bb’ >>>L[1:7:2] ou L[1::2]
>>>L[-1] [2, 6, 'hello']
‘bb’ >>>L[::2]
>>> L[:] [1, 3, 1.3, 'bb']
[1, 2, 3, 6, 1.3, 'hello', 'bb'] >>> L[::-1]
>>> L[7] ['bb', 'hello', 1.3, 6,
...IndexError: list index out of range 3, 2, 1]
64
 A. Les listes:
Opérations sur les listes
>>>L_vide=[]
>>>L=list(range(5))
>>>L + [0,3,1] #l’opérateur + concatène les listes et donne une nouvelle liste
[0,1,2,3,4,0,3,1]
>>> L # L reste inchangée !!!!
[0,1,2,3,4]
>>>L*2 #L’opération list*n ou n*list concatène n copies de la liste
[0,1,2,3,4,0,1,2,3,4]
>>>L=L*2
>>>L
[0,1,2,3,4,0,1,2,3,4]
>>>L=list(range(5))
>>> L
[0, 1, 2, 3, 4]
>>> L+[1]*4
[0, 1, 2, 3, 4, 1, 1, 1, 1]
65
 A. Les listes
Copie de liste (1/4)
>>> L=list(range(10))
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L1=L # Attention les deux listes référencient le même objet en mémoire

>>> L.append(5) # ajoute 5 en fin des deux listes

>>> L1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
>>> id(L), id(L1)
(46713952,46713952)

print id(L) == id(L1) # True - L est le même objet que L1

print id(L[0]) == id(L1[0]) # True - L[0] est le même objet que L1[0]
66
A. Les listes
Copie de liste (2/4)
Exemple :
▪ Copier une liste de cette manière :
>>> x = [1,2,3]
>>> y = x
▪ 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?

67
 A. Les listes
Copie de liste (3/4)
▪ Pour recevoir une copie de liste indépendante, plusieurs manières existent:
>>> L2=L[:] print id(L) == id(L2) # False – L2 est un nouvel objet
>>> id(L), id(L1), id(L2) print id(L[0]) == id(L2[0]) # True – L2[0] est le même objet que L[0]
(46713952, 46713952, 37856880)
▪Ou encore:
>>>from copy import *
print id(L) == id(L3) # False – L3 est un nouvel objet
>>> L3=copy(L) print id(L[0]) == id(L3[0]) # True – L3[0] est le même objet que L[0]

>>> id(L), id(L1), id(L2), id(L3),

(46713952, 46713952, 37856880, 46752632)
▪Ou encore: print id(L) == id(L4) # False – L4 est un nouvel objet
>>>L4=deepcopy(L) print id(L[0]) == id(L4[0]) # False – L4[0] est un nouvel objet
68
 A. Les listes
Copie de liste (4/4)
>>> L.append(4)
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4]
>>> L1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 4]
>>>L2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
>>> L3
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
>>> L4
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5]
>>> L is L1
True
>>> L is L2
False
>>>L2 == L3; L2 is L3
True False 69
A. Les Listes
Méthodes prédéfinies
>>> nbr=[17,38,10,25,72]
>>> nbr.sort() >>> nbr[0]=11
>>> nbr >>> nbr
[10, 17, 25, 38, 72] [11, 25, 17, 10]
>>> nbr.append(12) >>> nbr[1:4]=[14,17,2]
>>> nbr >>> nbr
[10, 17, 25, 38, 72, 12] [11, 14, 17, 2]
>>> nbr.reverse() >>> nbr.pop()
>>> nbr 2
[12, 72, 38, 25, 17, 10] >>> nbr
>>> nbr.remove(38) [11, 14,17]
>>> nbr >>> nbr.extend([17,3,6])
[12, 72, 25, 17, 10] >>> nbr
>>> nbr.index(17) [11, 14, 17, 17, 3, 6]
3 >>> nbr.count(17)
>>>del nbr[1] 2
>>>nbr
[12,25,17,10] 70
B. Les chaînes de caractères (1/5)
Une chaîne de caractère est une séquence de caractère uni-code de la classe str.
Syntaxe:
▪ C’est une séquence de caractères entre simple ou double côtes non modifiable!
▪ Même principe d’indexation que les listes.

Exemple:
>>> ch1='toto' >>> ch="bonjour"
>>> type(ch1) >>> ch_vide=""
<class 'str'> >>> ch_n_vide=" "
>>>ch_vide=‘’ >>> ch_vide==ch_n_vide
>>>ch_vide1="" False
>>>ch_vide==ch_vide1 >>> ch[0]
True 'b'

71
B. Les chaînes de caractères (2/5)

>>> ch="bonjour" Mais:

>>> ch[-1]
'r' >>> ch[0]='t'
>>> len(ch) TypeError: 'str' object does not
7 support item assignment
>>> ch[:3]
Opérateurs + et *:
'bon'
>>> ch='bon'
>>> ch[3:]
>>> ch1='jour'
'jour' >>> ch + ch1
>>> ch[2:5] 'bonjour'
'njo' >>> ch2=ch + ch1
>>> ch[::-1] >>> ch2*3
'ruojnob' 'bonjourbonjourbonjour '

72
B. Les chaînes de caractères (3/5)
>>> dir(str)
[' add ',…… 'index', 'isalnum', 'isalpha',
'isdecimal', 'isdigit', … 'islower', 'isnumeric',
'isspace', 'istitle', 'isupper', 'join', 'ljust',
'lower', 'lstrip', 'maketrans', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title',
'translate', 'upper', 'zfill']
>>> help(str.isalpha)
Help on method_descriptor:
isalpha(...) S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.

73
 B. Les chaînes de caractères (4/5)
Principales méthodes
>>>ch="BienVenu"
◦ isupper() et islower() : retournent True si la chaîne ne contient
respectivement que des majuscules/minuscules :
>>> ch.isupper()
False
◦ istitle() : retourne True si seule la première lettre de chaque mot de la chaîne est en
majuscule, et le reste du mot sont des lettres minuscules, sinon False:
>>> ch.istitle()
False
◦ isalnum(), isalpha(), isdigit() et isspace() : retournent True si la chaîne ne contient
respectivement que des caractères alphanumériques, alphabétiques, numériques
ou des espaces :
>>> ch.isalpha()
True
74
B. Les chaînes de caractères (5/5)
Principales méthodes
>>> ch.upper() # le résultat est une nouvelle chaîne
'BIENVENU'
>>> ch
'BienVenu'
>>> ch.lower()
'bienvenu’
>>> ch=ch.upper()
>>> ch
'BIENVENU'
Autres Méthodes utiles:
>>> ch= " bonjour tout le monde "
>>> ch.strip()
'bonjour tout le monde'
>>> ch.split()
['bonjour', 'tout', 'le', 'monde']
75
 C. Les tuples (1/3)
Un tuple est une collection ordonnée et non modifiable d’éléments éventuellement
hétérogènes.
Syntaxe:
▪ Éléments séparés par des virgules, et entourés de parenthèses.
>>> t = 12345, 54321, ’salut!’
>>> t[0]
12345
>>> t
(12345, 54321, ’salut!’)
Les Tuples peuvent être imbriqués:
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, ’salut!’), (1, 2, 3, 4, 5))
76
 C. Les tuples (2/3)

■ Un problème particulier (tuple 0 ou 1 élément):

➢ Les tuples vides sont construits avec des parenthèses vides;
➢ Un tuple avec un seul élément est construit en faisant suivre cet élément
d’une virgule
■ Par exemple :
>>> empty = ()
>>> singleton = ’salut’, # notez la virgule en fin de ligne
>>> len(empty), len(singleton), singleton
(0, 1, ('salut',))

77
C. Les tuples (3/3)
Remarque :
Les chaînes et les Tuples n’étant pas modifiable, il est possible de migrer vers des
listes au moyen de l’instruction suivante list()
>>> t=(1,2,3)
>>> t=list(t)
>>> type(t)
<class 'list'>
>>> t.append(5)
>>> t
[1, 2, 3, 5]
>>> ch="Bonjour"
>>>list(ch)
['b', 'o', 'n', 'j', 'o', 'u', 'r']

78
 D. Les dictionnaires (1/5)
Un dictionnaire (tableau associatif) est un type de données permettant de stocker
des couples cle:valeur,
▪ avec un accès très rapide à la valeur à partir de la clé,
▪ la clé ne peut être présente qu’une seule fois dans le tableau.
Caractéristiques:
▪ l’opérateur d’appartenance d’un élément « in » ;
▪ la fonction taille « len() » donnant le nombre de couples stockés ;
▪ permet de retrouver un objet par sa clé
▪ Il est itérable (on peut le parcourir)
▪ Non ordonné
▪ Mutable.

Python propose la class dict.

79
 D. Les dictionnaires (2/5)
>>>d={1:'un', 2:'Deux',3:'trois',4:'Quatre', 5:'cinq'}
>>> type(d)
<class 'dict'>
>>> dir(dict)
[' class ', ….. ' repr ', ' setattr ‘,
setitem ', ‘ sizeof ', ' str ', ' subclasshook ', 'clear', 'copy', 'fromkeys', 'get', 'items',
'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>> help(dict.keys)
Help on method_descriptor:keys(...)
D.keys() -> a set-like object providing a view on D's keys
>>>d. setitem (6,’six’) #ajoute un couple clé-valeur
>>>d
{1: 'un', 2: 'Deux', 3: 'trois', 4: 'Quatre', 5: 'cinq', 6:'six'}

80
D. Les dictionnaires (3/5)
>>>coef={"maths":5, "physique":4, "info":4}
>>>coef.items()
dict_items([('maths', 5), ('physique', 4), ('info', 4)])
>>>coef.keys()
dict_keys(['maths', 'physique', 'info'])
>>>coef.values()
dict_values([5, 4, 4])
>>> coef["maths"]
5

81
 D. Les dictionnaires (4/5)
Le parcours d’un dictionnaire:

1ere méthode : >>> for i in coef.items():

print(i)
('maths', 5)
('physique', 4)
('info', 4)

2éme méthode :
>>>for matiere, coefficient in coef.items():
print(matiere, ':', coefficient)
maths : 5
physique : 4
info : 4 82
 D. Les dictionnaires (5/5)
Exemples de dictionnaires
>>> # insertion de clés/valeurs une à une >>> # définition en compréhension (ou intension)
>>> d1 = {} # dictionnaire vide >>> d3 = {x: x**2 for x in (2, 4, 6)}
>>> d1["nom"] = 3 >>> print(d3)
>>> d1["taille"] = 176 {2: 4, 4: 16, 6: 36}
>>> print(d1) >>> # utilisation de paramètres nommés
{'nom': 3, 'taille': 176} >>> d4 = dict(nom=3, taille=176)
>>> # définition en extension >>> print(d4)
>>> d2 = {"nom": 3, "taille": 176} {'nom': 3, 'taille': 176}
>>> print(d2) >>> # utilisation d'une liste de couples clés/valeurs
{'nom': 3, 'taille': 176} >>> d5 = dict([("nom", 3), ("taille", 176)])
>>> print(d5)
{'nom': 3, 'taille': 176}

83
 E. Les ensembles (1/2)
Un ensemble est une collection non ordonnée et mutable d’objets uniques.
Les ensembles sont des structures non indexées !
Syntaxe:
On crée des ensembles en appelant avec des accolades ou avec la fonction set(). Notez que
{} ne crée pas un ensemble vide, mais un dictionnaire vide ; utilisez set() pour ce cas.
Exemple:
>>>S={1,1,3,3,'a','b','ccc',2,2,1,'a','a','bb'}
>>>S
{'a', 1, 2, 'b', 'bb', 3, 'ccc'}
>>>S.add(9)
>>>S
{'a', 1, 2, 'b', 'bb', 3, 'ccc‘,9}
84
 E. Les ensembles (2/2)
Les Opérations :
>>> e={1,2,3,'E','E','R','A',3,3,2,6}
>>> e1=set([1,2,3,'k','j',2,2,'L','A',3,3,2,6])
>>> type(e),type(e1)
<class 'set'> <class 'set'>
>>> e1
{1, 2, 3, 6, 'L', 'A', 'k', 'j'}
>>> e|e1 #opération d'union
{'A', 1, 2, 3, 'E’, 6, 'k', 'j', 'L', 'R'}
>>> e&e1 #opération d’intersection
{'A', 1, 2, 3, 6}
>>> e-e1 #opération de différence
{'R', 'E'}
85
2) Les fonctions en Python
Syntaxe
def NomFonction (Paramètres):
BlocInstructions

▪ def : Mot clé qui sert à déclarer un objet de type fonction

▪ NomFonction: le nom de la fonction utilisé dans les appels
▪ paramètres : Si la fonction a plusieurs paramètres, on utilise les virgules
pour les séparer ;
➢ en cas ou il n’y a pas de paramètres, on ouvre et on ferme les
parenthèses obligatoirement ;
➢ on précise jamais le type des paramètres ;
86
 2) Les fonctions en Python

Si on veut que celle-ci renvoie une valeur, il faut utiliser le mot clé « return ».
Exemple 1:
>>> def carre(x):
return x**2
>>> carre(3)
9

De même que pour les boucles et les tests, l’indentation de ce bloc

d’instructions (i.e. le corps de la fonction) est obligatoire.

87
 2) Les fonctions en Python
Exemple 2:
>>> res = carre(2)
>>> print(res)
4
▪ Ici, le résultat renvoyé par la fonction est stockée en mémoire dans la variable « res ».
▪ Une fonction ne prend pas forcément un argument et ne renvoi pas forcément une valeur.
Exemple 3:
>>> def hello():
print("bonjour")
>>> hello()
bonjour

88
 2) Les fonctions en Python
Dans ce cas la fonction hello() se contente d’imprimer la chaîne de caractères « Bonjour » à
l’écran.
➢ Elle ne prend aucun argument et ne renvoie aucun résultat.
➢ Par conséquent, cela n’a pas de sens de vouloir récupérer dans une variable le résultat
renvoyé par une telle fonction.
➢ Si on essaie tout de même, Python affecte la valeur «None» qui signifie « rien » en anglais :
>>> x = hello()
bonjour
>>> print(x)
None

89
2) Les fonctions en Python
Exemple :
>>>def TableMul5():
""" Affiche la table de
multiplication de 5 """
for i in range (1,11):
print('5 *', i,'= ',5*i)

>>> help(TableMul5)
Help on function TableMul5 in module main :
TableMul5()
Affiche la table de
multiplication de 5
>>> TableMul5()
5*1= 5 5 * 6 = 30
5 * 2 = 10 5 * 7 = 35
5 * 3 = 15 5 * 8 = 40
5 * 4 = 20 5 * 9 = 45
5 * 5 = 25 5 * 10 = 50 90
 2) Les fonctions en Python
▪ Python est en effet connu comme étant un langage au typage dynamique, c’est-
à-dire qu’il reconnaît automatiquement le type des variables au moment de
l’exécution,
Exemples :
>>> def fois(x,y):
return x*y
>>> fois(3,2)
6
>>> fois(‘p’,2)
pp
▪ L’opérateur « * » reconnait plusieurs types (entiers, réels, chaînes de caractères),
notre fonction est donc capable d’effectuer plusieurs tâches avec le même
code source!
91
 2) Les fonctions en Python
Un autre gros avantage de Python est que ses fonctions sont capables de renvoyer
plusieurs valeurs à la fois, comme dans cette fonction :
>>> def carre_cube(x):
...
return x**2,x**3
En réalité Python renvoie un objet séquentiel qui peut par conséquent contenir
plusieurs valeurs.
▪ Dans notre exemple Python renvoie un objet « tuple » car on a utilisé une
syntaxe de ce type.
▪ Notre fonction pourrait aussi renvoyer une liste :
>>> def carre_cube2(x):
return [x**2,x**3]

92
 2) Les fonctions en Python
Paramètres positionnels
Python autorise d’appeler la fonction sans trop respecter l’ordre des arguments
au moment de la déclaration.
▪ Il suffit d’utiliser le nom du paramètre au moment de l’appel et de préciser la
valeur qu’il prend :
>>> def Aff(nom, prenom, age):
print('nom=', nom)
print('prenom=', prenom)
print('age=', age)

>>> Aff(age=20, prenom=‘Alex', nom=‘Dupont')

nom= Dupont
prenom= Alex
age= 20
93
2) Les fonctions en Python
Nombre de paramètres variable

Python permet de définir une fonction avec un nombre arbitraire de

paramètres.
▪ Généralement ce paramètre est appelé « args » et il est toujours précédé du
caractère « * ».
▪ La syntaxe *args permet d’indiquer lors de la définition d’une fonction que
cette dernière peut accepter un nombre variable d’arguments.
▪ Ces arguments sont intégrés dans un tuple. On va pouvoir préciser 0, 1 ou
plusieurs paramètres classiques dans la définition de la fonction.
▪ Ceci permet une flexibilité sur le nombre des paramètres au moment de
l’appel.

94
2) Les fonctions en Python
Nombre de paramètres variable
Exemple :
>>> def somme(*args):
s=0
for n in args:
s+=n
print (‘la somme est : ’, s)

>>> somme(1,2)
la somme est : 3
>>> somme(1,2,3,4)
la somme est : 10
>>> somme(30,100,2)
la somme est : 132
95
 2) Les fonctions en Python
Quand elle ne se trouve pas à la fin d’une fonction, mais au milieu, l’instruction « return »
a pour effet d’interrompre le déroulement de la fonction. Ainsi, on peut écrire :
>>>def puissance(x, n):
if (n==0):
return 1
r=1
for i in range(n):
r = r*x
return r
Si la valeur de « n » est nulle, l’instruction « return 1 » interrompra le
déroulement de la fonction et aucune des instructions suivantes (à partir de r = 1)
ne sera exécutée.
96
2) Les fonctions en Python
Portée des listes (1/2)
Soyez extrêmement attentifs avec les types modifiables (tels que les
listes) car on peut les modifier au sein d’une fonction :
>>> def MaFonction(): >>> liste = [1,2,3]
>>> MaFonction()
... liste[1] = -127 >>> liste
[1, -127, 3]
...
De même que si vous passez une liste en argument, elle est tout autant
modifiable au sein de la fonction :
>>> def MaFonction(x): >>> y = [1,2,3]
>>> MaFonction(y)
... x[1] = -15
>>> y
... [1, -15, 3]

97
 2) Les fonctions en Python
Portée des listes (2/2)
Une solution pour éviter la modification d’une liste lorsqu’elle est passée en tant
qu'argument, est de la passer explicitement afin qu’elle reste intacte dans le programme
principal.
>>> def ma_fonction(x):
... x[1] = -15
...
>>> y = [1, 2, 3]
>>> ma_fonction(y[:])
>>> y
[1, 2, 3]
>>> ma_fonction(list(y))
>>> y
[1, 2, 3]

Dans ces deux derniers exemples, une copie de « y » est créée à la volée lorsqu’on appelle
la fonction, ainsi la liste « y » du module principal reste intacte.
98
 2) Les fonctions en Python
Fonctions locales

Exemple : on veut écrire une fonction « max3 » calculant le maximum de trois

entiers.
▪ Pour cela, il est élégant de commencer par la définition d’une fonction «
max2 » calculant le maximum de deux entiers, pour l’utiliser ensuite
deux fois.
def max3(x, y, z): => On parle alors de fonction locale à une
def max2(u, v): autre fonction.
if u > v:
return u
else:
return v
return max2(x, max2(y, z)) 99
Chapitre 3 – Laprogrammation Orienté
Objet en Python

100
 Classes et objets en Python
■ Python est un langage de programmation orienté objet. Presque tout en Python est un
objet, avec ses propriétés et ses méthodes. Une classe est comme un usine d’objet pour
créer des objets.
■ Les objets Python sont similaires aux objets du monde réel. Par exemple, nous pouvons
créer un objet voiture en Python, qui aura des propriétés telles que la vitesse et la
couleur; et un comportement comme: accélérer et freiner.

101
Les classes
■ Une classe est un ensemble incluant des variables ou attributs et
des fonctions ou méthodes. Les attributs sont des variables
accessibles depuis toute méthode de la classe où elles sont définies.
■ Syntaxe : Pour créer une classe, utilisez le mot-clé class:
• La forme la plus simple de définition de classe ressemble à ceci :

class nom_classe :
# corps de la classe # ...

102
 Les classes
Instanciation

▪ Une instance correspond à un objet créé à partir d’une classe (via le

constructeur)
▪ L’instanciation : création d’un objet d’une classe

Syntaxe : Instanciation d’une classe :

cl=nom_classe() : affecte la nouvelle instance à la variable cl

103
 Les classes
Instanciation

■ Exemple: Créez une classe nommée Voiture, avec un attribut nommé ‘vitesse’:
class Voiture:
vitesse = 100
■ Créer un objet: Maintenant, nous pouvons utiliser la classe nommée Voiture
pour créer des objets.
■ Exemple: Créez un objet nommé ‘audi’ et affichez la valeur de la vitesse:
>>> audi = Voiture()
>>> print (audi.vitesse)
100

104
 Les classes
Constructeur
■ Les constructeurs sont généralement utilisés pour instancier une classe.
La tâche des constructeurs consiste à initialiser (attribuer des valeurs)
aux attributs de la classe lorsqu'un objet de la classe est créé.
■ En Python, toutes les classes ont une méthode appelée __init__(), qui
est automatiquement appelée lors de l’instanciation.
def __init__(self, liste_paramètres):
# Initialisiation

105
Les classes
Types de constructeurs
▪ constructeur par défaut: le constructeur par défaut est un constructeur simple
qui n’accepte aucun argument. Sa définition n’a qu’un seul argument qui soit une
référence à l’instance en cours de construction: __init __ (self)
▪ constructeur paramétré: Le constructeur paramétré prend son premier
argument en tant que référence à l'instance en cours de construction, appelée
self, et le reste des arguments est fourni par le programmeur.
➢ Exemple:
class Personne:
nom= ' '
prenom= ' '

# constructeur de la classe
def __init__(self, nom, prenom):
self.nom=nom
self.prenom=prenom
106
Exemple:
■ Créez une classe nommée Voiture, utilisez la fonction __init__() pour attribuer des
valeurs pour le modèle et la vitesse:
class Voiture:
def __init__(self, modèle, vitesse):
self.modèle = modèle
self.vitesse = vitesse
renault = Voiture("Mégane",, 100)
print(renault.modèle) Sortie:
Mégane
print(renault.vitesse)
100

107
 Les classes
Attributs
▪ Les attributs de classe sont des variables qui sont associées de manière explicite à une
classe.
▪ Les attributs de classe se comportent comme des variables globales pour toutes les
méthodes de cette classe.
▪ Comme les variables locales, elles apparaissent lorsqu’on leur affecte une valeur la
première fois.
class MaClasse :
def aff(self,y):
print("hello World"*y)
i=123456 # attribut de classe
▪ Vous pouvez à tout moment créer un attribut pour votre objet.
x= MaClasse()
x.compteur = 1 #création de l’attribut compteur 108
Les classes
Attribut de classe / d’instance
▪ Un attribut de classe est un paramètre statique en dehors et indépendamment de toute
instanciation,
▪ Un attribut d’instance est déclaré généralement dans le constructeur et précédé par self.
class Test:
chat = "noir"
def __init _(self):
self.chat = "gris"
instance = Test()
print (Test.chat)
print (instance.chat)
noir
Sortie :
gris 109
Les classes :
Méthodes
■ Les objets peuvent également contenir des méthodes. Les méthodes dans les objets sont
des fonctions qui appartiennent à l’objet.
■ Une méthode f ( ) est appelée comme suit: x.f( ) ( avec x est une instance de la classe).
■ Créons une méthode dans la classe Voiture:
class Voiture:
def __init__(self, modèle, vitesse):
self.modèle = modèle
self.vitesse = vitesse

def accelerer(self):
#ajoute 10 km par heure à la vitesse actuelle
self.vitesse = self.vitesse + 10

renault = Voiture("Mégane", 100)

renault.accelerer()
Sortie:
print("La vitesse actuelle:", renault.vitesse) La vitesse actuelle: 110
110
 Les classes
Méthodes spéciales
▪ Les méthodes spéciales, sont un groupe de méthodes intégrées présentes dans
chaque classe.
▪ Ces méthodes sont caractérisées par des doubles traits de soulignement au début et à
la fin du nom de la méthode. Ces méthodes ne sont pas destinées à être invoquées
directement par l'utilisateur mais par la classe lors de l'exécution de certaines actions.
Exemples :
## Syntaxe de haut niveau ## Méthode spéciale correspondante
# Opérations
objet1 + objet2 # objet1.__add__(objet2)
objet1 == objet2 # objet1.__eq__(objet2)

# Conversion en str ou affichage

print (objet) # objet.__str__()
str (objet) # objet.__str__()
# Appel d'une fonction
fonction() # fonction.__call__() 111
 Les classes
Méthodes spéciales
▪ Quand on affiche avec print une instance, la méthode __str__() s’exécute
implicitement pour récupérer la valeur à afficher.
▪ On peut donc coder la méthode str pour obtenir un affichage personnalisé :

class Livre: Sans redéfinition du _str _:

print(l)
def __init__(self, titre, auteur):
self.titre = titre < main .Livre object at 0x01F17050>
self.auteur = auteur
Suite à la redéfinition du _str _:
def __ str __(self): print(l)
return "{} de {}".format(self.titre, self.auteur)
l= Livre("L alchimiste", "P. Coehlo") L alchimiste de P. Coehlo

112
 Les classes
Méthodes spéciales
▪ Parfois il est intéressant de décortiquer un objet pour résoudre un bug ou pour comprendre un
script.
▪ La fonction dir(x)vous donne un aperçu des méthodes de l'objet x:
>>> class Voiture:
def init (self):
self.nom = "Ferrari"
def donne_moi_le_modele(self):
return "250"

>>> v= Voiture()
>>>dir(v)
['__doc__', '__init__', '__module__', 'donne_moi_le_modele', 'nom’,……….]
113
 Les classes
Attribut privé
■ Les attributs privés sont des attributs d'une classe qui ne sont accessibles qu'au
sein de la classe elle-même.
■ Si vous avez déjà travaillé avec des langages comme Java, vous savez peut-être
que les attributs privés sont rendus privés à l'aide du mot-clé private. Cependant,
Python n'a pas de mot-clé privé.
■ En Python, nous pouvons rendre un attribut privé en ajoutant 2 caractères de
soulignement _ avant notre nom de variable. Ici, au lieu d'utiliser name, nous
utilisons __name comme variable.
■ Exemple: class Dog:
def __init__(self, name):
self.__name = name
r = Dog("rocky")
print(r.__name)
AttributeError: 'Dog' object has no attribute '__name'
114
 Les classes
Attribut privé
■ Dans l’exemple précédent, pour que nous puissions accéder à l'attribut
__name, nous aurions normalement besoin de créer une méthode Getter
get_name pour accéder au nom.

class Dog:
def __init__(self, name):
self.__name = name
def get_name(self):
return self.__name

r= Dog("rocky")
print(r.get_name())

rocky

115
Les classes
Accesseur et mutateur (1/2)

Une convention de passer par :

• des getter (ou accesseur en français) pour récupérer un
attribut
• des setter (mutateur) pour changer la valeur d'un attribut.

116
Les classes
Accesseurs et mutateurs (2/2)
class Voiture :
def _init _(self): >>> v1=Voiture()
>>> print(v1.set_roues(7))
self.__roues=4
set_roues is called:
def get_roues(self): Changement du nombre
de roues
print ("get_roues is called: Récupération du
None
nombre de roues")
>>> print(v1.get_roues())
return self.__roues get_roues is called:
def set_roues(self, v): Récupération du nombre
de roues
print ("set_roues is called: Changement du 7
nombre de roues")
self.__roues = v
117
Les classes
Exemple de classe
class Etudiant:
""" Une classe qui représente un étudiant """
def _init__(self,n,a):
self.nom = n
self.__age = a
def get_age(self):
return self.__age

f = Etudiant("Akrem", 22)
print(f.nom) # Accès à l’attribut
“Akrem”
print(f.__age) # Accès à l’attribut
AttributeError: 'Etudiant' object has no attribute 'age'
print(f.get_age()) # Accès à la méthode
22 118
 Les classes
Les méthodes d’instance-self
▪ Voici un exemple de classe qui contient une méthode :
class MaClasse :
def ma_méthode(self):
print (self.mon_attribut)
▪ Le bloc indenté en-dessous du mot-clé class s’appelle le corps de la classe. Et les
méthodes sont définies avec le mot-clé def dans le corps de la classe.
▪ On dit que ce sont des méthodes d’instance parce qu’il faut créer une instance
pour pouvoir les appeler :
mon_instance = MaClasse()
mon_instance.ma_méthode()

▪ Dans la méthode d'instance, chaque objet aura un comportement différent.

119
 Les classes
Méthodes de classe
▪ Une méthode de classe se définit exactement comme une méthode
d'instance, à la différence qu'elle ne prend pas en premier paramètre self
(l'instance de l'objet) mais cls (la classe de l'objet).
▪ Une méthode de classe est une méthode qui est liée à une classe plutôt qu’à
ses objets. Il n’est pas nécessaire de créer une instance de classe pour
appeler la méthode.
▪ Une méthode de classe peut être appelée à la fois par la classe et ses
instances.
▪ On utilise ensuite un décorateur de Python pour lui faire comprendre qu'il
s'agit d'une méthode de classe, pas d'une méthode d'instance:
@classmethod
120
Les classes
Méthodes de classe
class Compteur:
"""Cette classe a un attribut de classe qui s'incrémente à chaque fois que l'on crée un objet de cette classe"""
objets_crees = 0 # Le compteur vaut 0 au départ
def __init__(self):
"""À chaque fois qu'on crée un objet, on incrémente le compteur"""
Compteur.objets_crees += 1
@classmethod
def combien(cls):
"""Méthode de classe affichant combien d'objets ont été créés"""
print("Jusqu'à présent, {} objets ont été créés.".format(cls.objets_crees))
c= Compteur()
Compteur.combien()
c1=Compteur()
Compteur.combien()

Jusqu'à présent, 1 objets ont été créés.

Jusqu'à présent, 2 objets ont été créés. 121
 Les classes
Méthodes statiques
Les méthodes statiques sont assez proches des méthodes de classe sauf qu'elles ne
prennent aucun premier paramètre, ni self ni cls.
Elles travaillent donc indépendamment de toute donnée, aussi bien contenue dans
l'instance de l'objet que dans la classe.

class Test:
"""Une classe de test tout simplement"""
@staticmethod
def afficher():
"""Fonction chargée d'afficher quelque chose"""
print("On affiche la même chose.")
print("peu importe les données de l'objet ou de la classe.")
t=Test()
t.afficher()

On affiche la même chose.

peu importe les données de l'objet ou de la classe. 122
Héritage
Syntaxe
La syntaxe pour définir une classe dérivée est la suivante :
Class NomClasseDerivee(NomClassedeBase):
<instruction1>
…
<instructionN>
L’exécution d’une définition de classe dérivée se déroule comme une classe de
base. Quand l’objet classe est construit, la classe de base est mémorisée. C’est ce
qui permet de trouver facilement un attribut.
Lorsqu’un attribut est référencé, il est recherché dans la classe dérivée s’il ne s’y trouve
pas on le recherchera dans la classe de base.

123
Héritage multiple

■ Python supporte également l’héritage multiple.

■ Une définition de classe avec plusieurs classes de base ressemble à :

Class NomClasseDerivee (Base1,Base2,..,BaseN) :

<instruction1>
…
<instructionN>
■Lorsqu’on référence un attribut, la recherche s’effectue de gauche à droite. Donc si
un attribut n’est pas trouvé dans NomClasseDerivee, on le cherchera d’abord dans
base1, puis dans base2, et ainsi de suite jusqu’à ce qu’on le trouve…

124
 Héritage
Surcharge
Il est possible d'écraser la méthode de la classe parente en la redéfinissant. On parle
alors de surcharger une méthode.
class Voiture: class VoitureSport(Voiture):
roues = 4 def __init__(self):
moteur = 1 self.nom = "Ferrari"
def __init__(self): def allumer(self):
self.nom = "A déterminer" print ("La voiture de sport démarre")
def allumer(self): ma_voiture_sport = VoitureSport()
print ("La voiture démarre") ma_voiture_sport.allumer()

La voiture de sport démarre 125

Héritage
Exemple d’Héritage
class Etudiant:
""" Une classe representant un étudiant"""
def init (self,n,a):
self.nom = n
self.age = a
self.moyenne = 16
def get_age(self):
return self.age
class Cs_etudiant (Etudiant):
""" Une classe qui hérite de la classe Etudiant """
def __init__ (self,n,a,s):
super(). init (self,n,a) #Appel de init de la classe Etudiant
self.section_num = s #Ajout d’un nouvel attribut d’instance
def get_age(self): #Surcharge de la méthode get_age
print ("Age: ", super().get_age())
126
Liste d’Objets
Création

Pour créer une liste d’objets de classe, il suffit de créer une liste et d’y insérer
les instances d’objets.
Exemple :
>>> ListEtudiants=[]
>>> ListEtudiants.append(Etudiant("manel",22))
>>> ListEtudiants.append(Etudiant("akrem",19))
>>> print("Affichage des étudiants : ")
>>> for i in range(len(ListEtudiants)) :
print(ListEtudiants[i].nom)

Affichage des étudiants :

manel
akrem 127