e

ri
Programmation ™ pour l’Économétrie

ét
o m
Alexandre Tessier © 2024
on
Éc
L3
 2
L3
Éc
on
o m
ét
ri
e
Table des matières

e
1 Propos liminaire 7

ri
2 Introduction 9
2.1 Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 C’est quoi programmer ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

ét
2.3 Pourquoi apprendre à programmer ? . . . . . . . . . . . . . . . . . . . . . . 10
2.4 Et les algorithmes dans tout ça ? . . . . . . . . . . . . . . . . . . . . . . . . 10
2.5 Python quésaco ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.6 Qu’est ce qu’un ordinateur ? . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.7 Que des 0 et des 1 ? . . . . . . . . . . . m . . . . . . . . . . . . . . . . . . . . 14
2.8 Installation de l’environnement Python . . . . . . . . . . . . . . . . . . . . 15
2.9 L’IDE spyder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Nombres, variables, booléens, textes 19

o
3.1 Données ' Objets, Types ' Classes . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Les nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3 Les variables (ou identificateurs) . . . . . . . . . . . . . . . . . . . . . . . . 21
on

3.4 Les booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.5 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.6 Les chaînes de caractères formatées . . . . . . . . . . . . . . . . . . . . . . 27

4 Listes, tuples, tranches 29

Éc

4.1 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.2 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3 Les types séquentiels et les tranches . . . . . . . . . . . . . . . . . . . . . . 32
4.4 Affectation de tuples ou listes . . . . . . . . . . . . . . . . . . . . . . . . . 35

5 Instructions composées, conditionnelles, boucles 37

5.1 L’indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
L3

5.2 Forme d’une instruction composée . . . . . . . . . . . . . . . . . . . . . . . 39

5.3 La conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4 La boucle « tant que » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.5 Les intervalles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.6 La boucle « pour » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

6 Fonctions 49
6.1 L’instruction def . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.2 L’objet None . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.3 Les espaces de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

3
4 TABLE DES MATIÈRES

6.4 Les docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

7 Dictionnaires, ensembles 59
7.1 Les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.2 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

8 Entrées-sorties 63
8.1 La fonction print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.2 La fonction input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

e
8.3 Les fichiers textes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

ri
9 Les expressions lambdas, génératrices, compréhensions 69
9.1 Les expressions lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
9.2 Les expressions génératrices . . . . . . . . . . . . . . . . . . . . . . . . . . 70
9.3 Les définitions en compréhension . . . . . . . . . . . . . . . . . . . . . . . 71

ét
10 Les erreurs et les tests 73
10.1 Les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
10.2 L’instruction try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10.3 L’instruction raise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
10.4 Les tests avec l’instruction assert . . . . . . . . . . . . . . . . . . . . . . . 78

11 Modules, packages
m 79
11.1 Le module math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
11.2 Le package NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
o
11.3 Le package pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
11.4 Le package matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
on

12 Les objets 83

13 Programmation avancée 85

14 Les types prédéfinis 87

14.1 Les booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Éc

14.2 Les entiers, les réels, les complexes . . . . . . . . . . . . . . . . . . . . . . 87

14.2.1 Les entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.2.2 Les réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
14.2.3 Les complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
14.2.4 Les opérateurs et fonctions . . . . . . . . . . . . . . . . . . . . . . . 88
14.2.5 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
L3

14.3 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

14.3.1 Les opérateurs et fonctions . . . . . . . . . . . . . . . . . . . . . . . 89
14.3.2 Les méthodes minuscules/majuscules . . . . . . . . . . . . . . . . . 89
14.3.3 Les méthodes d’alignement et recadrage . . . . . . . . . . . . . . . 90
14.3.4 Les méthodes de découpage . . . . . . . . . . . . . . . . . . . . . . 91
14.3.5 Les méthodes de test du contenu . . . . . . . . . . . . . . . . . . . 91
14.3.6 Les méthodes de recherche . . . . . . . . . . . . . . . . . . . . . . . 92
14.3.7 Les autres méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . 92
14.3.8 Les chaînes de caractères formatées . . . . . . . . . . . . . . . . . . 93
14.4 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
TABLE DES MATIÈRES 5

14.4.1 Les opérateurs, fonctions et instructions . . . . . . . . . . . . . . . 95

14.4.2 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
14.5 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
14.5.1 Les opérateurs, fonctions et instructions . . . . . . . . . . . . . . . 98
14.5.2 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
14.6 Les intervalles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
14.6.1 Les opérateurs, fonctions et instructions . . . . . . . . . . . . . . . 99
14.6.2 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

e
14.7 Les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
14.7.1 Les opérateurs, fonctions et instructions . . . . . . . . . . . . . . . 101
14.7.2 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

ri
14.8 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
14.8.1 Les opérateurs et fonctions . . . . . . . . . . . . . . . . . . . . . . . 103
14.8.2 Les méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

ét
15 Les Opérateurs 105
15.1 La priorité des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
15.2 L’opérateur ternaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
15.3 Les opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
15.4 Les opérateurs de comparaison . . . . .
m . . . . . . . . . . . . . . . . . . . . 107
15.5 Les opérateurs in et not in . . . . . . . . . . . . . . . . . . . . . . . . . . 107

16 Les identificateurs 111

o
17 Les instructions 113
17.1 Les instructions simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
17.1.1 L’évaluation d’expression . . . . . . . . . . . . . . . . . . . . . . . . 113
on

17.1.2 L’affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

17.1.3 L’instruction pass . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
17.1.4 L’instruction del . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
17.1.5 L’instruction break . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
17.1.6 L’instruction continue . . . . . . . . . . . . . . . . . . . . . . . . . 115
Éc

17.1.7 L’instruction return . . . . . . . . . . . . . . . . . . . . . . . . . . 115

17.1.8 L’instruction yield . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
17.1.9 L’instruction global . . . . . . . . . . . . . . . . . . . . . . . . . . 116
17.1.10 L’instruction nonlocal . . . . . . . . . . . . . . . . . . . . . . . . . 116
17.1.11 L’instruction import . . . . . . . . . . . . . . . . . . . . . . . . . . 116
17.1.12 L’instruction raise . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
17.1.13 L’instruction assert . . . . . . . . . . . . . . . . . . . . . . . . . . 117
L3

17.2 Les instructions composées . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

17.2.1 L’instruction if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
17.2.2 L’instruction match . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
17.2.3 L’instruction while . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
17.2.4 L’instruction for . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
17.2.5 L’instruction def . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
17.2.6 L’instruction with . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
17.2.7 L’instruction class . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
17.2.8 L’instruction try . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
6 TABLE DES MATIÈRES

18 Les fonctions prédéfinies 125

18.1 La fonction d’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
18.2 Les fonctions numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
18.3 Les fonctions constructeurs d’objets . . . . . . . . . . . . . . . . . . . . . . 126
18.4 Les fonctions sur les itérables . . . . . . . . . . . . . . . . . . . . . . . . . 129
18.5 Les fonctions sur les conteneurs . . . . . . . . . . . . . . . . . . . . . . . . 130
18.6 Les fonctions d’entrée-sortie . . . . . . . . . . . . . . . . . . . . . . . . . . 130
18.7 Les fonctions en lien avec les attributs d’objets . . . . . . . . . . . . . . . . 131
18.8 Les fonctions générales sur les objets . . . . . . . . . . . . . . . . . . . . . 132

e
18.9 Les « méta fonctions » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

ri
19 Les modules et packages prédéfinis 133
19.1 Le module math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
19.2 Le module random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
19.3 Le module statistics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

ét
19.4 Le module datetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
19.5 Le module array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
19.6 Le module decimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
19.7 Le package NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
19.8 Le package pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
19.9 Le package matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
o m
on
Éc
L3
Chapitre 1

e
Propos liminaire

ri
Cet enseignement ne s’adresse pas à des étudiants qui se destinent à devenir informati-
cien. Il peut y avoir, volontairement, des approximations ou incomplétudes. Cependant, ce

ét
support de cours peut être utilisé par l’informaticien qui souhaite apprendre la program-
mation . Il pourra ensuite compléter sa formation par des cours plus approfondis.
est un langage qui évolue régulièrement. Ce support a été rédigé en 2024 et se
base sur la version 3.12 de la documentation . Il peut y avoir de légères différences
avec la version de que vous utilisez.
Cet enseignement de licence économie parcours économétrie a pour objectif de pré-
parer à l’utilisation des librairies
m
NumPy (numpy), (pandas) et
(matplotlib) pour le traitement de données et les statistiques descriptives. L’objectif
est de préparer l’enseignement de master qui suivra.
o
Les chapitres 2 à 13 sont conçus pour être lus dans l’ordre,alors que les chapitres 14
on

à 19 sont à utiliser comme documentation de référence quand cela est nécessaire.

Le chapitre 2 est utile pour comprendre le fonctionnement général de l’ordinateur et

aider à assimiler certains éléments des chapitres suivants. Les notions abordées n’ont pas
besoin d’être comprises dans le détail, cela sera sans conséquences importantes pour la
suite. La présentation des concepts y est incomplète et très rapide : chaque point fait
Éc

l’objet d’un cours complet dans une formation informatique.

Il est indispensable pendant la lecture du cours, d’avoir un ordinateur avec un

environnement pour tester les exemples proposés, et d’autres exemples que
vous inventerez, au fur et à mesure de la lecture, afin de bien comprendre les concepts
présentés.
L3

7
8 CHAPITRE 1. A. Tessier

e
ri
ét
o m
on
Éc
L3
Chapitre 2

e
Introduction

ri
2.1 Références

ét
Ce cours se suffit à lui-même pour l’objectif fixé. Vous pouvez consulter d’autres sources
pour aller plus loin, comme [2], mais il est conseillé de vous concentrer uniquement sur ce
cours si vous rencontrez des difficultés.
Pour vos révisions vous pourrez regarder les sections 3 à 5 du tutoriel . Il est
bien fait et plutôt concis. m
Quand vous saurez programmer en , les meilleures sources seront les documenta-
tions officielles : [1] pour , [3] pour NumPy, [4] pour , [5] pour .
o
2.2 C’est quoi programmer ?
La programmation consiste à coder dans une machine des instructions pour que celle-ci
on

accomplisse une tâche particulière.

Il existe toutes sortes de machines programmables. Il peut s’agir de machines élec-
troniques, comme un ordinateur, mais aussi de machines mécaniques, comme le métier à
tisser Jacquard qui est considéré être la première machine programmable. Inventé à Lyon
en 1801, des cartes perforées permettaient de programmer le motif à tisser en indiquant
Éc

les positions des fils à soulever. Il fut la cause de la révolte des canuts.
D’une certaine manière, on peut considérer le système de cartes perforées de Jacquard
comme un langage de programmation qu’on qualifiera de langage machine, car l’instruc-
tion soulever un fil est l’action élémentaire que peut faire le métier à tisser. Un langage
de haut niveau consisterait, par exemple, à décrire les formes à tisser par des fonctions
mathématiques. Cela nécessiteraient alors que le métier à tisser soit capable d’interpréter
(ou de compiler) 1 ses fonctions pour les transformer en actions élémentaires : soulever tel
L3

fil à tel instant.

C’est pareil pour l’ordinateur. Il ne sait faire que des actions élémentaires, comme
additionner deux entiers, poursuivre par telle instruction si tel emplacement mémoire
vaut 0. . . Programmer avec ces instructions élémentaires serait trop complexe pour les
1. On parle de compilateur (ou compilation) quand l’ensemble des instructions de haut niveau sont
transformées à l’avance en actions élémentaires, une fois pour toute, pour former ce qu’on appelle un
programme exécutable. C’est alors seulement le programme exécutable qui est chargé sur la machine
pour être exécuté. On parle d’interprète (ou interprétation) quand ce sont les instructions de haut niveau
qui sont chargées sur la machine et qu’un mécanisme les transforme en actions élémentaires au moment
d’être exécutées.

9
10 CHAPITRE 2. A. Tessier

applications modernes. On a donc inventé des tas de langages de programmation dits de

haut niveau (C, Java, Python, Php, etc.) dans le but de faciliter la programmation. Ils
permettent d’écrire les programmes de manière synthétique et facilement compréhensible
par les programmeurs. Chaque langage a ses spécificités qui font qu’il est plus adapté
pour programmer tel ou tel type d’application. C’est pour cela qu’il existe de nombreux
langages de programmation, et il n’y en a pas de meilleur dans l’absolu.
Il n’en reste pas moins qu’au final, un programme dans un langage de haut niveau
sera toujours transformé en instructions élémentaires qui sont les seules comprises par
l’ordinateur. Il faut comprendre qu’un langage de haut niveau n’ajoute aucune capacité

e
nouvelle à l’ordinateur, il facilite juste la tâche du programmeur par son expressivité.
Une instruction de haut niveau correspond généralement a de nombreuses instructions

ri
élémentaires du langage machine.
Le programme écrit dans le langage de haut niveau s’appelle le code source (ou pro-
gramme source), alors que celui écrit en langage machine (ou proche du langage machine)
s’appelle le code exécutable (ou programme exécutable). Le code source est l’ensemble

ét
des instructions qu’on donne à l’ordinateur qui se contentera, après transformation en
instructions élémentaires, de les exécuter telles qu’on les lui a données. L’ordinateur est
un assemblage de composants électroniques qui ne fait que suivre exactement les ordres
donnés par les instructions du programme. Il n’est doté d’aucune forme d’intelligence (à
moins qu’il n’ait été programmé dans ce but). m
Les langages de haut niveau ne sont cependant pas aussi expressif qu’une langue
naturelle, comme le français. Ils ont une syntaxe très simple et très rigoureuse. La moindre
virgule mal placée, le moindre mot mal orthographié, et l’ordinateur ne comprend plus
les instructions. Dans le cas de , même un espace en trop pourra parfois poser
o
problème !
on

2.3 Pourquoi apprendre à programmer ?

Dans votre cas, ce n’est pas pour devenir informaticien — quoique, si cela vous intéresse
n’hésitez pas à m’en parler — mais parce que, dans le domaine de l’économie et de la
gestion, vous serez amenés à utiliser des outils informatiques pour réaliser vos missions en
Éc

entreprise.
À ce titre, il est avantageux de bien en comprendre le fonctionnement afin d’en opti-
miser l’utilisation. Mais surtout, vous pourrez être amené à développer vos propres petits
programmes quand ils sont simples, sans faire appel à un informaticien. Savoir le faire,
sera pour vous un atout indéniable.
Rassurez-vous, c’est tout à fait possible, sans pour autant avoir toutes les connaissances
qu’on acquiert dans un vrai cursus informatique.
L3

2.4 Et les algorithmes dans tout ça ?

Dans un programme, vous mettrez généralement en œuvre différents algorithmes.
Un algorithme est une méthode de résolution d’un problème spécifique. Il peut s’agir,
par exemple, de trier en ordre croissant une liste de valeurs, calculer efficacement le dé-
terminant d’une matrice, trouver le chemin le plus court d’un point à un autre dans un
réseau de transport. . . Pour résoudre tous ces problèmes, les informaticiens ont trouvé des
algorithmes efficaces, au regard de la complexité intrinsèque du problème. L’algorithme
2.5. PYTHON QUÉSACO ? 11

e
Figure 2.1 – logo ™

ri
étant la méthode de résolution du problème, il n’a pas besoin d’être décrit dans un lan-
gage de programmation particulier. Il peut même être décrit par des simples phrases en

ét
français.
Il ne vous sera pas utile d’étudier ou comprendre les algorithmes. Laissez cela aux
informaticiens. Mais vous devez savoir qu’ils existent pour être capable de les utiliser
dans les programmes que vous écrirez.

2.5 Python quésaco ?

m
est un langage de programmation né en 1989. À l’origine prévu pour être un
o
langage de script ; c’est-à-dire un langage de haut niveau, interprété, pour décrire des
petites suites de commandes ; il a été voulu facile à lire et écrire tout en étant puissant.
C’est pour cette raison qu’on appelle souvent script un programme/code .
on

Son nom est un hommage à la troupe d’humoristes britanique Monty Python. Son
logo (voir figure 2.1) représente deux serpents à la manière des anciens dessins mayas :
deux pythons de couleurs différentes avec une grosse tête et une queue raccourcie.
Aujourd’hui, est un vrai langage de programmation. C’est le langage le plus
utilisé dans le domaine de la science des données (data science) et de l’apprentissage
automatique (machine learning).
Éc

est un langage abordable facilement par le non informaticien. Il a une syntaxe

simple, mais très expressive, qui ne nécessite pas la compréhension de concepts trop com-
plexes. Il propose des structures de données riches et facilement utilisables. Il dispose de
nombreuses librairies 2 pour manipuler des données, par exemple : NumPy ou .
C’est pour cette raison qu’il a été choisi dans votre cursus : pouvoir manipuler facilement
des données sans pour autant devenir un informaticien.
L3

Certains langages de programmation nécessitent de grandes connaissances en informa-

tique, mais est un langage abordable facilement, et bien adapté à la manipulation
et l’exploitation de données.
En dehors d’être à la mode, les principaux avantages de sont :
1. être accessible et ne pas nécessiter une formation pointue en informatique ;
2. être très utilisé par les non-informaticiens : économistes, statisticiens, scientifiques. . . ,
mais aussi des informaticiens ;
2. Une librairie regroupe, autour d’une thématique, des fonctionnalités déjà programmées pour être
utilisées facilement dans les programmes.
12 CHAPITRE 2. A. Tessier

3. être interprété, ce qui facilite l’exécution du code source sur des ordinateurs diffé-
rents ;
4. avoir une syntaxe souple et riche avec de nombreuses expressions idiomatiques qui
offrent une grande expressivité ;
5. etc.
Mais ses principaux inconvénients sont :
1. être accessible et moins rigoureux que d’autres langages (par exemple, absence de
typage explicite, de déclaration des variables) rendant le code moins sûr et plus

e
difficile à debugger ;
2. être très utilisé par des non-infomaticiens qui n’ont pas toujours les compétences

ri
suffisantes et font, parfois, de la mauvaise programmation ;
3. être interprété, ce qui le rend plus lent que d’autres langages ;
4. avoir une syntaxe souple et riche qui peut perdre parfois le débutant dans de nom-
breuses expressions équivalentes ;

ét
5. etc.
Vous l’avez compris, ses avantages sont aussi ses inconvénients !

2.6 Qu’est ce qu’un ordinateur ?

m
Cette section et la suivante ne sont pas indispensables pour apprendre la programma-
tion , mais elles aident à la compéhension du fonctionnement de l’ordinateur.
o
L’ordinateur peut sembler être une machine très complexe. Ce sont ses capacités qui
lui donnent cette apparence d’être une machine complexe, mais on peut en décrire le
fonctionnement de manière assez simple. Un peu comme un métier à tisser qui serait
on

capable d’avaler des descriptions mathématiques de formes à tisser très sophistiquées,

alors que son fonctionnement au final consiste seulement à soulever certains fils puis faire
passer la bobine.
L’informaticien a une vision schématique de l’ordinateur qu’il appelle l’architecture de
von Neumann (voir figure 2.2).
Dans l’architecture de von Neumann, l’ordinateur est constituté de trois principaux
Éc

éléments :
— le processeur (CPU = Central Processing Unit), qui est lui même constitué de
l’unité de contrôle (Control Unit) qui contrôle le flux et l’exécution des instructions
élémentaires et l’unité de calcul (Arithmetic Logic Unit) qui réalise les calculs
arithmétiques et les opérations logiques ;
— la mémoire (RAM = Random Access Memory) qui stocke les données et les ins-
L3

tructions des programmes ;

— les entrées – sorties (I/O = Input/Output) qui permettent à l’ensemble de com-
muniquer avec les périphériques.
Le CPU et la RAM communiquent entre eux via un bus (généralement on considère
trois bus : le bus de données, le bus d’adresse et le bus de contrôle).
L’unité de calcul est capable de réaliser des calculs arithmétiques ou des opérations
logiques simples. Exemple : additionner deux nombres, tester si un nombre est positif,
etc.
L’unité de contrôle gère l’analyse et le séquençage des instructions (les actions élémen-
taires) à exécuter.
2.6. QU’EST CE QU’UN ORDINATEUR ? 13

architecture von Neumann périphériques d’entrée/sortie

Devices
mémoire
Random Access Memory clavier écran
entrée
Input souris imprimante
bus
scanner webcam
processeur

e
sortie disque dur clé USB
Central Processing Unit
Output
réseau micro

ri
séquenceur unité de calcul
Control Unit Arithmetic Logic Unit
haut-parleurs etc.

ét
Figure 2.2 – architecture de von Neumann

Dans ce modèle, les instructions à exécuter sont elles mêmes enregistrées dans la
mémoire. L’unité de contrôle se charge d’aller lire dans la mémoire les instructions du
programme à exécuter les unes après les autres.
m
Les processeurs modernes, qui comptent plusieurs milliards de transistors et sont or-
ganisés en plusieurs coeurs, sont capables de réaliser plusieurs instructions élémentaires
o
en même temps. L’architecture von Neumann est une vision abstraite des processeurs
modernes, mais qui reste globalement conforme à la réalité et suffisante pour comprendre
le fonctionnement de l’ordinateur.
on

La mémoire peut être vue comme une suite d’emplacements, chacun disposant d’une
adresse et contenant une suite de 0 et de 1 (pour des raisons historiques, la longueur de
la suite est un multiple de 8). Une valeur 0 ou 1 est appelé un bit. Une suite de 8 bits est
appelée un octet.
Le couple CPU – RAM est relié à de nombreux périphériques, comme l’écran, le clavier,
la souris, le disque dur, la caméra, le réseau, l’imprimante. . . Il communique avec ces
Éc

périphériques via les entrées – sorties. Les périphériques d’entrée sont ceux qui permettent
de faire circuler une information depuis le périphérique vers l’ordinateur. Par exemple le
clavier est un périphérique d’entrée : chaque fois que l’on presse une touche du clavier,
cette information est transmise par le clavier vers l’ordinateur. Les périphériques de sortie
sont ceux qui permettent de faire circuler une information depuis l’ordinateur vers le
périphérique. Par exemple l’écran est un périphérique de sortie. L’ordinateur enverra une
L3

information pour provoquer un affichage donné sur l’écran. Certains périphériques sont à
la fois des périphériques d’entrée et de sortie. On peut citer par exemple le disque dur sur
lequel il est possible d’écrire (sortie) ou de lire (entrée) des données, ou encore le réseau
qui permettra d’envoyer des informations ou d’en recevoir d’autres ordinateurs.
Comme indiqué, nous n’allons pas programmer directement en langage machine avec
les instructions élémentaires, mais nous utiliserons le langage de haut niveau . Pour
donner l’intuition, une instruction , comme x = y * 2 , consiste à donner à la va-
riable x la valeur de la variable y multipliée par 2. Elle correspond à une suite d’actions
élémentaires, qu’on pourrait résumer par : transférer la valeur à l’adresse de y de la
mémoire vers l’unité de calcul, la multiplier par deux, transférer le résultat à l’adresse de
14 CHAPITRE 2. A. Tessier

x en mémoire. Il existe aussi des instructions permettant de communiquer facile-

ment avec les différents périphériques de l’ordinateur. Par exemple, l’instruction de sortie
print("C'est simple !") , provoquera, grâce à des instructions élémentaires, l’affichage de
la phrase C’est simple ! dans la console .

2.7 Que des 0 et des 1 ?

e
Nous avons vu que la mémoire ne contient que des bits, c’est-à-dire des valeurs 0
ou 1. Pourtant, on y strockera toutes sortes de chose : des instructions de programmes,
des données numériques, du texte, des photos, de la musique, des vidéos, etc. Cela peut

ri
sembler surprenant, mais toutes ces choses peuvent être codées uniquement avec des 0 et
des 1, on dit alors qu’elles sont numérisées. Nous en donnons l’intuition, sans entrer dans
les détails.
Nous écrivons habituellement les nombres en base 10, en utilisant les 10 chiffres de 0

ét
à 9. Par exemple, le nombre 467 est le nombre 4 × 102 + 6 × 101 + 7 × 100 , c’est-à-dire
4 × 100 + 6 × 10 +7 × 1. En base 2, c’est la même chose mais seulement avec les chiffres 0 et
1. Ainsi le nombre qui s’écrit 1101 en base 2 est le nombre 1 × 23 + 1 × 22 + 0 × 21 + 1 × 20 ,
c’est-à-dire 1 × 8 + 1 × 4 + 0 × 2 + 1 × 1. C’est le nombre qui s’écrit 13 en base 10. On
peut donc écrire n’importe quel nombre entier en utilisant uniquement les chiffres 0 et 1.
m
Pour les nombres réels, on utilise parfois la notation scientifique. Par exemple, on écrit
9,238 E 2 pour désigner le nombre 9, 238 × 102 , c’est-à-dire 923,8. Dans cette écriture,
9,238 s’appelle la mantisse et 2 s’appelle l’exposant. On peut faire la même chose, mais
o
en écrivant mantisse et exposant en base 2. Ainsi, il s’agira encore de suites de 0 et de 1.
Un texte est une suite de caractères. Un caractère peut aussi être codé avec des 0
et des 1. Pour cela on fait correspondre à chaque lettre un entier. Par exemple, dans le
on

codage unicode 3 , le caractère W est codé par l’entier 89, qui s’écrit en base 2 : 1011001.
Il existe différentes manières de coder une image. L’une d’entre
elles, consiste à la voir comme une suite de pixels. Chaque
pixel a une couleur. Une couleur peut être codée par une
composition de rouge, vert et bleu. Pour chaque pixel, on uti-
lisera une suite de 3 entiers qui indiquent, chacun, le niveau
Éc

de rouge, de vert et de bleu du pixel. Dans ce codage, l’image

est simplement une suite de triplets d’entiers.
On voit que tout peut être codé avec des 0 et des 1. Mais alors, si la mémoire ne
contient que des suites de 0 et 1, comment savoir s’il s’agit de nombres, textes, images ?
Par exemple, si un emplacement de la mémoire contient la suite 01011001, comment savoir
s’il s’agit du caractère W ou de l’entier 89 ? C’est tout simplement la manière d’interpréter
L3

la valeur à cet emplacement mémoire qui fera que l’on considère que c’est l’un ou l’autre.
Dans le programme les données auront un type. Si le type est entier l’emplacement
mémoire sera interprété comme l’entier 89, si le type est caractère l’emplacement mémoire
sera interprété comme le caractère W. Cette notion de type a son importance. Par exemple,
le caractère 5 et l’entier 5 ne sont pas codé de la même manière : l’entier 5 est codé 101
(1 × 22 + 0 × 21 + 1 × 20 ), alors que le caractère 5 est codé en UTF-8 par l’entier 53
c’est-à-dire 110101 (1 × 25 + 1 × 24 + 0 × 23 + 1 × 22 + 0 × 21 + 1 × 20 ).

3. Unicode est un codage standard des caractères. C’est le plus utilisé. Il existe sous différentes formes,
la plus commune, en raison de sa compatibilité avec les codages plus anciens, est UTF-8.
2.8. INSTALLATION DE L’ENVIRONNEMENT PYTHON 15

Rassurez-vous, avec les langages de programmation de haut niveau, comme , on

n’a pas à se soucier de cela !

2.8 Installation de l’environnement Python

Pour saisir le code , on utilisera
— directement l’interprèteur ;
— un éditeur de texte ; 4

e
— ou un environnement de développement intégré (IDE pour Integrated Development
Environment).

ri
Pour simplfier, on peut dire que c’est le nombre d’instructions du programme qui définira
l’outil à utiliser. Pour quelques instructions, ça pourra être directement l’interprèteur
; pour des petits programmes, l’éditeur de texte suffira ; mais en général, on utilisera
un IDE qui apporte une interface facilitant grandement la programmation et la mise au

ét
point du programme.
Comme nous l’avons vu, l’ordinateur n’exécute que des instructions élémentaires. Il
faut donc un outil (interprète dans le cas de , compilateur pour d’autres langages)
qui transforme nos instructions de haut niveau (écrites en ) en instructions élé-
mentaires que l’ordinateur exécutera. Quelque soit le sytème d’exploitation 5 utilisé, un
m
interprète est généralement déjà installé sur votre ordinateur. Il est utilisable en
mode interactif dans un terminal. L’ouverture d’un terminal se fait par le menu des ap-
plications. Ensuite, la commande python3 permet de lancer l’interprète en mode
interactif :
o
Python 3.11.7 (main, Dec 15 2023, 18:12:31) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
on

>>>

Les >>> en début de ligne sont appelés le prompt . Ils nous indiquent que l’in-
terprète attend nos instructions, par exemple print("C'est simple !") :
Éc

Python 3.11.7 (main, Dec 15 2023, 18:12:31) [GCC 11.2.0] on linux

Type "help", "copyright", "credits" or "license" for more information.
>>> print("C'est simple !")
C'est simple !
>>>

L’utilisation d’un IDE s’avère rapidement beaucoup plus pratique.

Pour disposer de l’ensemble des outils, nous utilisons la distribution de
L3

. D’après WikipédiA :

4. Attention, ne pas confondre éditeur de texte et traitement de texte. L’éditeur de texte est un outil
pour saisir du texte et l’enregistrer dans un fichier sous forme de texte brut, c’est-à-dire sans aucune
mise en forme ou fioriture. Le traitement de texte, quant à lui, permet d’utiliser différentes polices de
caractères, faire de la mise en page, insérer des images. . . Un programme saisi dans un traitement
de texte, comme LibreOffice ou Word, serait totalement inexploitable pour l’environnement .
5. Le système d’exploitation (OS pour Operating System) est un ensemble de programmes qui per-
mettent d’exploiter votre ordinateur. Les grands systèmes d’exploitation utilisés de nos jours sont le
système libre et open source Linux (et ses dérivés comme Androïd), macOS (système commercial dérivé
du système libre FreeBSD) ou le vieux système propriétaire Windows toujours le plus utilisé sur PC.
 16 CHAPITRE 2. A. Tessier

e
ri
ét
Figure 2.3 – l’environnement de développement intégré
m
est une distribution libre et open source des langages de pro-
grammation et appliquée au développement d’applications dédiées
o
à la science des données et à l’apprentissage automatique (traitement de don-
nées à grande échelle, analyse prédictive).
L’installation de dépend du système d’exploitation utilisé : Linux, macOS
on

ou Windows. Suivez les instructions de la documentation d’installation. La distribution

installera tous les outils utilisés dans ce cours.

2.9 L’IDE spyder

Éc

Nous utiliserons l’IDE qui fait partie des outils de la distribution .

Il peut être lancé directement depuis le terminal ou depuis le navigateur .
La figure 2.3 présente la fenêtre principale de . Elle est composée de différentes
sous-fenêtres, par défaut il y en a trois :
— à gauche : l’éditeur de code ;
— en haut, à droite : la visualisation de l’aide, des variables, des graphiques ou de
l’explorateur de fichiers ;
L3

— en bas, à droite : la console et son historique.

Comme dans toute application, on trouve, en haut, des menus et des boutons.
Tapez dans la fenêtre d’édition à gauche l’instruction

7 print("C'est simple !")

puis cliquez sur le bouton (de manière équivalente le menu Run ou la touche F5) pour
lancer l’exécution et obervez le résultat dans la fenêtre de la console en bas à droite.
Vous remarquez, dans la fenêtre d’étition, la première ligne
 2.9. L’IDE SPYDER 17

1 # -*- coding: utf-8 -*-

Cette ligne qui commence par # est un commentaire. Elle est ignorée lors de l’exécution
des instructions, mais indique que le codage utilisé dans le script est la variante UTF-8
du codage unicode. Elle doit toujours être placée en tête du script. Les lignes suivantes,
encadrées par """ servent à la documentation du script. Ignorons-les également pour le
moment.

e
ri
ét
o m
on
Éc
L3
18 CHAPITRE 2. A. Tessier

e
ri
ét
o m
on
Éc
L3
Chapitre 3

e
Nombres, variables, booléens, textes

ri
3.1 Données ' Objets, Types ' Classes

ét
Le langage permet de manipuler différents types de données : des simples,
comme des nombres, des plus complexes, comme des tableaux.
Les données ont un type, par exemple 3 est un entier ( int en ) et 3.14 est
un réel ( float en ). En , on parlera d’objet plutôt que de donnée et de classe
plutôt que de type. On dira qu’un objet est instance d’une classe, pour dire que la donnée
est d’un type : 3 est une instance de int .
m
On verra plus tard qu’en réalité un objet est un peu plus qu’une donnée, parce qu’une
classe est plus qu’un type. En effet, on pourrait voir l’objet comme une donnée « intelli-
o
gente » qui sait faire des choses. Par exemple, tout entier sait nous dire ce qu’on obtient
si on lui ajoute un autre entier. Demander à l’entier 3 ce qu’on obtient quand on lui
ajoute 5 s’écrit (3).__add__(5) et sa réponse est l’entier 8 . Rassurez-vous, en pratique,
on

on écrira tout simplement 3 + 5 , qui donne le même résultat : 8 .

Deux caractéristiques des objets vont particulièrement nous intéresser :
1. Sont-ils modifiables (on dit aussi mutables) ?
Par exemple, le nombre 3 n’est pas modifiable, 3 sera toujours 3 quoiqu’il arrive.
Considerez maintenant une voiture, vous pouvez la modifier : remplacer les pneus
Éc

été par des pneux hiver, peindre la carrosserie d’une autre couleur, etc.
Pour les objets , c’est la même chose, certains sont modifiables, d’autres non.
Vous ne pourrez pas changer l’entier 3, mais vous pourrez ajouter un objet à une
liste d’objets.
2. Sont-ils itérables ?
Imaginez une bibliothèque. C’est une collection de livres. Vous pouvez la voir
L3

comme un tout : la biliothèque. Vous pouvez également la voir comme un livre,

puis un autre livre, puis le livre suivant, et ainsi de suite.
C’est un peu le principe d’un objet itérable en . Par exemple, pour une liste
d’objets, un mécanisme , appelé un itérateur, permet d’obtenir successive-
ment les objets de la liste, un par un. On peut manipuler la liste comme un tout,
mais on peut aussi, grâce à l’itérateur, manipuler ses éléments l’un à la suite de
l’autre.
Même si nous ne comprendrons les notions d’itérable, itérateur, itération, qu’à partir
de la section 5.6, rentenez qu’elles sont fondamentales en programmation .

19
20 CHAPITRE 3. A. Tessier

3.2 Les nombres

Les nombres sont des objets ni modifiables, ni itérables. Le langage permet de
manipuler trois sortes de nombres :
— les entiers, comme 3 ou -15 ;
— les réels 1 , comme 3.0 , -3.5 ou 1.52e-7 ;
— les complexes, comme 3+0j ou -3.5+7j (en mathématiques, j est noté i).
Nous n’utiliserons pas les complexes dans ce cours.
En général, on ne fait pas de différence entre l’entier 3 et le réel 3. Mais en informatique,

e
comme nous l’avons vu dans la section 2.7, la manière de coder ces valeurs n’est pas la
même : il ne va pas leur correspondre la même suite de 0 et 1. C’est le type de la donnée,

ri
plus exactement la classe de l’objet, qui permettra à d’interpréter correctement la
suite de 0 et 1 en mémoire. La notion de type ou classe est importante en programmation,
même si les choses peuvent paraître plus simples en que dans d’autres langages.
La fonction type permet de connaître la classe d’un objet x . On écrit type(x) qui

ét
nous donne le nom du type de x . En informatique on dit que type(x) retourne l’identi-
ficateur de la classe de x . On dit que x est une instance de cette classe.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
type(3) retourne int m
type(3.14) retourne float

On peut utiliser les opérations classiques pour écrire des expressions avec des nombres.
o
Si x et y sont des nombres :
— l’addition : x + y , par exemple 2 + 3 vaut 5 ;
— la soustraction : x - y , par exemple 2 - 3 vaut -1 ;
on

— la multiplication : x * y , par exemple 2 * 3 vaut 6 ;

— la division : x / y , par exemple 2 / 3 vaut 0.66666... ;
— la puissance : x ** y , par exemple 2 ** 3 vaut 8 .
— l’opposé : - x , par exemple - 3 vaut -3 .
On peut utiliser des parenthèses dans les expressions, comme (2 + 3) * 4 .
Les expressions sont évaluées de manière classique de gauche à droite en utilisant les
Éc

règles de priorité habituelles sur les opérateurs :

— 2 + 3 * 4 est équivalent à 2 + (3 * 4) et différent de (2 + 3) * 4 ;
— 2 - 3 - 4 est équivalent à (2 - 3) - 4 et différent de 2 - (3 - 4) .
a également deux autres opérateurs qui donnent, pour le premier, le quotient
de la division euclidienne (la division entière) et, pour le second le reste de la division
euclidienne :
L3

— le quotient : x // y , par exemple 25 // 3 vaut 8 ;

— le reste : x % y , par exemple 25 % 3 vaut 1 .
En effet, le quotient 25 // 3 vaut 8 et le reste 25 % 3 vaut 1, car 25 = 3×8+1. En ,
les deux opérations quotient et reste sont définies également pour des entiers négatifs et
même pour des réels.
1. En fait, utilise un sous-ensemble des réels appelé float . Il s’agit des nombres qui peuvent
s’écrire en base 2 avec un nombre fini de chiffres derrière la virgule. Cela a des conséquences, car un
nombre écrit en décimal (base 10) n’a pas toujours d’écriture finie en base 2. Par exemple le nombre
0, 1 en base 10 a une écriture infinie en base 2 : 0, 0001100110011 . . . , et sa valeur exacte n’existe pas en
!
3.3. LES VARIABLES (OU IDENTIFICATEURS) 21

Il existe aussi quelques fonctions classiques définies en , comme :

— la valeur absolue abs(x) ;
— l’arrondi round(x, n) pour arrondir x à n chiffres après la virgule, ou round(x)
pour arrondir x à l’entier le plus proche.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
la valeur de round(3.14159, 2) est 3.14

e
on dit que round(3.14159, 2) retourne 3.14

ri
Le module math fourni de nombreuses fonctions mathématiques supplémentaires. Pour
utiliser les fonctions du module math , il faut commencer par l’importer avec le code
import math (voir la section 17.1.11). Ensuite, on pourra utiliser les fonctions qui y sont
√

ét
définies. Par exemple, pour calculer 25, on utilise la fonction « square root » du module
math et on écrit math.sqrt(25) qui retourne comme résultat 5.0 . La section 19.1 donne
les principales fonctions du module math .
Comme vous serez amené à faire beaucoup de calculs avec des « float » qui sont en
réalité des arrondis de nombres réels (12 chiffres après la virgule pour la partie mantisse,
m
voir la section 2.7 et la note en bas de page 20), vous devez tout de suite savoir que ces
calculs ne sont pas toujours exacts. En revanche, le calul sur les entiers en est exact
(mais peut s’avérer long pour des entiers avec beaucoup de chiffres).
o
on

3.3 Les variables (ou identificateurs)

Nous introduisons maintenant la notion de variable .
Comme vu en section 2.7, les données sont stockées, dans l’ordinateur, sous forme
numérisée, c’est à dire sous forme de suites de 0 et 1. Pour accéder et exploiter facilement
Éc

ces données, appelées des objets en , on utilise des variables.

Une variable a un nom, on dit aussi un identificateur, constitué d’une suite de lettres
a → z et A → Z , de chiffres 0 → 9 et du caractère tiret du bas _ (appelé aussi blanc
souligné). L’identificateur de la variable ne peut pas contenir d’autres caractères, comme
des espaces ou des ponctuations par exemple. Il ne peut pas commencer par un chiffre.
Vous ne ferez pas commencer non plus par le tiret du bas _ , car cela a un sens particulier
en .
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
x , y24 , note_python sont des noms de variables autorisés
<x- , 24y , note python ne sont pas des noms de variables autorisés

Les caractères accentués, comme é è ê ë , ou des autres alphabet, comme β, R,

€ sont autorisés, mais on évitera généralement de les utiliser, car il ne sont pas toujours
22 CHAPITRE 3. A. Tessier

bien gérés par les OS propriétaires comme macOS ou le vieux systèmes d’exploitation
Windows.
Une convention, utilisée par tous les programmeurs , veut que les identificateurs
de variables soient écrits, de préférence, en minuscules avec les mots séparés par des _ ,
comme note_python . Même si c’est autorisé, on ne nommera pas une variable NOTE_PYTHON
ou Note_python ou notePython . . . On évitera aussi les identificateurs O (o majuscule),
l (L minuscule), I (i majuscule), qui peuvent être confondus avec les chiffres 0 et 1.
De manière générale, on peut considérer qu’une variable contient l’adresse en
mémoire 2 à laquelle on trouve un objet. On dit que la variable référence l’objet pour dire

e
qu’elle « contient » l’adresse mémoire à laquelle on trouve la valeur de l’objet. Dans le
cas où la variable référence un objet non modifiable, on peut considérer sans risque que

ri
la valeur de la variable est directement la valeur de l’objet, mais dans le cas où il s’agit
d’un objet modifiable, il est indispensable de comprendre que la variable contient l’adresse
mémoire à laquelle se trouve la valeur de l’objet, et, comme vous le constaterez plus tard,
deux variables différentes peuvent référencer le même objet en mémoire.

ét
On peut faire deux choses avec une variable :
1. On peut lui faire référencer un objet en mémoire, on dit aussi lui affecter une
valeur. Pour cela on utilise le symbole = . À droite du = , on met une expression
qui donne la valeur qui sera référencée par la variable qui se situe à gauche du = .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = 15.25
m
2 y24 = 14.5 + 16
o
3 note_python = (14.5 + 16) / 2

2. On peut utiliser sa valeur dans une expression.

on

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 y24 = 14.5 + 16
2 note_python = y24 / 2

à la ligne 1, on affecte la valeur de l’expression 14.5 + 16 à la variable y24

Éc

à la ligne 2, la variable note_python référence le résultat de la valeur référencée

par y24 divisée par 2 , c’est-à-dire 30.5 / 2 , soit 15.25

En aucun cas, il faut voir la ligne note_python = y24 / 2 comme une égalité ou une
équation à résoudre ! Il faut distinguer le rôle différent joué par la variable à gauche du =
et celle dans l’expression à droite. Dans un cas on lui affecte une valeur (pour note_python
L3

à gauche), dans l’autre cas on utilise la valeur (pour y24 à droite).

L’expression à droite peut se limiter simplement à une variable. Par exemple, quand
on écrit x = y c’est pour que x référence le même objet que y (le même emplacement
en mémoire).

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
x = y n’est pas la même chose que y = x :

2. Cette adresse est elle-même une donnée enregistrée en mémoire, mais ces considérations dépassent
les objectifs de ce cours.
 3.3. LES VARIABLES (OU IDENTIFICATEURS) 23

1 x = 1
2 y = 2
3 x = y

x et y référencent toutes les deux l’entier 2 , alors que

1 x = 1
2 y = 2
3 y = x

e
x et y référencent toutes les deux l’entier 1 .

ri
Vous vous doutez que deux variables qui référencent le même objet (le même espace
en mémoire) aura des conséquences dans le cas où l’objet en question est modifiable.
En effet, si x et y référencent le même objet et que l’on modifie l’objet référencée par
x , l’objet référencé par y est également modifié, puisque c’est le même objet (le même

ét
emplacement de la mémoire). Nous montrerons des exemples plus tard.
Un cas intéresant est celui où la même variable apparaît à gauche et à droite du = .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
m
1 x = 15.25
2 x = 2 * x

il faut comprendre, pour la deuxième affectation, qu’il y a d’abord l’évaluation de l’ex-

o
pression à droite du = , c’est-à-dire de 2 * x qui vaut 30.5 , puis la modification de x
pour qu’elle référence maintenant la valeur de cette expression, c’est-à-dire l’objet 30.5
on

Si l’on souhaite que plusieurs variables référencent le même objet, on peut enchaîner
les affectations. Si e est une expression quelconque, on écrit y = x = e pour que les
variables x et y référencent toutes les deux le même objet valeur de l’expression e .
C’est équivalent à x = e suivi de y = x .
Éc

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
après y = x = 14.5 + 16 , les variables x et y référencent toutes les deux le même objet
qui vaut 30.5

Quand on programme, on veux souvent ajouter à une variable une valeur, ou multiplier
une variable par une valeur, ou diviser une variable par une valeur. . . Dans ce cas, on
peut utiliser les opérateurs en place : += , -= , *= , /= , //= , %= , **= . Par exemple, si
L3

x vaut 3 , x += 2 consiste à ajouter 2 à x , qui aura ensuite la valeur 5 .

Il existe enfin une dernière forme d’affectation qui est une expression ayant comme
valeur la valeur affectée ! Cette expression utilise l’opérateur := , elle s’écrit (x := e) , où
x est une variable et e une expression. L’expression e est évaluée, c’est la valeur de
l’expression (x := e) , mais au passage, elle est affectée à x .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
considérons le code y = 5 + (x := 3 * 2) * 4
l’expression 5 + (x := 3 * 2) * 4 est évaluée dans l’ordre :
24 CHAPITRE 3. A. Tessier

— d’abord 5 qui vaut 5

— ensuite (x := 3 * 2) * 4
— d’abord (x := 3 * 2) qui vaut 6 qui est, au passage, affecté à x
— puis 6 * 4 qui vaut 24
— enfin 5 + 24 qui vaut 29 .
le résultat 29 est affectée à y
après exécution du code, x vaut 6 et y vaut 29

e
Cette expression d’affectation, appelée aussi expression morse, est peu utilisée en de-
hors de cas bien particuliers où il est utile d’avoir la valeur de l’expression et, en même
temps, conserver cette valeur dans une variable.

ri
3.4 Les booléens

ét
Il s’agit simplement des valeurs de vérités faux et vrai. Ce type, non modifiable, non
itérable, a seulement deux valeurs qui sont False (faux) et True (vrai).
Il y a trois opérateurs sur les booléens : not (négation, « non »), and (conjonction,
« et »), or (disjonction, « ou »), dont on donne les tables de vérités :

x not x
x
False
m y
False
x and y
False
x or y
False
False True False True False True
True False True False False True
o
True True True True

On peut retenir que and est vrai dans un seul cas : quand les deux sont vrais, or est
on

faux dans un seul cas : quand les deux sont faux.

Le langage propose des opérateurs de comparaison dont le résultat est une
valeur de vérité, c’est-à-dire un booléen False ou True :
— égal (=) : x == y , par exemple 2 == 3 vaut False ;
— différent (6=) : x != y , par exemple 2 != 3 vaut True ;
— inférieur (<) : x < y , par exemple 2 < 3 vaut True ;
Éc

— inférieur ou égal (≤) : x <= y , par exemple 2 <= 3 vaut True ;

— supérieur (>) : x > y , par exemple 2 > 3 vaut False ;
— supérieur ou égal (≥) : x >= y , par exemple 2 >= 3 vaut False ;
Notez que l’opérateur d’égalité s’écrit == , car le symbole = est déjà utilisé pour l’affec-
tation. C’est une source d’erreur classique chez le programmeur débutant. Les opérateurs
6=, ≤, ≥ s’écrivent != , <= , >= par facilité, car les symboles 6=, ≤, ≥ ne sont pas présents
L3

sur le clavier de l’ordinateur.

Contrairement à la majorité des langages de programmation, on peut enchaîner les
comparaisons en . Écrire x < y < z est équivalent à x < y and y < z , ou encore
x < y + 1 == z * 2 est équivalent à x < y + 1 and y + 1 == z * 2 .
Il existe un opérateur qui ne doit pas être confondu avec == , il s’agit de l’opérateur
is . x == y vaut True si x et y ont la même valeur. x is y vaut True si x et y
référencent le même objet en mémoire. On voit que si x is y , alors x == y . En revanche,
on peut avoir x == y sans avoir x is y . C’est le cas où x et y référencent deux objets
à des emplacements différents en mémoire, mais les deux objets ont la même valeur.
La section 15.1 donne les règles de priorités entre les différents opérateurs en .
 3.5. LES CHAÎNES DE CARACTÈRES 25

3.5 Les chaînes de caractères

Les chaînes de caractères sont des objets non modifiables, mais itérables. Une chaîne
de caractères est une suite quelconque de caractères, on peut dire qu’un texte (avec des
lettres, des ponctuations, des espaces, des retours à la ligne. . . ) est une chaîne de carac-
tères.
Le texte la programmation python s’écrit en 'la programmation python' . À
noter que les guillements ne font pas partie de la chaîne de caractères, mais servent
seulement à la délimiter. Il s’agit bien du texte la programmation python.

e
Mais comment faire pour le texte la programmation 'python' qui contient lui-même
le caractère ', alors que ce caractère sert à délimiter le début et la fin de la chaîne ?

ri
On peut écrire les chaînes de caractères de quatre manières différentes, par exemple,
pour le texte la programmation python :
— entre guillemets simples : 'la programmation python' ;
— entre guillemets doubles : "la programmation python" ;

ét
— entre triple guillemets simples : '''la programmation python''' ;
— entre triple guillemets doubles : """la programmation python""" .
Dans les 4 cas, il s’agit bien du texte la programmation python.
Quand la chaîne est délimitée par des guillemets simples, on peut utiliser un guillemet
double à l’intérieur, par exemple, la chaîne 'la programmation "python"' pour le texte
la programmation "python". En revanche pour introduire un guillemet simple, il faut

guillemets doubles, il faut utiliser \" pour mettre un guillemet double dans la chaîne.
o m
utiliser le caractère d’échapement \ suivi de '. De même si la chaîne est délimitée par des

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
'la programmation \'python\'' ou "la programmation 'python'"
correspondent au texte la programmation 'python'
on

mais 'la programmation 'python'' est une erreur : invalid syntax

'la programmation "python"' ou "la programmation \"python\""
correspondent au texte la programmation "python"
mais "la programmation "python"" est une erreur : invalid syntax
Éc

Une chaîne délimitées par des guillements simples ou doubles ne peut pas être écrites
sur plusieurs lignes. Pour représenter un texte de plusieurs lignes, on utilise les triples
guillemets (simples ou doubles).

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 """voici un texte
sur plusieurs
L3

2
3 lignes"""

qui correspond au texte :

voici un texte
sur plusieurs
lignes

On peut aussi utiliser le caractère d’échappement \ suivi de n pour écrire un texte de

plusieurs lignes en une seule ligne, \n signifie « nouvelle ligne ».
26 CHAPITRE 3. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
'voici un texte\nsur plusieurs\nlignes' pour le texte :

voici un texte
sur plusieurs
lignes

Puisque le caractère \ sert de caractère d’échappement, pour le mettre dans un texte,

e
il faut simplement le doubler, par exemple 'un \\ !' correspond au texte un \ !.
On peut concaténer (mettre bout à bout) des chaines de caractères avec l’opérateur
+ . L’expression 'la' + ' programmation' vaut 'la programmation' .

ri
On peut également multiplier une chaîne par un entier, ce qui revient à la conca-
téner avec elle-même un certain nombre de fois. L’expression 'la' * 3 vaut 'lalala' ,
l’expression 3 * 'la' a la même valeur.
Les chaînes sont des instance de la classe str (pour string en anglais), on peut le

ét
vérifier avec type('la programmation python') qui vaut str .
Comme tout objet, les chaînes savent faire des choses. Par exemple, une chaîne sait
retourner une chaîne avec les mêmes lettres en capitales grâce à sa méthode upper() . L’ex-
pression 'la programmation'.upper() retourne la nouvelle chaîne : 'LA PROGRAMMATION' . La
section 14.3 donne les principales méthodes de la classe str .
La fonction len(x) retourne la longueur d’une chaîne x , par exemple len('la prog')
vaut 7 . Notez que tous les caractères sont comptés, y compris l’espace.
m
Les caractères d’une chaîne sont numérotés de 0 à sa longueur moins 1. Pour obtenir
o
la chaîne composée du caractère à la position i dans la chaîne x , on écrit x[i] .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
on

'la prog'[0] vaut 'l'

'la prog'[2] vaut ' '
'la prog'[6] vaut 'g'
'la prog'[7] est une erreur : string index out of range
Éc

Attention à ne pas confondre la chaîne ' ' de longueur 1 qui contient le caractère
espace, avec la chaîne vide '' de longueur 0 qui ne contient aucun caractère. La chaîne
vide peut également s’écrire str() .
Pour terminer, cette rapide présentation des chaînes de caractères, on montre comment
extraire une sous-chaîne d’une chaîne. Pour obtenir la sous-chaîne de x qui va de la
position i à la position j exclue, on écrit x[i:j] .
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
'la prog'[1:5] vaut 'a pr'
'la prog'[5:1] vaut ''
'la prog'[1:12] vaut 'a prog'

Nous reviendrons, dans le chapitre suivant, plus en détail sur cette notation entre
crochets, qu’on appelle tranche (slice en anglais), qu’on peut utiliser avec tous les objets
qui sont des séquences et qui peut avoir d’autres formes.
 3.6. LES CHAÎNES DE CARACTÈRES FORMATÉES 27

3.6 Les chaînes de caractères formatées

Il s’agit d’une chaîne de caractères immédiatement précédée d’un f, comme f'la prog' .
C’est bien une chaîne de caractères, on peut le vérifier avec type(f'la prog') qui retourne
str . Sa valeur est simplement 'la prog' .
L’intérêt de préfixer la chaîne avec un f, pour en faire une chaîne formatée, est qu’on
peut y placer, entre accolades, des expressions qui seront remplacées par leur valeur au
moment de l’évaluation de la chaîne.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
'la prog{1+1}' vaut 'la prog{1+1}'

ri
mais f'la prog{1+1}' vaut 'la prog2'
pour mettre une accolade dans une chaîne formatée, il suffit de la doubler :
f'{{la}} prog{1+1}' vaut '{la} prog2'

ét
L’expression entre accolades est quelconque. Elle peut contenir des variables, des appels
de fonctions ou méthodes. . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1
2
3
x = 'py'
y = 'thon'
z = f'la prog {x+y}'
o m
après ce code, z vaut 'la prog python'

Pour une présentation plus complète des chaînes et des chaînes formatées, voir la
on

section 14.3.
Éc
L3
28 CHAPITRE 3. A. Tessier

e
ri
ét
o m
on
Éc
L3
Chapitre 4

e
Listes, tuples, tranches

ri
Il existe des objets qui « contiennent » d’autres objets. On les appelle des conteneurs.
C’est le cas par exemple d’une liste d’objets, il s’agit d’un objet : la liste, dont les éléments

ét
sont des objets : le premier objet de la liste, puis le deuxième, et ainsi de suite jusqu’au
dernier.
En fait, vous connaissez déjà une type qui se comporte comme un type conteneur.
Il s’agit des chaînes de caractères. En effet, une chaîne de caractères est une suite de
caractères. La chaîne se comporte comme un conteneur de chaînes de un caractère. m
On a vu, par exemple, la fonction len('la prog') qui donne la longueur de la chaîne
'la prog' , ou, d’un autre point de vue, le nombre de chaînes de un caractère que contient
cette chaîne. D’ailleurs on peut accéder aux chaînes d’un caractère contenues dans la
chaîne 'la prog' , par exemple 'la prog'[3] est la chaîne d’un caractère 'p' .
o
Les objets itérables sont tous des objets conteneurs, mais tous les objets conteneurs
ne sont pas itérables. Dit autrement, il n’y a pas forcément de mécanisme pour énumérer
on

un a un tous les objets contenus dans un objet conteneur.

4.1 Les listes

Les listes sont des objets modifiables et itérables. Les éléments d’une liste sont des
Éc

objets quelconques, ils peuvent d’ailleurs eux-mêmes être des listes. On peut construire
une liste en donnant simplement entre crochets ses éléments séparés par des virgules. C’est
ce qu’on appelle la définition en extension d’une liste.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[3, 'L2 éco', 125.12] est une liste de trois éléments
L3

son premier élément est l’entier 3 , le second est la chaîne de caractères 'L2 éco' et le
dernier est le réel 125.12
le lecteur curieux a déjà tapé dans la console :
type([3, 'L2 éco', 125.12]) qui vaut list

On peut accéder à un élément d’une liste par son indice. Comme les caractères d’une
chaîne sont numérotés à partir de 0, les éléments d’une liste sont numérotés à partir de
0. Le nombre d’objets de la liste x s’obtient avec len(x) .

29
 30 CHAPITRE 4. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[3, 'L2 éco', 125.12][1] vaut 'L2 éco'
[3, 'L2 éco', 125.12][7] est une erreur : list index out of range
len([3, 'L2 éco', 125.12]) retourne 3

On peut facilement remplacer un élément d’une liste. Pour remplacer l’objet à la

position i dans la liste x par la valeur de l’expression e , on écrit x[i] = e .

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ri
1 x = [1, 2, 3]
2 x[1] = 4 # remplace l'élément d'indice 1 de la liste x par l'objet 4

Après ce code, la liste x est [1, 4, 3] .

ét
Dans le code de l’exemple précédent, nous avons introduit un commentaire. Un com-
mentaire commence par # et va jusqu’à la fin de la ligne. Le commentaire est
ingnoré à l’exécution, c’est comme s’il n’était pas là.
Une liste peut ne contenir aucun élément. C’est la liste vide qui se note [] , ou de
manière équivalente list() .
m
Comme pour les chaînes de caractères, les opérateurs + et * sont définis sur les listes.
Si x et y sont des listes, alors x + y est une nouvelle liste qui contient tous les éléments
de x suivis de tous les éléments de y . On peut multiplier une liste par un entier pour
o
obtenir un nouvelle liste qui est la conténation de la liste avec elle-même le nombre de
fois indiqué.
on

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[1, 2] + [3, 4] est la liste [1, 2, 3, 4]
[1, 2] * 3 est la liste [1, 2, 1, 2, 1, 2]
3 * [1, 2] est la liste [1, 2, 1, 2, 1, 2]
Éc

Une liste est un objet. Comme tout objet elle sait faire des choses grâce à ses méthodes.
Par exemple, on peut lui demander d’ajouter un objet derrière tous ses autres élé-
ments. Pour ajouter la valeur de l’expression e à la fin de liste x , on écrit x.append(e) .
Attention, la liste x est modifiée et contient un élément supplémentaire.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L3

1 x = [12.5, 2]
2 x.append('python')

après ce code, la liste x est [12.5, 2, 'python']

Il ne faut pas confondre + et append() . + est un opérateur entre deux listes et

construit une nouvelle liste. Après le code x.append(e) , la liste x est modifiée, l’objet e
a été ajouté à la fin.
 4.1. LES LISTES 31

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
supposons que x soit la liste [1, 2]
x + [3] est une nouvelle liste [1, 2, 3]
mais x est inchangée, c’est toujours la liste [1, 2]
après le code x.append(3) , la liste x est modifiée, c’est maintenant [1, 2, 3]
reprenons l’hypothèse que x est la liste [1, 2]
l’expression x + 3 est une erreur : can only concatenate list (not "int") to list
l’expression x.append([3]) n’est pas une erreur

e
cela ajoute l’objet [3] à la fin de x , qui devient la liste [1, 2, [3]]

Voyons tout de suite une conséquence importe du fait qu’une liste soit un objet mo-

ri
difiable.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ét
1 x = [1, 2]
2 y = x # y et x référencent le même objet en mémoire : la liste [1, 2]
3 x.append(3) # l'objet 3 est ajouté à la fin de la liste référencée par x

après ce code, la liste x est [1, 2, 3] tout comme la liste y puisque x et y référencent
toutes les deux cette liste en mémoire

On peut citer aussi la méthode x.count(e) qui permet à la liste x de nous retourner
m
le nombre de fois qu’elle contient la valeur de l’expression e .
o
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[1, 4, 1, 2, 2, 1, 4].count(1) retourne 3
on

[1, 4, 1, 2, 2, 1, 4].count(3) retourne 0

La section 14.4 donne les principales méthodes des listes.

On a déjà vu la fonction len(x) qui donne le nombre d’éléments de la liste x . On
peut citer quelques autres fonctions sur les listes :
— la fonction min(x) , qui donne le plus petit élément de la liste x , bien sûr, tous
Éc

les éléments de la liste doivent être comparable entre eux (on ne compare pas des
torchons et des serviettes) ;
— la fonction max(x) , qui donne le plus grand élément de la liste x ;
— la fonction sum(x) , qui donne la somme des éléments de la liste x (si c’est une
liste de nombres).
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
min([10, 12, 8.5, 17, 4, 16]) retourne 4
min([10, '12', 8.5, 17, 4, 16]) est une erreur : ’<’ not supported between instances
of ’str’ and ’int’
max(['parc', 'jardin', 'square', 'esplanade']) retourne 'square'
sum([10, 12, 8.5, 17, 4, 16]) retourne 67.5

On voit, dans l’exemple précédent, que les chaînes de caractères sont comparables
entre elles. C’est l’ordre lexicographique qui est utilisé, celui du dictionnaire : 'ab' est
32 CHAPITRE 4. A. Tessier

plus petite que 'abc' et 'abc' est plus petite que 'ba' . Mais attention, le dictionnaire
ne différencie pas les capitales des minuscules. Ici, l’ordre entre deux caractères est donné
par l’odre dans le codage unicode. Dans le codage unicode, toutes les capitales sont avant
les minuscules. On a donc 'B' plus petite que 'a' .
Nous avons présenté la définition en extension d’une liste. Il existe une autre manière,
plus compliquée mais très puissante, de définir une liste : la définition en compréhension
à l’aide d’expressions génératrices. Nous aborderons ce point plus tard, car il nécessite
quelques connaissances supplémentaires.

e
4.2 Les tuples

ri
Il s’agit des n-uplet : les couples, les triplets, les quadruplets. . . On conserve le mot
anglais tuple plutôt que n-uplet, car c’est le nom du type en : tuple . Les tuples
ressemblent beaucoup aux listes, mais ils ne sont pas modifiables. Par contre, comme les
listes, les tuples sont itérables.

ét
Les éléments d’un tuple sont des objets quelconques. On peut construire une tuple
en donnant simplement ses éléments suivis chacun d’une virgule, par exemple le tri-
plet 3, 'L2 éco', 125.12, . La dernière virgule peut être omise, sauf s’il n’y a qu’un
élément. Le tuple précédent peut donc s’écrire plus naturellement 3, 'L2 éco', 125.12 .
C’est d’ailleurs la même chose pour les listes, on peut écrire [1, 2, 3] ou [1, 2, 3,] .
En revanche, cette dernière virgule est obligatoire pour un tuple à un seul élément. En
effet, 3 est l’entier 3 alors que 3, est le tuple avec comme seul élément 3 .
m
Pour plus de clarté et pour lever certaines ambiguïtés, on mettra le plus souvent le
o
tuple entre parenthèses : (3, 'L2 éco', 125.12) .
Le tuple vide se note () , ou de manière équivalente tuple() .
On peut accéder à l’élément d’indice i du tuple x par x[i] . Le nombre d’éléments
on

du tuple est len(x) .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(3, 'L2 éco', 125.12)[1] vaut 'L2 éco'
len((3, 'L2 éco', 125.12)) retourne 3
Éc

Contrairement aux listes, les tuples ne sont pas modifiables. Par exemple, si x est
le tuple (1, 2, 3) , alors x[1] = 4 provoquera une erreur : ’tuple’ object does not
support item assignment.
De même, les tuples ne disposent pas de méthodes qui leur permettent de se modifier,
comme la méthode x.append(e) de la liste x par exemple.
On retrouve les opérateurs + et * pour les tuples.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L3

(1, 2) + (3, 4) est le nouveau tuple (1, 2, 3, 4)

(1, 2) * 3 ou 3 * (1, 2) est le tuple (1, 2, 1, 2, 1, 2)

On retrouve aussi les fonctions min(x) , max(x) , sum(x) pour un tuple x .

4.3 Les types séquentiels et les tranches

Les types séquentiels sont les listes, les tuples, les chaines de caractères et les intervalles
(ces derniers seront présentés plus tard).
4.3. LES TYPES SÉQUENTIELS ET LES TRANCHES 33

Les opérateurs in et not in peuvent être utiliser sur ces types 1 . Si x est un objet
de l’un de ces types et y un objet quelconque :

opération résultat
y in x est True si au moins un élément de x est égal à y , sinon c’est False
y not in x est la négation de y in x
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
'square' in ['parc', 'jardin', 'square', 'esplanade'] vaut True

e
'SQUARE' in ('parc', 'jardin', 'square', 'esplanade') vaut False
'u' in 'square' vaut True

ri
Notez que in permet aussi de savoir si une chaîne est une sous-chaîne d’une autre, ce
qui ne fonctionne pas pour les listes ou les tuples.

ét
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
'qua' in 'square' vaut True
'qa' in 'square' vaut False
['parc', 'jardin'] in ['parc', 'jardin', 'square', 'esplanade'] vaut False
en effet, la liste ['parc', 'jardin'] n’est pas égale à un des 4 éléments de la liste
['parc', 'jardin', 'square', 'esplanade']
m
Il y a également deux méthodes communes aux types séquences :
o
— x.count(e) retourne le nombre d’occurences de la valeur de l’expression e dans
la séquence x ;
— x.index(e) retourne l’indice de la première occurence de la valeur de e dans x ,
on

ou provoque une erreur si e n’a pas d’occurrence dans x .

Dans le cas des chaînes, l’expression e n’est pas limitée à un caractère.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(3, 3, 2, 2, 1, 2).count(2) retourne 3
(3, 3, 2, 2, 1, 2).index(2) retourne 2
Éc

'afaefafaefeaffe'.count('fa') retourne 3
'afaefafaefeaffe'.index('fa') retourne 1
que retourne 'afaefafaefeaffe'.count('') ?

Nous savons déjà accéder à l’élément d’indice i d’une séquence x avec x[i] . Mais on
peut aussi utiliser des indices négatifs ! Si i est négatif et compris entre -1 et -len(x)
alors x[i] est la même chose que x[len(x) + i] .
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
len(['a', 'b', 'c']) vaut 3
['a', 'b', 'c'][2] vaut 'c'
['a', 'b', 'c'][-1] est le dernier élément 'c' (c’est ['a', 'b', 'c'][3 - 1] )
['a', 'b', 'c'][-3] est le premier élément 'a' (c’est ['a', 'b', 'c'][3 - 3] )
['a', 'b', 'c'][-4] est une erreur : list index out of range

1. Les opérateurs in et not in sont utilisables avec tout objet itérable et généralement avec les
objets conteneurs. On peut les utiliser avec les dictionnaires et les ensembles que nous verrons plus tard.
34 CHAPITRE 4. A. Tessier

Nous présentons maintenant le concept de tranche (slice en anglais). En toute généra-

lité, une tranche de x s’écrit x[i:j:k] . Cela représente la tranche d’éléments de x qui
va de l’élément d’indice i à l’élément d’indice j exclu, en prenant un élément sur k .
L’entier k s’appelle le pas. On peut utiliser des indices négatifs pour i et j . Si l’indice
j correspond à une position inférieure ou égale à celle de l’indice i et que le pas k est
positif, alors la tranche est vide. En revanche, on peut avoir un pas négatif, ce qui revient
à prendre les élements en partant de la fin.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

e
[11, 12, 13, 14, 15, 16, 17, 18][1:6:2] représente la tranche de 12 à 16 un élément
sur deux, c’est-à-dire [12, 14, 16]

ri
[11, 12, 13, 14, 15, 16, 17, 18][1:-2:2] est la même tranche
[11, 12, 13, 14, 15, 16, 17, 18][6:1:2] est une tranche vide
[11, 12, 13, 14, 15, 16, 17, 18][5:2:-1] nous donne la tranche [16, 15, 14]
les curieux ont déjà testé un pas de 0 . . .

ét
Les valeurs i , j , k sont optionnelles. En l’absence de valeur précisée, la première
vaut 0 , la deuxième vaut len(x) et la dernière vaut 1 .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
m
(11, 12, 13, 14, 15, 16, 17, 18)[1:6:2] donne (12, 14, 16)
(11, 12, 13, 14, 15, 16, 17, 18)[:6:2] donne (11, 13, 15)
(11, 12, 13, 14, 15, 16, 17, 18)[1::2] donne (12, 14, 16, 18)
(11, 12, 13, 14, 15, 16, 17, 18)[1:6:] donne (12, 13, 14, 15, 16)
o
(11, 12, 13, 14, 15, 16, 17, 18)[:6:] donne (11, 12, 13, 14, 15, 16)
(11, 12, 13, 14, 15, 16, 17, 18)[::] donne (11, 12, 13, 14, 15, 16, 17, 18)
on

et (11, 12, 13, 14, 15, 16, 17, 18)[::-1] ?

À noter que le second : est optionnel si le pas est de 1.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(11, 12, 13, 14, 15, 16, 17, 18)[1:6:1]
Éc

(11, 12, 13, 14, 15, 16, 17, 18)[1:6:]

(11, 12, 13, 14, 15, 16, 17, 18)[1:6]
sont équivalents

Attention, il faut distinguer la tranche d’un élément x[i:i + 1] de l’élement lui même
x[i] .
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[11, 12, 13][1:2] est la tranche à un élément [12]
[11, 12, 13][1] est l’entier 12

Pour finir, dans le cas où la séquence est d’un type modifiable, on peut utiliser la
tranche en partie gauche de l’affectation.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 4.4. AFFECTATION DE TUPLES OU LISTES 35

1 x = [11, 12, 13, 14, 15, 16, 17, 18]

2 x[1:6] = [20, 21]

après le code, x est la liste [11, 20, 21, 17, 18] , la tranche qui contient les éléments
12 , 13 , 14 , 15 , 16 a été supprimée de la liste et remplacée par la tranche d’éléments
20 , 21
et si on avait écrit x[1:6] = [] ?

e
Il existe aussi un objet slice(i, j, k) pour désigner une tranche, qu’on pourra ap-
pliquer à un séquence, mais nous ne l’utiliserons pas ici.

ri
4.4 Affectation de tuples ou listes
On peut mettre à gauche d’une affectation un tuple (ou une liste) de variables et à

ét
droite n’importe quel itérable qui a autant d’éléments que la séquence de gauche. Chaque
élément de l’itérable de droite sera affecté à la variable correspondant à gauche. On parle
de déballage (unpacking en anglais).

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
m
1 x, y = 1, 2

ici on ne met généralement pas les parenthèses autour du tuple, ni la virgule finale
o
l’itérable de droite peut être d’un type différent, si le nombre d’éléments correspond aux
nombres de variables à gauche
on

1 [x, y] = (1, 2)
2 u, v, w = 'abc'

x vaut 1 , y vaut 2 , u vaut 'a' , v vaut 'b' et w vaut 'c'

par contre, [x, y] = (1, 2, 3) est une erreur : too many values to unpack (expected
2)
Éc

On peut également utiliser les opérateurs unaires de déballage * et ** , mais cela

dépasse largement le cadre de cet enseignement.
L3
36 CHAPITRE 4. A. Tessier

e
ri
ét
o m
on
Éc
L3
 Chapitre 5

e
Instructions composées, conditionnelles,

ri
boucles

ét
Pour l’instant, les deux choses que nous savons faire, c’est
— évaluer des expressions construites avec des objets, des opérateurs, des appels de
fonctions ou de méthodes d’objets, nous le faisons généralement dans la fenêtre
console de ;
— affecter des valeurs d’expressions à des variables, nous le faisons généralement dans
m
la fenêtre édition de .
Heureusement, on peut faire bien d’autres choses avec , comme exécuter certaines
instructions seulement si une expression est vraie, c’est l’instruction conditionnelle, ou
encore, répéter certaines instructions tant qu’une expression est vraie, c’est la boucle.
o
Le langage est un langage de programmation impératif 1 (orienté objet), c’est-
à-dire qu’on décrit la suite exacte, dans l’ordre, des instructions à exécuter. L’odre des
on

instructions est important : faire A avant B n’est généralement pas la même chose que
faire B avant A.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

x = 1 # x vaut 1
Éc

1
2 x = x + 2 # x vaut 3
3 x = 2 * x # x vaut 6

n’est pas la même chose que

1 x = 1 # x vaut 1
2 x = 2 * x # x vaut 2
x = x + 2 # x vaut 4
L3

Généralement on ne met qu’une instruction par ligne en . Cependant, il est

possible de mettre plusieurs instructions simples sur une même ligne en les séparant par
des ; .

1. Dans les langages de programmation déclaratif, contrairement aux langages de programmation

impératif, on décrit le problème à résoudre plutôt que la séquence d’instructions pour le résoudre.

37
 38 CHAPITRE 5. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = 1 ; x = x + 2 ; x = 2 * x

est équivalent au premier code de l’exemple précédent

Mais, qu’est-ce qu’une instruction simple ? Les instructions simples sont celles qui
ne sont pas des instructions composées ! Une instruction simple, comme une affectation
ou une évalutation d’expression, est une instruction qui ne peut pas contenir elle-même

e
d’instructions. Par opposition, une instruction composée est une instruction qui contien-
dra d’autres instructions. Par exemple l’instruction conditionnelle est une instruction

ri
composée.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ét
1 if note_python < 10:
2 resultat = 'ajourné·e'
3 else:
4 resultat = 'reçu·e'

si la variable note_python est inférieure à 10 alors la valeur 'ajourné·e' sera affectéem

à la variable resultat , sinon ( note_python est supérieure ou égale à 10) c’est la valeur
'reçu·e' qui sera affectée à la variable resultat

Dans cet exemple on trouve une instruction conditionnelle qui va de la ligne 1 à la

o
ligne 4. Elle est composée de deux clauses
— une clause if lignes 1 et 2 qui contient une instruction dans son corps ligne 2 ;
on

— une clause elif lignes 3 et 4 qui contient également une instruction dans son corps
ligne 4.
Cette instruction conditionnelle est donc constituée de deux clauses qui contiennent cha-
cune une instruction dans leur corps. On remarque que l’instruction dans le corps de la
clause (ligne 2) est décalée vers la droite par rapport à l’en-tête de la clause (ligne 1). On
parle d’indentation.
Éc

5.1 L’indentation
L’indentation d’un code consiste à augmenter ou diminuer l’espacement en début de
ligne :
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 a = 1 # cette ligne n'est pas indentée, elle commence tout à gauche

2 b = 2 # cette ligne est indentée, elle commence par 4 caractères espaces
3 c = 3 # cette ligne a la même indentation que la précédente
4 d = 4 # cette ligne est plus indentée que la précédente
5 e = 5 # cette ligne a la même identation que les lignes 2 et 3

L’identation a générallement pour objectif de rendre le code plus lisible pour le pro-
grammeur. Un peu comme quand vous mettez en forme un document avec un traitement
 5.2. FORME D’UNE INSTRUCTION COMPOSÉE 39

de texte pour le rendre plus lisible. Dans la grande majorité des langages modernes de pro-
grammation, l’indentation est libre, même s’il existe des conventions entre programmeurs
pour faciliter la lecture d’un code qu’on n’a pas écrit soi-même.
Mais en , l’indentation n’est pas libre ! Elle joue un rôle supplémentaire : elle
participe à la sémantique du code, c’est-à-dire qu’elle donne du sens au code.
Le code de l’exemple précédent provoquera une erreur : unexpected indent, car il n’est
pas correctement indenté. L’indentation en sert à regrouper des instructions qui
appartiennent à un même bloc d’instructions. Dans ce cas, les instructions ont exactement
la même indentation, comme on le voit ci-dessous avec une instruction conditionnelle

e
contituée de deux clauses if (lignes 1 à 3) et else (lignes 4 à 5), suivie d’une affectation
(ligne 6). La première clause if contient deux instructions (lignes 2 et 3) et la seconde

ri
clause else contient une seule instruction (ligne 5).

1 if a < 1: # en-tête de la première clause

2 b = 2 # 1ère instruction du corps de la première clause
c = 3 # 2ème instruction du corps de la première clause

ét
3
4 else: # en-tête de la deuxième clause
5 d = 4 # unique instruction du corps de la deuxième clause
6 e = 5 # instruction qui suit l'instruction conditionnelle

Dans quel cas utilise-t-on l’indentation ? On l’utilise pour identifier les blocs d’ins-
tructions d’une instruction composée. Les instructions du corps d’une clause ont la même
m
indentation qui est supérieure à l’indentation de l’en-tête de la clause. Généralement on
décale de quatre espaces. Toutes les en-têtes d’une même instruction composée ont la
même indentation.
o
5.2 Forme d’une instruction composée
on

La forme générale d’une instruction composée est toujours la même. Une instruction
composée est consitutée d’une ou plusieurs clauses, chaque clause commence par un en-tête
et est suivi par le corps de la clause constitué d’une ou plusieurs instructions. L’en-tête
débute par un mot clé et se termine par : . La forme d’une clause est
mot_clé · · · : en-tête
Éc

instruction_1 clause
.
. corps
.
instruction_n

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L3

1 if a < 1: # en-tête de la clause if

2 b = 2 # 1ère instruction du corps de la clause
3 c = 3 # 2ème instruction du corps de la clause

la structure de la clause qui utilise le mot clé if ci-dessus est

if a < 1: en-tête
clause
b = 2
corps
c = 3
 40 CHAPITRE 5. A. Tessier

Les instructions 1 à n sont les instructions contenues dans le corps de la clause. Ces
instructions peuvent être des instructions simples ou elles-mêmes des instructions com-
posées. Si le corps de la clause ne contient que des instructions simples, et uniquement si
cela améliore la lisibilité du code, on peut écrire la clause sur une seule ligne en utilisant
le ; oiyr séparer les instructions simples :
mot_clé · · · : instruction_1 ; · · · ; instruction_n

e
Le corps de la clause doit obligatoirement contenir au moins une instruction. Il peut
arriver, exceptionnellement, qu’on souhaite avoir un corps vide. Dans ces cas, on utilise
l’instruction pass . Il s’agit d’une instruction simple qui ne fait tout simplement rien !

ri
5.3 La conditionnelle

ét
L’instruction conditionnelle permet d’exécuter un bloc d’instructions en fonction de
la valeur d’une expression.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
je connais le prix hors taxe et le taux de tva d’un produit, je veux appliquer une remise
de 10 % sur le prix HT s’il est supérieur ou égal à 100 et enfin calculer le prix TTC

1 prix_ht = 212.5 # le prix HT

m
2 tva = 0.055 # le taux de tva
o
3 remise = 0.1 # le taux de la remise
4 if 100 <= prix_ht: # on teste si le prix_ht est supérieur ou égal à 100
5 prix_ht *= 1 - remise # on applique la remise seulement si 100 <= prix_ht
prix_ttc = round(prix_ht * (1 + tva), 2) # cette instruction est toujouts exécutée
on

L’instruction conditionnelle est une instruction composée. Elle contient au moins une
clause obligatoire dont l’en-tête commence par le mot réservé if suivi d’une expression
puis de : . Comme nous l’avons déjà vu, les instructions du corps sont dans un bloc
d’instructions dans les lignes suivantes avec une indentations supérieure 2 . Les instructions
Éc

du corps ne seront exécutée que si l’expression de l’en-tête est équivalente à True .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
supposons une variable n qui a une valeur entière
si sa valeur est impaire, on veut la multiplier par 3 puis lui ajouter 1

1 if n % 2 == 1: # si n est impaire (le reste de la division par 2 est 1)

n *= 3 # multiplier n par 3
L3

3 n += 1 # ajouter 1 à n

ou de manière équivalente, car toutes les instructions du corps sont des instructions
simples

1 if n % 2 == 1: n *= 3 ; n += 1

cette forme est peu utilisée sauf si elle améliore la lisibilité du code
2. Les instruction du corps peuvent être sur la même ligne derrière le : et séparées par des ; s’il
s’agit seulement d’instructions simples.
 5.3. LA CONDITIONNELLE 41

En toute généralité, l’instruction conditionnelle contient une clause if obligatoire,

suivie d’un nombre quelconque de clauses elif , puis une éventuelle clause else pour
finir. Un seul corps de clause est exécuté.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
la variable j contient un entier qui indique le jour de la semaine
1 pour lundi, 2 pour mardi. . . jusqu’à 7 pour dimanche
on souhaite mette le jour correspondant en toutes lettres dans une variable jour

e
1 if j == 1:
2 jour = 'lundi'
elif j == 2:

ri
3
4 jour = 'mardi'
5 elif j ==3:
6 jour = 'mercredi'
7 elif j ==4:
jour = 'jeudi'

ét
8

9 elif j ==5:
10 jour = 'vendredi'
11 elif j ==6:
12 jour = 'samedi'
13 elif j ==7:
jour = 'dimanche'
14
m
Les expressions des en-têtes sont évaluées une par une dans l’ordre des clauses jusqu’à
o
en trouver une équivalente à True . Quand c’est le cas, le corps de la clause est exécutée et
les clauses suivantes sont ingorées. Il y a donc au plus un corps de clause qui est exécuté.
Si les expressions des en-têtes des clauses if et elif sont toutes équivalente à False ,
on

c’est le corps de la clause else , si elle est présente, qui est exécuté.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 if j == 1:
2 jour = 'lundi'
Éc

3 elif j == 2:
4 jour = 'mardi'
5 elif j == 3:
6 jour = 'mercredi'
7 elif j == 4:
8 jour = 'jeudi'
9 elif j == 5:
10 jour = 'vendredi'
elif j == 6:
L3

11
12 jour = 'samedi'
13 elif j == 7:
14 jour = 'dimanche'
15 else:
16 jour = 'erreur : ce numéro de jour n\'existe pas'

Dans cet exemple, comme il n’y a qu’une instruction simple dans chaque clause, on
peut écrire les clauses sur une ligne, ce qui améliore ici la lisibilité du code.
 42 CHAPITRE 5. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 if j == 1: jour = 'lundi'
2 elif j == 2: jour = 'mardi'
3 elif j == 3: jour = 'mercredi'
4 elif j == 4: jour = 'jeudi'
5 elif j == 5: jour = 'vendredi'
6 elif j == 6: jour = 'samedi'
7 elif j == 7: jour = 'dimanche'
else: jour = 'erreur : ce numéro de jour n\'existe pas'

e
8

Il peut y avoir aussi seulement les clauses if et else sans clauses elif .

ri
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
supposons une variable n qui a une valeur entière
si sa valeur est impaire, on veut la multiplier par 3 puis lui ajouter 1

ét
sinon (donc elle est paire), on veut la diviser par 2

1 if n % 2 == 1: # si n est impaire
2 n *= 3 # multiplier n par 3
n += 1 # ajouter 1 à n
3
4
5
else:
n /= 2
# sinon (n est paire)
# diviser n par 2
o m
Bien sûr, les instructions du corps d’une clause sont quelconques. Elles peuvent être
des instructions simples ou elles-mêmes des instructions composées.
on

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
la variable note contient la note de l’étudiant·e
on a le code suivant qui donne son résultat dans la variable resultat

1 if 10 <= note:
2 resultat = 'reçu·e'
Éc

3 else:
4 resultat = 'ajourné·e'

on souhaite enrichir ce code pour ajouter la mention éventuelle

1 if 10 <= note
2 resultat = 'reçu·e'
if 16 <= note:
L3

4 resultat += ' mention très bien'

5 elif 14 <= note:
6 resultat += ' mention bien'
7 elif 12 <= note:
8 resultat += ' mention assez bien'
9 else:
10 resultat = 'ajourné·e'

On voit comment l’indentation permet de savoir à quel bloc appartient une instruction.
Le deuxième code de l’exemple précédent contient une seule instruction, il s’agit d’une
 5.4. LA BOUCLE « TANT QUE » 43

conditionnelle avec une clause if (ligne 1 à 8) et une clause else (ligne 9 à 10). Le corps
de la clause if contient deux instructions : un affectation (ligne 2), puis une conditionnelle
(ligne 3 à 8) qui a trois clauses : un if (ligne 3 à 4) et deux elif (lignes 5 à 6 et 7 à 8).
Il existe une autre forme de conditionnelle formée d’une clause match contenant une
ou plusieurs clauses case . En toute généralité, cette instruction est plus complexe qu’il
n’y paraît, car elle nécessite de comprendre le filtrage de motif. Pour cette raison, nous ne
la détaillons pas ici, mais en donnons un exemple simple à comprendre, où une expression
( j ) va être comparée à différentes valeurs ( 1 , 2 , 3 . . . ).

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

match j:

ri
1

2 case 1:
3 jour = 'lundi'
4 case 2:
5 jour = 'mardi'

ét
6 case 3:
7 jour = 'mercredi'
8 case 4:
9 jour = 'jeudi'
10 case 5:
11 jour = 'vendredi'
case 6:
12

13
14
jour
case 7:
= 'samedi'
m
15 jour = 'dimanche'
case _:
o
16
17 jour = 'erreur : ce numéro n\'existe pas'
on

5.4 La boucle « tant que »

Il existe deux formes de boucles en ,
— la boucle while qui permet de répéter un bloc d’instructions tant que une expres-
sion est équivalente à True ;
Éc

— la boucle for qui permet d’itérer un bloc d’instructions pour chaque élément d’un
itérable.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 i = 1
2 x = []
L3

3 while i <= 3: # tant que i <= 3

4 x.append(i) # ajouter i à la liste x
5 i += 1 # augmenter i de 1

La boucle while commence par une clause while obligatoire, suivie éventuellement
d’une clause else . Son fonctionnement consiste à évaluer l’expression de l’en-tête de la
clause while , puis
— si celle-ci est équivalente à True , on dit qu’on entre dans la boucle, c’est-à-dire
qu’on exécute le corps de la clause while , puis on revient au début de la clause
while pour réévaluer l’expression et recommencer ;
 44 CHAPITRE 5. A. Tessier

— si celle-ci est équivalente à False , on dit qu’on sort de la boucle, et on exécute

le corps de la clause else , si elle est présente, puis on passe aux instructions qui
suivent la boucle.
Quand on entre dans la boucle, toutes les instructions du corps sont exécutées, même
si l’expression de l’en-tête while devient fausse pendant l’exécution. C’est seulement à
l’issue de l’exécution du corps de la boucle qu’on revient sur l’en-tête while pour réévaluer
l’expression.
Pour comprendre le fonctionnement, on peut faire une trace de l’exécution. La trace
consiste à donner, sous forme d’un tableau, l’évolution de la valeur des variables au cours

e
de l’exécution.

ri
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 i = 1
2 x = []
3 while i <= 3:

ét
4 x.append(i)
5 i += 1
6 else:
7 x.append('FIN')

Voici la trace de l’exemple :

ligne i x commentaire
m
1 1 intialisation de i
o
2 1 [] intialisation de x
3 1 [] i <= 3 vaut True on entre dans la boucle
4 1 [1] on ajoute i à x
on

5 2 [1] on incrémente i (on ajoute 1 à i )

3 2 [1] on revient évaluer i <= 3 qui vaut True
4 2 [1, 2] on ajoute i à x
5 3 [1, 2] on incrémente i
3 3 [1, 2] on revient évaluer i <= 3 qui vaut True
3 [1, 2, 3] on ajoute i à x
Éc

5 4 [1, 2, 3] on incrémente i
3 4 [1, 2, 3] on revient évaluer i <= 3 qui vaut False
6 4 [1, 2, 3] on passe à la clause else
7 4 [1, 2, 3, 'FIN'] on ajoute 'FIN' à x
Après exécution de ce code, on a i qui vaut 4 et x qui vaut [1, 2, 3, 'FIN'] .
Que pensez-vous de l’exemple suivant ?
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 i = 1
2 x = []
3 while 0 <= i:
4 x.append(i)
5 i += 1
6 else:
7 x.append('FIN')
 5.4. LA BOUCLE « TANT QUE » 45

C’est ce qu’on appelle une boucle infinie. La clause else et les instructions qui suivent
la boucle ne seront jamais exécutées. La forme la plus générale de boucle infinie utilise l’en-
tête while True: . Mais cela ne signifie pas toujours que la boucle est réellement infinie,
car une instruction spéciale permet de sortir d’une boucle.
L’instruction simple break dans le corps d’une boucle permet de sortir immédiatement
de la boucle, sans exécuter la clause else si elle est présente.
L’instruction simple continue dans le corps d’une boucle permet de revenir direc-
tement à l’en-tête de la boucle sans exécuter les instructions restantes du corps de la
boucle.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ri
1 i = 0
2 x = []
3 while True:
4 i += 1

ét
5 if i == 2:
6 continue
7 elif 3 < i:
8 x.append('ARRÊT')
9 break
10 x.append(i) m
11 else:
12 x.append('FIN')
13 x.append('!')
o
Examinez la trace de cet exemple figure 5.1.
Décider si une boucle n’est pas infinie, c’est-à-dire si elle termine, s’appelle le problème
on

de l’arrêt. Prouver rigoureusement qu’une boucle termine est souvent très compliqué,
même pour des boucles très simples.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
supposons une variable n entière et positive
tant que n est différente de 1, on répète :
Éc

si elle est impaire on la multiplie par 3 et ajoute 1, sinon on la divise par 2

1 while n != 1:
2 if n % 2 == 1:
3 n = 3 * n + 1
4 else:
5 n /= 2
L3

Est-ce que cette boucle termine toujours quelque soit la valeur de n entière et positive
au départ ? Par exemple, essayez avec n qui vaut 7 au départ.
Actuellement, personne ne sait répondre à cette question, mais on pense qu’elle termine
toujours. Cette conjecture, connue sous les noms de conjecture de Collatz, ou conjecture
de Syracuse ou conjecture 3n + 1, date de 1937 ! La boucle est très simple et pourtant,
depuis presqu’un siècle, on essaie de prouver qu’elle s’arrête toujours. En toute généralité,
le problème de l’arrêt pour une boucle est indécidable. On ne sait même pas si l’arrêt de
la boucle précédente est décidable. Si ce point vous passionne, courrez vous inscrire dans
un cursus informatique !
46 CHAPITRE 5. A. Tessier

e
ligne i x commentaire
1 0 intialisation de i
0 [] intialisation de x

ri
2

3 0 [] l’expression est True , on entre dans la boucle

4 1 [] on incrémente i
5 1 [] i == 2 vaut False on passe à la clause elif
1 [] 3 < i vaut False on passe à l’instruction qui suit

ét
7

10 1 [1] on ajoute i à x puis on revient au début de la

clause while
3 1 [1] l’expression est True , on entre dans la boucle
4 2 [1] on incrémente i
2 [1] i == 2 vaut True on exécute le bloc de la clause
5

6 2 [1]
if
m
on revient au début de la clause while
3 2 [1] l’expression est True , on entre dans la boucle
o
4 3 [1] on incrémente i
5 3 [1] i == 2 vaut False on passe à la clause elif
7 3 [1] 3 < i vaut False on passe à l’instruction qui suit
on

10 3 [1, 3] on ajoute i à x puis on revient au début de la

clause while
3 3 [1, 3] l’expression est True , on entre dans la boucle
4 4 [1, 3] on incrémente i
5 4 [1, 3] i == 2 vaut False on passe à la clause elif
4 [1, 3] 3 < i vaut True on exécute le bloc de la clause
Éc

elif
8 4 [1, 3, 'ARRÊT'] on ajoute 'ARRÊT' à x
9 4 [1, 3, 'ARRÊT'] on interromp la boucle et passe à l’instruction qui
suit
13 4 [1, 3, 'ARRÊT', '!'] on ajoute '!' à x
L3

Figure 5.1 – trace de la boucle while

 5.5. LES INTERVALLES 47

5.5 Les intervalles

Avant de présenter la deuxième boucle, la boucle for , nous introduisons un nouveau
type : le type intervalle (range en anglais). C’est un type non modifiable, mais itérable.
range(x, y, z) retourne l’intervalle qui va de l’entier x à l’entier y exclus, par pas
de z . On peut l’utiliser avec deux arguments range(x, y) , dans ce cas le pas est de 1,
ou avec un argument range(y) dans ce cas l’intervale va de 0 à y exclu par pas de 1. On
peut accéder aux éléments par leur indice et utiliser les tranches sur les intervalles.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
range(3, 6) correspond à l’intervalle d’entiers [[3; 6[[, qui contient 3, 4 et 5

ri
range(5, 2, -1) correspond à l’intervalle d’entiers qui va de 5 à 3 en décroissant
range(3, 15, 2) correspond à l’intervalle des entiers impairs de 3 à 13
range(0, 100, 2)[0] vaut 0
range(0, 100, 2)[1] vaut 2

ét
range(0, 100, 2)[-1] vaut 98
range(0, 100, 2)[1:20:3] vaut range(2, 40, 6) (les valeurs 2, 8, 14, 20, 26, 32, 38)
range(0, 100, 2)[1:20:3][-1] vaut 38

L’avantage des intervalles par rapport aux listes ou aux tuples qui contiendraient les
mêmes valeurs est qu’ils occupent une place constante et réduite en mémoire. La liste
m
d’entiers stocke chacun de ses éléments en mémoire, l’intervalle ne stocke en mémoire que
trois entiers : la valeur de départ, la valeur d’arrêt et le pas.
o
5.6 La boucle « pour »
on

La boucle for de fait appel aux notions d’itérateur ou générateur que nous
verrons plus en détail plus tard. Disons pour simplifier, qu’elle permet de répéter un bloc
d’instructions pour chaque élément d’un itérable.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Éc

1 x = []
2 for i in range(1, 4):
3 x.append(i)

La boucle for commence par une clause for obligatoire, suivie éventuellement d’une
clause else . L’en-tête de la clause for est de la forme for i in e: , où la valeur de
L3

l’expression e doit être un objet itérable 3 (intervalle, tuple, liste, chaîne de caractères. . . ).
i peut être tout ce qu’on met en partie gauche d’une affectation, le plus souvent il s’agira
d’une variable (voir section 3.3). Lors du premier passage sur l’en-tête de la clause for , un
itérateur est créé pour l’objet e . Le premier élément fourni par l’itérateur est affecté à i ,
puis le corps de la clause for est exécuté. Ensuite on revient au début de la clause for ,
l’élément suivant produit par l’itérateur est affecté à i , puis le corps de la clause for
est exécuté à nouveau. Et ainsi de suite jusqu’au dernier élément produit par l’itérateur.
Enfin, la clause else est exécutée, si elle est présente.
3. Nous verons plus tard que l’expression e peut être directement un itérateur ou un générateur.
 48 CHAPITRE 5. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = []
2 for i in range(1, 4):
3 x.append(i)
4 else:
5 x.append('FIN')

Rappelons que range(1, 4) correspond à l’intervalle d’entiers de 1 à 3. L’itérateur

e
produit par range(1, 4) , va fournir successivement, à chaque tour de boucle, les entiers
1 , puis 2 , puis 3 . Pour comprendre le fonctionnement, on fait la trace.

ri
ligne i x commentaire
1 [] intialisation de x
1 [] création de l’itérateur et intialisation de i à 1

ét
2

3 1 [1] on ajoute i à x
2 2 [1] la valeur suivante de l’itérateur, 2 , est affectée à i
3 2 [1, 2] on ajoute i à x
2 3 [1, 2] la valeur suivante, 3 , est affectée à i
3 3 [1, 2, 3] on ajoute i à x m
2 3 [1, 2, 3] l’itérateur ne fournit plus de valeur, on passe au else
4 3 [1, 2, 3] on exécute le corps de la clause else
5 3 [1, 2, 3, 'FIN'] on ajoute 'FIN' à x
o
Après ce code, i vaut 3 et x vaut [1, 2, 3, 'FIN'] .
Notez que dans une boucle qui commence par for i in e: , si l’itérable e est vide,
on

aucune valeur n’est affectée à i et il n’y a aucun « tour » de boucle. Pour cette raison,
il est fortement déconseillé d’utiliser la valeur de i après la boucle.
On peut utiliser n’importe quel itérable (ou itérateur, ou générateur) dans l’en-tête de
la boucle.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Éc

1 x = []
2 for i in 'python':
3 x.append(i)

après ce code, x vaut ['p', 'y', 't', 'h', 'o', 'n']

L3

Les instructions break et continue peuvent être utilisée avec la boucle for et se
comportent comme avec la boucle while .
 Chapitre 6

e
Fonctions

ri
Nous avons déjà utilisé quelques fonctions prédéfinies en pyhton, comme type , round ,
len . . . Nous allons maintenant voir l’instruction composée qui permet de définir nos

ét
propres fonctions.

6.1 L’instruction def

La définition de fonction ne comporte qu’une seule clause qui utilise le mot clé defm
dans son en-tête. L’en-tête précise le nom de la fonction et la liste de ses paramètres.
L’instruction particulière return dans le corps de la fonction donne la valeur « de retour »
de la foncion. Cette clause crée un nouvel objet function qui est référencé par le nom de
o
la fonction.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
on

1 def fois2(x):
2 y = x + x
3 return y

définit une nouvelle fonction nommée fois2 qui a un seul paramètre nommé x et qui
contient deux instructions, la première qui affecte la valeur x + x à une nouvelle variable
Éc

y , la deuxième qui donne la valeur de retour de la fonction derrière le mot clé return
l’instruction return met toujours fin à la fonction
type(fois2) vaut function

On peut appeler une fonction dans une expression. Il faut alors indiquer les valeurs
qu’on veut donner aux paramètres. Ces valeurs, données aux paramètres, sont appelés les
L3

arguments.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
si l’on reprend l’exemple précédent, évaluons l’expression fois2(10)
la valeur 10 est passée en argument pour le paramètre x
le corps de la fonction est exécutée avec x qui vaut 10
une nouvelle variable y est initialisée avec la valeur x + x , c’est-à-dire 20
puis l’évaluation est terminée par l’instruction return qui retourne la valeur de y
l’expression fois2(10) vaut 20

49
 50 CHAPITRE 6. A. Tessier

Détaillons l’évaluation d’une expression plus compliquée.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
évaluons l’expression fois2(1 + fois2(2 + 4)) + 3
il s’agit d’une somme, il faut évaluer les deux termes de la somme, celui de gauche
fois2(1 + fois2(2 + 4)) , puis celui de droite 3
— le terme de gauche est un appel de fonction, la fonction fois2
il faut évaluer son argument 1 + fois2(2 + 4)
il s’agit d’une somme, il faut évaluer les deux termes de la somme, celui de gauche

e
1 et celui de droite fois2(2 + 4) :
— le premier terme 1 vaut 1
— le second terme fois2(2 + 4) est un appel de la fonction fois2 avec en

ri
argument 2 + 4
il faut évaluer l’argument 2 + 4 qui vaut 6
la fonction fois2 est appelée avec 6 en argument on exécute le corps de la
fonction fois2 avec la valeur 6 pour son paramètre x

ét
une nouvelle variable y est initialisée avec la valeur x + x , c’est-à-dire 12
puis l’évaluation est terminée par l’instruction return qui retourne 12
l’appel de fonction est terminée, les deux variables locales à la fonction, le
paramètre x et la variable y , « disapraissent »
le second terme de la somme, fois2(2 + 4) , vaut 12
1 + 12 vaut 13
la fonction fois2 est appelée avec 13 en argument
m
on exécute le corps de la fonction fois2 avec la valeur 13 pour son paramètre
o
x
une nouvelle variable y est initialisée avec la valeur x + x , c’est-à-dire 26
puis l’évaluation est terminée par l’instruction return qui retourne 26
on

les deux variables locales à la fonction, le paramètre x et la variable y , « disa-

praissent »
le premier terme de la somme, fois2(1 + fois2(2 + 4)) , vaut 26
— le terme de droite 3 vaut 3
fois2(1 + fois2(2 + 4)) + 3 vaut 26 + 3 , c’est-à-dire 29
Éc

Une fonction peut avoir plusieurs paramètres.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def foisn(x, n):

2 y = n * x
3 return y
L3

la fonction foisn doit être appelée avec deux arguments

foisn(10) provoque une erreur : foisn() missing 1 required positional argument:
’n’
foisn(10, 3) vaut 30

Par défaut, les arguments sont donnés dans le même ordre que les paramètres, mais
on peut aussi les donner dans un ordre quelconque 1 en précisant chaque fois le nom du
paramètre.
1. À moins que soient utilisés les symboles spéciaux / ou * qui indiquent
 6.2. L’OBJET NONE 51

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
dans foisn(10, 3) , 10 est la valeur du premier paramètre x et 3 est la valeur du
deuxième paramètre y
mais on aurait pu écrire foisn(x=10, n=3) qui est équivalent
quand on nomme les arguments, on peut changer l’ordre
par exemple, foisn(n=3, x=10) est toujours la même expression

On peut donner une valeur par défaut pour un ou plusieurs paramètres d’une fonction.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

def foisn_v2(x, n = 1):

ri
1
2 y = n * x
3 return y

foisn_v2(10, 3) , foisn_v2(x=10, n=3) , foisn_v2(n=3, x=10) , sont toujours équivalentes

ét
et valent 30
en revanche, on peut ne pas préciser de valeur pour le deuxième paramètre n
dans ce cas, c’est la valeur par défaut qui est utilisée
foisn_v2(10) est équivalente à foisn_v2(10, 1) et vaut 10

Une fonction ne retourne qu’un seul objet. Mais rien n’interdit que cet objet soit un
tuple.
m
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
une fonction qui retourne la somme et le produit des éléments d’un itérable

1 def somme_produit(x):
somme = 0
on

2
3 produit = 1
4 for i in x:
5 somme += i
6 produit *= i
7 return somme, produit
Éc

somme_produit([1, 2, 3, 4, 5]) retourne le couple (15, 120)

après le code s, p = somme_produit([1, 2, 3, 4, 5]) , s vaut 15 et p vaut 120

Nous avons donnée une version simple de la définition de fonction. Plus tard, nous
verrons des compléments qui concernent les opérateurs de déballage, la généricité, ou
encore les décorateurs.
L3

6.2 L’objet None

Il peut arriver qu’on souhaite écrire une fonction qui ne retourne pas de valeur par-
ticulière. Pour cela, il existe un objet très particulier en qui représente en fait
— avant / des paramètres par position ;
— entre / et * des paramètres par position ou nommés ;
— après * des paramètres nommés.
Il est possible également d’utiliser les opérateurs de déballage * ou ** , qui sont alors obligatoirement
suivis de paramètres nommés.
 52 CHAPITRE 6. A. Tessier

l’absence d’objet ! Il s’agit de l’objet None , on pourrait dire qu’il signifie « rien » ou « pas
de valeur ». Cet objet est bien entendu ni modifiable, ni itérable.
C’est la valeur retournée par une fonction qui ne se termine pas par une instruction
return , ou termine par une instruction return sans valeur précisée.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def double_append(x, a, b):

2 x.append(a)

e
3 x.append(b)
4

5 ma_liste = [1, 2]

ri
6 double_append(ma_liste, 3, 4)

la fonction double_append ajoute les valeurs de a et b à la liste x

elle ne retourne pas de valeur particulière

ét
après le code précédent, ma_liste vaut [1, 2, 3, 4]

6.3 Les espaces de nommage

Un espace de nommage fait correspondre un identificateur (un nom de variable) à un
m
objet (l’objet référencé par la variable). Par exemple, quand on écrit x = 'la prog' , cela
ajoute l’identificateur x à l’espace de nommage courant avec la référence vers l’empla-
cement (l’adresse) où est stocké la chaîne de caractères 'la prog' en mémoire. Chaque
o
objet dispose de son propre espace de nommage. Il y a en plus un espace de nommage
global qui contient les variables du script.
Lors de l’évaluation d’un appel de fonction, l’espace de nommage de la fonction est
on

« empilé » sur la « pile des espaces de nommages ».

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def fois2(x):
y = x + x
Éc

2
3 return y

l’espace de nommage de la fonction fois2 contient deux variables : x qui est un para-
mètre et sera initialisée avec l’argument donné à l’appel de la fonction et y
évaluons l’expression fois2(10) :
la fonction fois2 est appelée avec la valeur 10 en argument
l’espace de nommage de fois2 est empilé sur la pile des espaces de nommage
L3

la variable x est ajoutée à l’espace de nommage de fois2 et, comme c’est le paramètre,
elle est initialisée avec la valeur de l’argument 10
la variable y est ajoutée à l’espace de nommage à la ligne 2, avec la valeur 20
l’instruction return y est exécutée, elle donne la valeur de fois2(10) qui est 20 et
termine l’appel de fonction
l’espace de nommage de fois2 est dépilé (il « disparaît »), la valeur de retour est 20

Détaillons, de manière schématique, un exemple où le script appelle une fonction f

qui appelle elle-même la fonction fois2 .
 6.3. LES ESPACES DE NOMMAGE 53

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def fois2(x):
2 y = x + x
3 return y
4
5 def f(x):
6 y = fois2(x + 3) + 2
7 return y * 3

e
8

9 x = 4
10 y = f(x + 1)

ri
les lignes 1 à 3 ajoutent la fonction fois2 à l’espace espace de nommage global
de nommage global fois2 −→ code de la fonction
espace de nommage global
les lignes 5 à 7 ajoutent la fonction f à l’espace de
fois2 −→ code de la fonction

ét
nommage global
f −→ code de la fonction
la ligne 9 ajoute la variable x à l’espace de nom- espace de nommage global
mage global avec la valeur 4 fois2 −→ code de la fonction
la ligne 10 doit commencer par évaluer l’expression f −→ code de la fonction
f(x + 1) , l’argument vaut 5 x −→ 4

l’espace de nommage de f est empilé avec le para-

m espace de nommage de f
x −→ 5
mètre x qui vaut 5
espace de nommage global
la ligne 6 commence par évaluer l’expression
o
fois2 −→ code de la fonction
fois2(x + 3) , c’est-à-dire appelle la fonction
f −→ code de la fonction
fois2 avec l’argument 8
x −→ 4
on

espace de nommage de fois2

x −→ 8
l’espace de nommage de fois2 est empilé avec x
y −→ 16
qui vaut 8
espace de nommage de f
la ligne 2 ajoute la variable y avec la valeur 16 à
x −→ 5
l’espace de nommage de fois2
Éc

espace de nommage global

la ligne 3 termine la fonction avec 16 en valeur de
fois2 −→ code de la fonction
retour f −→ code de la fonction
x −→ 4
espace de nommage de f
l’espace de nommage de fois2 est dépilé x −→ 5
la ligne 6 ajoute la variable y avec la valeur de y −→ 18
L3

16 + 2 à l’espace de nommage de f espace de nommage global

la ligne 7 termine l’appel de f avec 18 * 3 , c’est- fois2 −→ code de la fonction
à-dire 54 , comme valeur de retour f −→ code de la fonction
x −→ 4
espace de nommage global
l’espace de nommage de f est dépilé fois2 −→ code de la fonction
la ligne 10 ajoute la variable y avec la valeur 54 f −→ code de la fonction
à l’espace de nommage global x −→ 4
y −→ 54
 54 CHAPITRE 6. A. Tessier

La fonction peut cependant utiliser la valeur d’une variable globale de l’espace de

nommage global, si elle n’a pas de variable locale avec le même nom.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def f(x):
2 return x + y
3
4 y = 5
z = f(10)

e
5

la première instruction, lignes 1 et 2, ajoute la fonc- espace de nommage global

tion f à l’espace de nommage global f −→ code de la fonction

ri
la ligne 4 ajoute une nouvelle variable y à l’espace
espace de nommage global
de nommage global avec la valeur 5
f −→ code de la fonction
à la ligne 5, il faut évaluer l’expression f(10) , c’est-
y −→ 5
à-dire appeler la fonction f avec l’argument 10

ét
l’espace de nommage de f est « empilé » sur l’es-
pace de nommage global
dans l’espace de nommage de f , le paramètre x espace de nommage de f
vaut 10 m x −→ 10
dans x + y ligne 2, la variable x est dans l’espace espace de nommage global
de nommage de f , elle vaut 10 , la variable y n’est f −→ code de la fonction
pas dans l’espace de nommage de f , elle est dans y −→ 5
l’espace de nommage global et vaut 5
o
la valeur de retour est 15
l’évaluation de f(10) est terminée, l’espace de espace de nommage global
on

nommage de f est dépilé f −→ code de la fonction

la variable z est ajoutée à l’espace de nommage y −→ 5
global avec la valeur 15 −→ 15 z
après exécution du script, il y a deux variables : y qui vaut 5 et z qui vaut 15
il n’y a pas de variable x : NameError: name ’x’ is not defined !
(il y a aussi une troisième variable f qui est l’identificateur de la fonction)
Éc

En revanche, dès qu’une variable apparaît à gauche de = dans la fonction, il s’agit

d’une nouvelle variable locale à la fonction.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def f(x):
y = 20
L3

3 return x + y
4
5 y = 5
6 z = f(10)

les lignes 1 à 3, ajoutent la fonction f à l’espace

de nommage global espace de nommage global
la ligne 5 ajoute la variable y dans l’espace de nom- f −→ code de la fonction
mage global avec la valeur 5 y −→ 5
ligne 6, il faut évaluer f(10)
 6.3. LES ESPACES DE NOMMAGE 55

espace de nommage de f
l’espace de nommage de f est empilé sur l’espace
x −→ 10
de nommage global
espace de nommage global
dans l’espace de nommage de f , le paramètre x
f −→ code de la fonction
vaut 10
y −→ 5

la ligne 2 ajoute la variable y dans l’espace de nom- espace de nommage de f

mage de f avec la valeur 20 x −→ 10
pour évaluer x + y , ligne 3, la variable x est dans y −→ 20

e
l’espace de nommage de f et vaut 10 , la variable espace de nommage global
y est dans l’espace de nommage de f et vaut 20 f −→ code de la fonction

ri
la valeur de retour est 30 y −→ 5

espace de nommage global

l’espace de nommage de f est dépilé
f −→ code de la fonction
la valeur 30 est affectée à la variable z dans
y −→ 5

ét
l’espace de nommage global
z −→ 30

On peut utiliser la valeur d’une variable globale dans une fonction (s’il n’y a pas de
variable locale qui a le même nom). Il peut arriver exceptionnellement qu’une fonction
ait besoin, non pas d’utiliser, mais de modifier la valeur d’une variable global. Comment
m
faire, puisque, si la variable apparaît à gauche du signe = , il s’agit d’une nouvelle variable
locale à la fonction ? Dans ce cas, on indique avant l’affectation que la variable est globale
avec l’instruction global .
o
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

def f(x):
on

1
2 global y
3 y = 20
4 return x + y
5
6 y = 5
7 z = f(10)
Éc

les lignes 1 à 4, ajoutent la fonction f à l’espace espace de nommage global

de nommage global, la ligne 6 ajoute la variable y f −→ code de la fonction
avec la valeur 5 , ligne 7, il faut évaluer f(10) y −→ 5

espace de nommage de f
x −→ 10
l’espace de nommage de f est « empilé » avec le
espace de nommage global
paramètre x qui vaut 10
L3

f −→ code de la fonction
y −→ 5
la ligne 2 déclare que la variable y sera celle de
espace de nommage de f
l’espace de nommage global, la ligne 3 lui affecte la
x −→ 10
valeur 20
global y
ligne 4, la variable x est dans l’espace de nommage
espace de nommage global
de f et vaut 10 , la variable y est celle de l’espace
f −→ code de la fonction
de nommage de global et vaut 20 , la valeur de re-
y −→ 20
tour est 30
 56 CHAPITRE 6. A. Tessier

l’évaluation de f(10) est terminée, l’espace de espace de nommage global

nommage de f est dépilé f −→ code de la fonction
la valeur 30 est affectée à la variable z dans y −→ 5
l’espace de nommage global z −→ 30

Dans le cas d’objets imbriqués (fonctions ou classes), il est possible d’utiliser l’instruc-
tion nonlocal pour indiquer que la variable à utiliser n’est pas celle de l’objet mais celle
de l’objet dans lequel il est imbriqué.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ri
1 def f(x):
2 def g(x): # la fonction g est locale à la fonction f
3 nonlocal y
4 return x + y
5 y = 15

ét
6 return g(x)
7
8 y = 5
9 z = f(10)

les lignes 1 à 6 ajoutent la fonction f à l’espace

espace de nommage global
de nommage global, la ligne 8 ajoute la variable y
avec la valeur 5 , la ligne 9 commence par appeler
la fonction f avec 10 en argument
m f −→ code de la fonction
y −→ 5

espace de nommage de f
o
l’espace de nommage de f est empilé avec x qui
x −→ 10
vaut 10
g −→ code de la fonction
les lignes 2 à 4 ajoutent la fonction g à l’espace de
on

y −→ 15
nommage de f
espace de nommage global
la ligne 10 ajoute la variable y avec la valeur 15
f −→ code de la fonction
ligne 11, il faut évaluer g(10)
y −→ 5
espace de nommage de g
l’espace de nommage de g est empilé avec x qui x −→ 10
Éc

vaut 10 nonlocal y
la ligne 3 déclare que la variable y est nonlocal :
espace de nommage de f
il s’agit de la variable y de l’espace de nommage
x −→ 10
de f , celui où se situe la fonction g
g −→ code de la fonction
la ligne 4 termine la fonction g avec en valeur de
y −→ 15
retour la somme de qui est x dans l’espace de nom-
espace de nommage global
mage de g et de y dans l’espace de nommage de
L3

f −→ code de la fonction
f , c’est-à-dire 25
y −→ 5
espace de nommage de f
x −→ 10
l’espace de nommage de g est dépilé g −→ code de la fonction
la ligne 6 termine la fonction f avec la valeur de y −→ 15
retour 25 espace de nommage global
f −→ code de la fonction
y −→ 5
 6.4. LES DOCSTRINGS 57

espace de nommage global

l’espace de nommage de f est dépilé f −→ code de la fonction
la ligne 9 ajoute la variable z avec la valeur 25 y −→ 5
z −→ 25

En résumé, quand une variable x est utilisée dans une fonction

— si elle est déclarée global x , c’est la variable de l’espace de nommage global qui
est utilisée ;

e
— dans le cas d’une fonction imbriquée, si elle est décalarée nonlocal x , c’est la
variable de l’espace de nommage dans lequel la fonction est imbriquée qui est

ri
utilisée ;
— si elle n’est déclarée ni global , ni nonlocal :
— si elle est à gauche d’un = , il s’agit d’une variable de l’espace de nommage local
de la fonction ;
— sinon, si elle est présente dans l’espace de nommage locale, c’est cette variable

ét
qui est utilisée, sinon c’est la variable de l’espace de nommage global qui est
utilisée.

6.4 Les docstrings m

La documentation est importante en programmation.
Bien sûr, on peut mettre des commentaires dans le code ou rédiger une documentation
avec un traitement de texte, mais offre un mécanisme permettant de générer auto-
o
matiquement la documentation pour certains éléments du code. Il s’agit des docstrings.
Une « docstring » est une chaîne de caractères placée comme première instruction du
on

bloc d’instruction d’une function. Par convention, on écrit la chaîne en utilisant les triple
guillements doubles, même s’il n’y a qu’une seule ligne.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def somme_produit(x):
"""calcule la somme et le produit des éléments de l'itérable x
Éc

2
3
4 retourne un tuple dont le premier élément est la somme et le deuxième le produit
5 si x est vide le couple (0, 1) est retourné
6 """
7 somme = 0 # variable pour la somme des éléments de x
8 produit = 1 # variable pour le produit des éléments de x
9 for i in x:
somme += i
L3

10
11 produit *= i
12 return somme, produit

après ce code, l’exécution de help(somme_produit) dans la console produit l’affichage

Help on function somme_produit in module __main__:

somme_produit(x)
calcule la somme et le produit des éléments de l'itérable x
58 CHAPITRE 6. A. Tessier

retourne un tuple dont le premier élément est la somme et le

deuxième le produit
si x est vide le couple (0, 1) est retourné

Dans l’exemple précédent on voit la différence entre la documentation de la fontion et

les commentaires dans le corps de la fonction :
— la docstring sert à documenter l’utilisation de la fonction, ce qui doit être connu
par celui qui veut utiliser la fonction ;

e
— le commentaire sert à documenter le code de la fonction, ce qui doit être connu par
celui qui veut comprendre comment la fonction est codée.

ri
ét
o m
on
Éc
L3
 Chapitre 7

e
Dictionnaires, ensembles

ri
7.1 Les dictionnaires

ét
Les dictionnaires sont des objets modifiables et itérables. On les appelles aussi des
tableaux associatifs.
On peut construire un dictionnaire en donnant des paires clé: valeur , séparées par
des virgules, entre accolades. Ainsi, à chaque clé correspond une valeur. Si la même clé
apparaît plusieurs fois, la valeur associée est celle qui correspond à la dernière apparition
m
de la clé. Il s’agit de la définition en extension. Comme pour les liste, on peut également
utiliser la définition en compréhension, que nous aborderons plus tard.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
on veut un dictionnaire qui fait correspondre à chaque nom de mois, le nom du premier
jour du mois pour l’année 2025
on

1 d = {'janvier': 'mercredi', 'février': 'samedi', 'mars': 'samedi', 'avril': 'mardi',

,→ 'mai': 'jeudi', 'juin': 'dimanche', 'juillet': 'mardi', 'août':
,→ 'vendredi', 'septembre': 'lundi', 'octobre': 'mercredi', 'novembre':
,→ 'samedi', 'décembre': 'lundi'}

les clés sont les noms des mois, les valeurs sont les noms des jours
Éc

type(d) vaut dict

On peut aussi construire un dictionnaire avec la fonction dict . Le dictionnaire vide

peut s’écrire dict() ou {} . Si x est un itérable qui contient des couples (clé, valeur) ,
dict(x) est le dictionnaire qui associe la clé de chaque couple à la valeur.
Pour des raisons liées à leur implémentation, les clés des dictionnaires ne peuvent pas
être d’un type modifiable. Par exemple, il est possible d’utiliser un tuple comme clé, mais
L3

pas une liste.

Comme les listes ou les tuples sont indicées par les entiers (à partir de 0), les diction-
naires sont indicées par les clés. Les clés sont donc toutes différentes.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
d['janvier'] vaut 'mercredi'
d['lundi'] est une erreur : KeyError: ’lundi’, car les clés sont les noms des mois

En revanche, la notion de tranche n’existe pas pour les dictionnaires.

59
 60 CHAPITRE 7. A. Tessier

Un dictionnaire est itérable. L’itération d’un dictionnaire produit successivement ses

clés dans l’ordre dans lequel elles ont été ajoutées au dictionnaire. Une itération du dic-
tionnaire d de l’exemple précédent va produire 'janvier' , puis 'février' . . . jusqu’à
'décembre' . On peut le voir en utilisant la fonction list qui construit la liste des élé-
ments d’un itérable.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
list(d) vaut

e
['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août',
,→ 'septembre', 'octobre', 'novembre', 'décembre']

ri
Si x est un dictionnaire
— len(x) retourne le nombre de clés de x ;
— x[y] retourne l’élément de clé y du dictionnaire x ou une erreur KeyError: y si
la clé y n’est pas dans x ;

ét
— x[y] = z remplace la valeur pour la clé y , si elle existe, par z , sinon ajoute la
clé y avec la valeur z ;
— y in x retourne True si la clé y est dans x , False sinon ;
— y not in x retourne True si la clé y n’est pas dans x , False sinon.
La section 14.7 présente plus de méthodes pour les dictionnaires.
Un dictionnaire ressemble, en un certain sens, à une fonction (un peu comme, en
mathématiques, une famille indicée ressemble à une application).
m
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
1 d = {1:'a', 'a':2}
on

2
3 def f(x):
4 match x:
5 case 1: return 'a'
6 case 'a': return 2
7 case _: raise KeyError(x)

d[1] vaut 'a'

Éc

f(1) vaut 'a'

d['a'] vaut 2
f('a') vaut 2
d[2] est une erreur : KeyError: 2
f(2) est une erreur : KeyError: 2
L3

Dans l’exemple précédent, on voit comment on peu déclencher une erreur, on dit lever
une exception, avec l’instruction raise . Nous reviendrons sur cette instruction plus tard,
quand nous étudierons le traitement des exceptions.

7.2 Les ensembles

Un ensemble correspond à la notion classique d’ensemble fini d’objets. Les
éléments d’un ensemble sont uniques et non ordonnés. Cependant, les ensembles sont des
objets itérables, mais l’ordre dans lequel les éléments sont itérés est quelconque.
 7.2. LES ENSEMBLES 61

Il existe deux sortes d’ensemble en :

— set qui sont des ensembles modifiables ;
— frozenset qui sont des ensembles non modifiables.
On peut construire un ensemble modifiable non vide en donnant ses éléments entre
accolades, séparés par des virugles. Il s’agit de la définition en extension. Comme pour les
liste, on pourra également utiliser la définition en compréhension.
La fonction len , les opérateurs in et not in , ainsi que les opérateurs de comparaison
== , != , < , <= , > , >= sont disponibles pour les ensembles. La relation d’odre utilisée
pour les ensembles est l’inclusion,

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ri
1 e = {1, 'a', 'ab', 5 - 4, 1.0, "a"}

e est l’ensemble {'ab', 1, 'a'}

type(e) vaut set

ét
len(e) vaut 3
'ab' in e vaut True
5 in e vaut False
{'a', 1} <= e vaut True m
On peut utiliser les fonctions set et frozenset pour construire des ensembles. L’en-
semble modifiable vide est set() , l’ensemble non modifiable vide est frozenset() . At-
o
tention, ensembles et dictionnaires utilisent tous les deux les accolades, {} n’est pas
l’ensemble vide, c’est le dictionnaire vide ! Si x est un itérable, set(x) est l’ensemble
modifiable construit à partir des éléments de x et frozenset(x) le même ensemble mais
on

non modifiable.
Deux ensembles, modifiables ou non, qui possèdent les mêmes éléments (au sens de == )
sont égaux (au sens de == ) : set([1.0, 4, 2]) == frozenset([4, 2, 4, 1]) vaut True .
Pour les ensembles modifiables uniquement, ceux du type set , la méthode add ajoute
un élément, la méthode remove retire un élément ou provoque une erreur s’il n’est pas
dans l’ensemble, discard retire un élement s’il est dans l’ensemble et ne fait rien sinon.
Éc

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 e = {1, 'a', 'ab', 5 - 4, 1.0, "a"} # e est l'ensemble {'ab', 1, 'a'}

2 e.add(2) # e est l'ensemble {'ab', 1, 2, 'a'}
3 e.remove('a') # e est l'ensemble {'ab', 1, 2}
4 e.discard(5) # e ne change pas
L3

5 e.remove(5) # provoque l'erreur 'KeyError: 5'

La section 14.8 présente plus de méthodes pour les ensembles.

62 CHAPITRE 7. A. Tessier

e
ri
ét
o m
on
Éc
L3
 Chapitre 8

e
Entrées-sorties

ri
En programmation, les entrées-sorties sont toujours un aspects un peu compliqué.
En effet, les langages de programmation essaient de fournir des mécanismes unifiés pour

ét
communiquer avec des périphériques de natures très différentes tout en offrant aussi des
mécanismes plus spécifiques pour simplifier certains types de communication. Le program-
meur débutant peut rapidement se trouver noyé dans cette jungle.
Dans cette partie nous verrons comment manipuler les entrées standards (clavier et
écran dans la console python) ainsi que les fichiers textes. Nous verrons plus tard comment
réaliser des sorties en mode graphique avec la fenêtre « Plots » de , ou traiter des
fichiers binaires contenant, par exemple, des feuilles de calcul.
o m
8.1 La fonction print
La fonction print permet la sortie en mode texte de valeurs d’expressions. Par défaut,
on

les expressions sont séparées par des espaces et la dernière est suivie d’un passage à la
ligne.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 print('C\'est simple !')

Éc

affiche le texte
C'est simple !

1 cours = 'programmation python'

2 formation = 'L2 économie'
3 print('Bienvenue dans le cours', cours, 'de', formation)
L3

4 print('C\'est simple !')

affiche le texte
Bienvenue dans le cours programmation python de L2 économie
C'est simple !

1 print()

provoque un simple passage à la ligne

63
 64 CHAPITRE 8. A. Tessier

La fonction print possède quatre paramètres nommés qui ont des valeurs par défaut :
— sep=' ' qui spécifie la chaîne de caractères utilisées pour séparer les expressions ;
— end='\n' qui spécifie la chaîne à ajouter derrière la dernière expression ;
— file=None qui spécifie le fichier à utiliser pour la sortie, on utilisera la valeur par
défaut None qui correspond à la sortie standard (la console );
— flush=False qui contrôle si l’écriture est immédiate ou « bufferisée », on utilisera
la valeur par défaut False .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

e
1 cours = 'programmation python'

ri
2 formation = 'L2 économie'
3 print('Bienvenue dans le cours', cours, 'de', formation, end='.\n')
4 print('Bienvenue dans le cours ', cours, ' de ', sep='**', end='')
5 print(formation)

ét
affiche le texte

Bienvenue dans le cours programmation python de L2 économie.

Bienvenue dans le cours **programmation python** de L2 économie

Notez que les expressions à afficher sont transformée en chaînes de caractères via la
fonction str .
o m
8.2 La fonction input
La fonction input a deux formes : input() et input(e) . Si une expression e est
on

indiquée, elle est affichée sur la sortie standard, sans être suivie d’un retour à la ligne.
Puis la fonction input lit une ligne sur l’entrée standard, c’est-à-dire que la ligne est
tapée au clavier et validée par la touche <Entrée>, la transforme en chaîne de caractères
(sans le retour à la ligne final qui sert à valider l’entrée), enfin cette chaîne est la valeur
de retour de la fonction.
Éc

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 nom = input('Ton nom : ')

2 cours = 'programmation python'
3 print('Bienvenue', nom, 'dans le cours', cours, end='.\n')

la ligne 1 affiche le texte

L3

Ton nom :

puis s’arrête en attendant qu’on entre un texte, on tape Emma<Entrée> :

Ton nom : Emma

à ce moment, la fonction input('Ton nom : ') retourne 'Emma'

puis l’exécution se poursuit avec la ligne 2, puis la ligne 3 qui affiche

Bienvenue Emma dans le cours programmation python.

 8.3. LES FICHIERS TEXTES 65

8.3 Les fichiers textes

Pour lire ou écrire dans un fichier, nous utilisons l’instruction composée with . Ce
n’est pas une obligation, mais cela facilite la gestion du fichier, en particulier en cas de
problème.
L’en-tête de son unique clause est de la forme with fichier as f: , où, dans notre cas,
fichier sera une expression correspondant à l’ouverture d’un fichier et f l’identicateur
utilisé pour accéder au fichier.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

with open('mon_fichier.txt', 'wt') as f:

ri
1
2 f.write('Ceci est un test.\n')

crée un fichier texte dans le dossier courant qui contient le texte

ét
Ceci est un test.

Comme le suggère l’exemple précédent, la fonction open permet d’ouvrir un fichier.

Elle a de nombreux paramètres, mais nous n’en utiliserons que deux :
— le premier est une chaîne qui indique le chemin vers le fichier à ouvrir, soit un
chemin absolu depuis la racine du disque, soit un chemin relatif depuis le dossier
courant ;
m
— le deuxième est une chaîne qui indique le mode d’ouverture du fichier, elle contient
une combinaison des caractères
o
caractère signification
'r' ouverture en lecture (échoue si le fichier n’existe pas)
'w' ouverture en écriture (écrase le fichier s’il existe déjà)
on

'x' ouverture en écriture (échoue si le fichier existe déjà)

'a' ouverture en ajout (crée le fichier s’il n’existe pas)
'+' ouverture en lecture et écriture
'b' ouverture en mode binaire
't' ouverture en mode texte
Par défaut, le mode d’ouverture est en lecture 'r' et en mode texte 't' . Par consé-
Éc

quent, l’expression open('fichier.txt', 'wt') est équivalente à open('fichier.txt', 'w')

et open('fichier.txt', 'rt') est équivalente à open('fichier.txt') .
Nous utiliserons uniquement les modes
— 'r' pour lire les lignes d’un fichier texte ;
— 'w' pour créer un fichier texte et y écrire des lignes ;
— 'a' pour ajouter des lignes à un fichier texte.
L3

Si l’on souhaite ouvrir plusieurs fichiers en même temps, on peut écrire

1 with fichier1 as f1, fichier2 as f2:

à la place de

1 with fichier1 as f1:

2 with fichier2 as f2:

Pour écrire dans un fichier ouvert en écriture ( 'w' ou 'a' ), il est possible d’utiliser
la fonction print ou la méthode write que nous utiliserons de préférence. La méthode
 66 CHAPITRE 8. A. Tessier

write n’a qu’un seul paramètre qui est une chaîne de type str (elle écrit la chaîne
sans ajouter de retour à la ligne derrière). Cela signifie que pour écrire la valeur d’une
expression e dans le fichier f , on écrit f.write(str(e)) . On peut écrire plus simplement
f.write(e) si e est déjà une chaîne de caractères (voir exemple suivant).

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 cours = 'programmation python'

2 formation = 'L2 économie'

e
3 with open('mon_fichier.txt', 'w') as f:
4 print('Bienvenue dans le cours', cours, 'de', formation, file=f)
5 print('C\'est simple !', file=f)

ri
ce code est équivalent à

1 cours = 'programmation python'

formation = 'L2 économie'

ét
2
3 with open('mon_fichier.txt', 'w') as f:
4 f.write('Bienvenue dans le cours ')
5 f.write(cours)
6 f.write(' de ')
7 f.write(formation)
8 f.write('\nC\'est simple !\n')

ou encore le code
m
cours = 'programmation python'
o
1
2 formation = 'L2 économie'
3 with open('mon_fichier.txt', 'w') as f:
4 f.write('Bienvenue dans le cours ' + cours + ' de ' + formation + '\nC\'est
on

,→ simple !\n')

Pour lire dans un fichier ouvert en lecture ( 'r' ), il n’est pas possible d’utiliser la
fonction input qui ne lit que sur l’entrée standard. Nous utiliserons les méthodes read ,
readline ou readlines .
Éc

Pour un fichier f ouvert en lecture

— f.read() retourne le contenu complet du fichier sous forme d’une unique chaîne
de caractères ;
— f.readline() retourne la ligne courante du fichier sous forme d’une chaîne de
caractères (qui contient le caractère de fin de ligne) ou une chaîne vide si la fin du
fichier est atteinte† ;
— f.readlines() retourne une liste qui contient chaque ligne du fichier sous forme
L3

d’une chaîne de caractères (les chaînes contiennent le caractère de fin de ligne).

†
remarquez que la fin du fichier est indiqué par la chaîne vide '' , alors que la lecture
d’une ligne vide retourne la chaîne '\n' qui contient un caractère.
La dernière ligne d’un fichier texte peut, si elle n’est pas vide bien sûr, ne pas terminer
pas un caractère de fin de ligne.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
le fichier mon_fichier.txt, crée avec l’exemple précédent, contient le texte

Bienvenue dans le cours programmation python de L2 économie

 8.3. LES FICHIERS TEXTES 67

C'est simple !

1 with open('mon_fichier.txt', 'r') as f:

2 le_texte = f.read()

le_texte vaut
"Bienvenue dans le cours programmation python de L2 économie\nC'est simple !\n"

e
1 with open('mon_fichier.txt', 'r') as f:
2 les_lignes = f.readlines()

ri
les_lignes vaut
['Bienvenue dans le cours programmation python de L2 économie\n', "C'est simple !\n"]

ét
1 with open('mon_fichier.txt', 'r') as f:
2 ligne1 = f.readline()
3 ligne2 = f.readline()
4 ligne3 = f.readline()

ligne1 vaut 'Bienvenue dans le cours programmation python de L2 économie\n' m

ligne2 vaut "C'est simple !\n"
ligne3 vaut ''
o
Mais il existe un moyen encore plus simple de lire les lignes une à une d’un fichier
texte : il est itérable. L’iterateur va produire les lignes sous forme de chaînes l’une après
l’autre.
on

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 les_lignes = []
2 with open('mon_fichier.txt', 'r') as f:
3 for ligne in f:
Éc

4 les_lignes.append(ligne)

les_lignes vaut
['Bienvenue dans le cours programmation python de L2 économie\n', "C'est simple !\n"]
L3
68 CHAPITRE 8. A. Tessier

e
ri
ét
o m
on
Éc
L3
 Chapitre 9

e
Les expressions lambdas, génératrices,

ri
compréhensions

ét
9.1 Les expressions lambdas
Les lambdas sont des expressions dont la valeur est une fonction. La forme générale est
lambda param : expr , où param sont les paramètres séparés par des virgules (comme les
paramètres d’une fonction définie par def , mais sans parenthèses autour), et expressionm
est la valeur de la fonction.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
1 f = lambda x, y : 2 * x + y

l’expression lambda x, y : 2 * x + y définit une fonction à deux paramètres x et y

on

dont la valeur de retour est 2 * x + y

le code précédent est équivalent à

1 def f(x, y):

2 return 2 * x + y
Éc

Les lambdas sont appelées des fonctions anonymes, car elles définissent des fonctions
sans leur associer d’identificateur (sauf si on affecte l’expression à un identificateur comme
dans l’exemple précédent), contrairement aux fonctions définies avec une instruction def
qui ont toujours un nom. Notez que le « corps » d’une lambda n’est composé que d’une
seule expression, l’expression qui donne la valeur de retour. Cela limite fortement les
fonctions que l’on peut définir avec une lambda, qui ne sont pas aussi générales que les
L3

fonctions qu’on peut définir avec def .

On utilise une expression lambda quand la fonction est très simple. Généralement on
ne nomme pas une fonction définie par une lambda si elle est utilisée une seule fois.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = (lambda x, y : 2 * x + y)(2,3)

est presque identique à

69
 70 CHAPITRE 9. A. Tessier

1 f = lambda x, y : 2 * x + y
2 x = f(2, 3)

la différence réside dans le fait que le deuxième code définit une fonction f ajoutée dans
l’espace de nommage
en revanche le deuxième code est équivalent à

1 def f(x, y):

return 2 * x + y

e
2
3 x = f(2, 3)

ri
Les lambdas sont souvent utilisées avec les fonctions qui prennent en paramètre une
autre fonction, qu’on appelle fonctions d’ordre supérieur, comme les fonctions map ou
filter par exemple (voir section 18.4).

ét
9.2 Les expressions génératrices
Il existe une expression dont la valeur est un itérateur (ou générateur). Elle s’écrit
(e1 for x in e2 if e3) , où e1 est une expression, x une variable (ou une liste de va- m
riables), e2 est un itérable et e3 une expression booléenne. L’expression va produire une
itération de la manière suivante : pour chaque élément x de l’itérable e2 qui rend vrai
e3 , la valeur e1 est produite.
o
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
l’expression (2 * x for x in [2, 7, -1, -5, 3] if 0 <= x) va produire l’itération 4 , 14 ,
6
on

le code

1 t = []
2 for i in (2 * x for x in [2, 7, -1, -5, 3] if 0 <= x):
3 t.append(i)
Éc

est presque équivalent à (il y a la variable x en plus)

1 t = []
2 for x in [2, 7, -1, -5, 3]:
3 if 0 <= x:
4 i = 2 * x
5 t.append(i)
L3

La dernière partie if e3 est optionnelle, s’il n’y en a pas, toutes les valeurs de l’itérable
e2 sont retenues. L’expression (e1 for x in e2) est équivalente à (e1 for x in e2 if True) .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
l’expression (2 * x for x in [2, 7, -1, -5, 3])
est équivalente à (2 * x for x in [2, 7, -1, -5, 3] if True)
elles produisent toutes les deux l’itération 4 , 14 , -2 , -10 , 6

ci-dessous trois expressions qui ont la même valeur, la somme des carrés pairs de 0 à 10
 9.3. LES DÉFINITIONS EN COMPRÉHENSION 71

0 × 0 + 2 × 2 + 4 × 4 + 6 × 6 + 8 × 8 + 10 × 10

1. sum(i*i for i in range(11) if i % 2 == 0)

2. sum(i*i for i in range(0,11,2))
3. sum(i*i for i in range(11)[::2])

Il est possible d’enchaîner plusieurs parties for ... if dans une expression généra-
trice.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ri
après le code

1 t = []
2 for i in (x+y for x in [2, 7, -1, -5, 3] if 0 <= x for y in [4, -3, -2] if y <= 0):
t.append(i)

ét
3

t vaut [-1, 0, 4, 5, 0, 1]
c’est (presque) équivalent à

1 t = [] m
2 for x in [2, 7, -1, -5, 3]:
3 if 0 <= x:
4 for y in [4, -3, -2]:
5 if y <= 0:
o
6 i = x+y
7 t.append(i)
on

9.3 Les définitions en compréhension

En mathématiques, on peut définir un ensemble en extension en donnant la liste de
ses éléments entre accolades, comme {0, 1, 4, 9, 16, 25}, ou en compréhension en donnant
Éc

une propriété caractéristique de ses éléments, comme {x2 | x ∈ N et x < 6}. En , on

sait définir des listes en extension, comme [0, 1, 4, 9, 16, 25] , mais on peut également
les définir en compréhension, comme [x**2 for x in range(6)] .
Il est donc possible d’utiliser une expression génératrice entre crochets pour définir
une liste en compréhension.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
L3

ci-dessous différentes expressions dont la valeur est la liste des carrés pairs de 0 à 10
[x**2 for x in range(11) if x % 2 == 0] est la liste [0, 4, 16, 36, 64, 100]
[x**2 for x in range(0,11,2)] est la liste [0, 4, 16, 36, 64, 100]
[(2*x)**2 for x in range(6)] est la liste [0, 4, 16, 36, 64, 100]
[0, 4, 16, 36, 64, 100] est la liste [0, 4, 16, 36, 64, 100]

L’expression génératrice peut également être utilisée entre accolades pour définir un
ensemble modifiable ou un dictionnaire.
72 CHAPITRE 9. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[2 * x for x in [1,2,3]] est la liste [2, 4, 6]
{2 * x for x in [1,2,3]} est l’ensemble {2, 4, 6}
{x:2 * x for x in [1,2,3]} est le dictionnaire {1: 2, 2: 4, 3: 6}

Attention, la valeur d’une expression génératrice entre parenthèses est un générateur,

ce n’est pas un tuple ! Mais souvenez-vous que les fonctions tuple , list , set , frozenset ,
dict . . . prennent un itérateur ou un générateur en argument.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(2 * x for x in [1,2,3]) est du type generator , sa valeur est un générateur

ri
en revanche, tuple(2 * x for x in [1,2,3]) est le tuple (2, 4, 6)
list(2 * x for x in [1,2,3]) est la liste [2, 4, 6]
set(2 * x for x in [1,2,3]) est l’ensemble {2, 4, 6}
frozenset(2 * x for x in [1,2,3]) est l’ensemble non modifiable frozenset({2, 4, 6})

ét
dict((x, 2 * x) for x in [1,2,3]) est le dictionnaire {1: 2, 2: 4, 3: 6}
mais {(x,2 * x) for x in [1,2,3]} est l’ensemble de couples {(2, 4), (1, 2), (3, 6)}

Les listes en compréhension offrent un moyen de définir une liste de manière très
concise.
m
Notez que cela ne fonctionne qu’avec une expression génératrice, si l’on place un autre
itérateur ou générateur entre crochets, on obtient une liste qui n’a qu’un seul élément :
l’itérateur ou le générateur.
o
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
la fonction iter(x) produit un itérateur de l’itérable x
on

iter(range(2,7,2)) produit l’itération 2 , puis 4 , puis 6

[iter(range(2,7,2))] est une liste à un seul élément : l’itérateur
mais list(iter(range(2,7,2))) est la liste [2, 4, 6]

Il y a deux applications courrantes des listes en compréhension

— quand on veut créer la liste des éléments d’une itération qui vérifient une condition
Éc

particulière ;
— quand on veut créer la liste des éléments qui sont les résultats d’une opération
appliquée à chaque élément d’une itération.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
[x for x in [2, -1, 3, 4, -5] if x < 0] est la liste des valeurs négatives [-1, -5]
[x + 3 for x in [2, -1, 3, 4, -5]] est la liste [5, 2, 6, 7, -2]
L3

[x + 3 for x in [2, -1, 3, 4, -5] if x < 0] est la liste [2, -2]

la fonction map(f, x) produit un itérateur des éléments de l’itérable x auxquels sont

appliqués la fonction f
map(lambda x: 2 * x, [1, 2, 3]) produit l’itération 2 , puis 4 , puis 6
à la place de list(map(lambda x: 2 * x, [1, 2, 3]))
on peut écrire [2 * x for x in [1, 2, 3]]
qui est plus lisible (dans les deux cas, c’est la liste [2, 4, 6] )
 Chapitre 10

e
Les erreurs et les tests

ri
10.1 Les exceptions

ét
Comme de nombreux langages de programmation, propose un mécanisme de
gestion des erreurs. En programmation, on parle généralement d’exceptions. Par exemple,
l’évaluation de l’expression 7 / 0 lève l’exception ZeroDivisionError: division by zero.
À l’intérieur d’un script, si l’exception n’est pas traitée, cela provoque l’arrêt du script avec
un message d’erreur (l’affichage de l’exception). Quand votre programme se « plante », m
la première chose à faire est de bien lire le message d’erreur qui indique des éléments
importants permettant d’identifier rapidement le problème :
— le nom du fichier et le numéro de ligne où s’est provoquée l’erreur ;
— l’instruction qui a provoqué l’erreur ;
o
— le nom de l’erreur suivie éventuellement des circonstances de l’erreur.
Le gros avantage est que l’on peut déclencher des erreurs, on dit « lever une exception »,
on

avec l’instruction simple raise et les traiter, on dit les « capturer » avec l’instruction
composée try .
On a vu que l’évaluation de l’expression (3, 1, 2).index(4) (voir sections 4.3 et 14.5)
provoque l’erreur : ValueError: tuple.index(x): x not in tuple, car 4 n’est pas un
élément du tuple (3, 1, 2) . Faut-il tester avant si (3, 1, 2).count(4) != 0 ou encore
4 in (3, 1, 2) ? Dans ce cas, il y aura une première recherche de l’élément 4 dans le
Éc

tuple (3, 1, 2) , puis une seconde recherche pour trouver son indice. La solution consiste
à utiliser une instruction try pour laisser l’erreur se produire pendant la recherche dans
la méthode index , puis la traiter. C’est ici plus efficace.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
écrivons la fonction indice(elem, seq) qui donne l’indice de elem dans l’itérable seq
ou None s’il n’est pas dans l’itérable
L3

1 def indice(elem, seq):

2 try:
3 return seq.index(elem)
4 except:
5 return None

le corps de la clause try est exécuté, s’il provoque une erreur le cors de la clause except
est exécuté
indice(3, (3, 1, 2)) retourne 0 et indice(4, (3, 1, 2)) retourne None

73
74 CHAPITRE 10. A. Tessier

10.2 L’instruction try

L’instruction try commence par une clause try obligatoire, suivie d’éventuellement
plusieurs clauses except , puis éventuellement une clause else , puis éventuellement une
clause finally . Il y a obligatoirement au moins une clause except ou la clause finally .
La clause else n’est possible que s’il y a au moins une clause except .
L’en-tête d’une clause try est try: . L’en-tête d’une clause except est except: ou

e
except E: ou except E as e: , où E est une expression qui correspond à un type d’ex-
ception et e est un identificateur (auquel sera affecté l’exception). L’en-tête d’une clause
else est else: . L’en-tête d’une clause finally est finally: .

ri
Le corps de la clause try est exécuté.
— Si l’exécution n’a levé aucune exception, la clause else est exécutée si elle est
présente, puis la clause finally si elle est présente, puis l’instruction try est

ét
terminée.
— Si l’exécution du corps de la clause try a levé une exception
— si des clauses except sont présentes et l’une au moins capture l’exception, le
corps de la première clause except qui capture l’exception† est exécutée, puis
la clause finally si elle est présente, puis l’instruction try est terminée ;m
— sinon, la clause finally est exécutée, puis l’instruction try est terminée.
†
l’exception est capturée dès que l’entête de la clause except correspond à la classe
de l’exception ou une classe ancêtre de l’exception. La section 17.2.8 donne la hiérarchie
o
des exceptions. Par exemple, l’exception ZeroDivisionError a pour mère ArithmeticError
qui a pour mère Exception . La clause except: capture toutes les exceptions. La clause
except E: ou except E as e: capture les exception de type E ou d’une classe fille de E .
on

On utilise la forme except E as e: quand il est utile d’avoir, dans le corps de la clause,
l’exception e qui a été levée, pour par exemple la lever de nouveau.
Notez que :
— La clause finally est toujours exécutée, même si un exception est levée.
— La clause else est exécutée si aucune exception n’est levée (sauf si le corps de la
Éc

clause try s’est terminé par une instruction break , continue ou return alors elle
n’est pas exécutée).
— Dans le cas où une exception est levée dans le corps de la clause try , la première
clause except qui capture l’exception est exécutée et l’exception est traitée.
La section 17.2.8 apporte des précisions dans le cas où le corps de la clause try s’est
terminé par une instruction break , continue ou return (l’instruction try est dans une
L3

boucle ou une définion de fonction ou méthode).

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
imaginons que l’on souhaite écrire une fonction qui fait la moyenne des éléments d’un
itérable, cette fonction a différentes raisons de ne pas fonctionner correctement, par
exemple, si l’itérable contient autre chose que des nombres ou s’il est vide, voire si ce
n’est pas un itérable
 10.2. L’INSTRUCTION TRY 75

1 def moyenne1(seq):
2 somme = 0
3 for n in seq:
4 somme += n
5 return somme / len(seq)
6
7 def moyenne2(seq):
8 somme = seq[0]
9 for n in seq[1:]:

e
10 somme += n
11 return somme / len(seq)

ri
les deux fonctions donne le bon résultat avec un itérable non vide de nombres
en revanche, moyenne1([]) lève l’exception ZeroDivisionError: division by zero
moyenne2([]) lève l’exception IndexError: list index out of range
moyenne1(['a', 1]) lève l’exception TypeError: unsupported operand type(s) for +=:

ét
’int’ and ’str’
moyenne2(['a', 1]) lève l’exception TypeError: can only concatenate str (not "int")
to str

Dans l’exemple précédent, on pourrait décider de retourner la valeur None quand m

l’argument n’est pas un itérable non vide de nombres. Pour cela, il faut identifier les
instructions qui peuvent provoquer une erreur.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
pour la fonction moyenne1 , les instructions qui peuvent lever une exceptions sont
— for n in seq: si seq est de type xxx qui n’est pas itérable : TypeError: ’xxx’
on

object is not iterable

— somme += n si n est de type xxx qui n’est pas un nombre : TypeError: unsupported
operand type(s) for +=: ’int’ and ’xxx’
— return somme / len(seq) si l’itérable seq est vide : ZeroDivisionError: division
by zero
Éc

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def moyenne3(seq):
2 somme = 0
3 try:
4 for n in seq:
5 somme += n
return somme / len(seq)
L3

6
7 except:
8 return None

la fonction donne la moyenne, ou la valeur None en cas de problème

moyenne3([]) , moyenne3(['a', 1]) , moyenne3(5) retournent None

On peut vouloir un traitement différent selon le type d’exception et retourner une

chaîne de caractères qui indique le problème rencontré.
 76 CHAPITRE 10. A. Tessier

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def moyenne4(seq):
2 somme = 0
3 try:
4 for n in seq:
5 somme += n
6 return somme / len(seq)
7 except TypeError:
return "pas itérable ou un éléments n'est pas un nombre"

e
8

9 except ZeroDivisionError:
10 return "il n'y a pas d'éléments"

ri
moyenne4([]) retourne "il n'y a pas d'éléments"
moyenne4(['a', 1]) retourne "paramètre pas itérable ou un éléments n'est pas un nombre"
moyenne4(5) retourne "paramètre pas itérable ou un éléments n'est pas un nombre"

ét
On voit qu’on ne peut pas distinguer les deux erreurs des lignes 4 et 5, car elles sont
instances toutes les deux de TypeError . Si l’on veut une gestion fine des erreurs, il faut
capturer l’exception au plus près de l’instruction qui l’a levée. m
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
1 def moyenne5(seq):
2 somme = 0
3 try:
for n in seq:
on

4
5 try:
6 somme += n
7 except: # c'est la somme qui pose problème (TypeError)
8 return "un éléments n'est pas un nombre"
9 try:
10 return somme / len(seq)
except: # c'est la division qui pose problème (ZeroDivisionError)
Éc

11
12 return "il n'y a pas d'éléments"
13 except: # c'est le for qui pose problème (TypeError)
14 return "paramètre pas itérable"

moyenne5([]) retourne "il n'y a pas d'éléments"

moyenne5(['a', 1]) retourne "un éléments n'est pas un nombre"
moyenne5(5) retourne "paramètre pas itérable"
L3

On pourrait aussi retourner None si la liste est vide ou directement la chaîne de

caractères qui correspond à l’erreur pour les autres erreurs. Dans ce cas, on a besoin de
capturer l’objet exception, puis on pourra utiliser la fonction str pour le transformer en
chaîne.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 10.3. L’INSTRUCTION RAISE 77

1 def moyenne6(seq):
2 somme = 0
3 try:
4 for n in seq:
5 try:
6 somme += n
7 except Exception as e: # e est l'exception qui a été levée
8 return str(e) # elle est du type Exception
9 try: # ou une descendante de Exception

e
10 return somme / len(seq)
11 except:
12 return None

ri
13 except Exception as e:
14 return str(e)

moyenne6([]) retourne None

moyenne6(['a', 1]) retourne "unsupported operand type(s) for +=: 'int' and 'str'"

ét
moyenne6(5) retourne "'int' object is not iterable"

Mais la meilleure manière de faire n’est pas de retourner une chaîne de caractères,
mais de lever une exception avec un message d’erreur approprié qui précise l’exception.

10.3 L’instruction raise

m
L’instruction raise e permet de lever l’exception e . L’objet e doit être une ins-
o
tance d’un type exception. Pour cela on utilise le nom du type comme une fonction (plus
tard, nous verrons qu’il s’agit du constructeur du type) avec en paramètre une chaîne de
caractères qui précise l’erreur.
on

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def moyenne7(seq):
2 somme = 0
3 try:
Éc

4 for n in seq:
5 try:
6 somme += n
7 except:
8 raise ValueError("un éléments n'est pas un nombre")
9 try:
10 return somme / len(seq)
11 except:
raise Exception("il n'y a pas d'éléments")
L3

12
13 except TypeError:
14 raise TypeError("paramètre pas itérable")

moyenne7([]) provoque l’erreur Exception: il n’y a pas d’éléments

moyenne7(['a', 1]) provoque l’erreur ValueError: un éléments n’est pas un nombre
moyenne7(5) provoque l’erreur TypeError: paramètre pas itérable
attention, il est important de préciser TypeError ligne 13, sinon une exception levée par
l’un des deux try lignes 5 à 8 et lignes 9 à 12, qui sont dans le corps de la clause try
lignes 3 à 12 serait capturer par la clause except lignes 13 à 14
 78 CHAPITRE 10. A. Tessier

Plus tard nous verrons comment créer nos propres types d’exceptions, ce qui peut-être
plus judicieux pour faciliter le traitement de l’exception que d’utiliser un type d’exception
déjà existant.

10.4 Les tests avec l’instruction assert

L’instruction assert permet d’insérer des tests pendant la mise au point du code. Les
instructions assert présentent l’avantage de rester dans le code mais elles peuvent être

e
désactivées au lancement du script si on le souhaite (elles se comportent alors comme des
commentaires). La variable __debug__ , indique, si elle est vraie, que les assertions sont
activées, sinon elles sont désactivées.

ri
Il existe deux formes pour cette instruction.
assert e
si l’expression e est équivalente à True , l’instruction assert ne fait rien, sinon,

ét
elle lève une exception AssertionError .
L’instruction est équivalente au code

1 if __debug__:
2 if not e:
3 raise AssertionError

assert e, x
m
si l’expression e est équivalente à True , l’instruction assert ne fait rien, sinon,
o
elle lève une exception AssertionError(x) .
L’instruction est équivalente au code
on

1 if __debug__:
2 if not e:
3 raise AssertionError(x)

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
je suis sûr que ma fonction est toujours appelée avec un itérable qui contient des nombres,
Éc

mais, pendant la phase de mise au point, je veux m’assurer qu’elle n’est pas appelée avec
une liste vide

1 def moyenne8(seq):
2 somme = 0
3 assert len(seq) != 0, "il n'y a pas d'éléments"
4 for n in seq:
L3

5 somme += n
6 return somme / len(seq)

moyenne8([]) provoque l’erreur AssertionError: il n’y a pas d’éléments

Chapitre 11

e
Modules, packages

ri
Un module est un morceau de code sur lequel on peut s’appuyer, un paquet (package
en anglais) est une collection de modules. En pratique, un module est un fichier et

ét
un package est un dossier qui contient des modules ou des packages.
Une bibliothèque, ou librairie, est un terme générique qui signifie « collection de
codes », qui s’applique donc à la fois aux modules et au packages.
Imaginons un module mon_module qui définit une fonction ma_fonction . On peut
— importer le module avec l’instruction import mon_module
cela crée un nouvelle variable mon_module
type(mon_module) vaut module
on peut utiliser la fonction mon_module.ma_fonction() ;
m
— importer le module en le référençant par un identificateur avec l’instruction
o
import mon_module as mm
cela crée un nouvelle variable mm
type(mm) vaut module
on

on peut utiliser la fonction mm.ma_fonction() ;

— importer la fonction avec l’instruction from mon_module import ma_fonction
cela crée un nouvelle variable ma_fonction
type(ma_fonction) vaut function
on peut utiliser la fonction ma_fonction() ;
Éc

— importer tous les objets de mon_module avec l’instruction from mon_module import *
cela crée autant de nouvelles variables pour chaque objet du module
type(ma_fonction) vaut function
on peut utiliser la fonction ma_fonction() ;
— importer la fonction en la référençant par un identificateur avec l’instruction
from mon_module import ma_fonction as mf
cela crée un nouvelle variable mf
L3

type(mf) vaut function

on peut utiliser la fonction mf() .
On a donné l’exemple avec une fonction ma_fonction , mais on peut faire la même
chose avec tout objet défini dans le module mon_module .
Voyons sur un exemple les cinq formes différentes de l’instruction import qui permet
d’importer un module.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
je souhaite utiliser la fonction sqrt du module math , qui retourne la racine carrée de

79
 80 CHAPITRE 11. A. Tessier

√
son argument, pour affecter à x la valeur de 3

1 import math # importe le module math avec le nom math

2 x = math.sqrt(3)

1 import math as m # importe le module math avec le nom m

x = m.sqrt(3)

e
2

ri
1 from math import sqrt # importe la fonction sqrt du module math avec le nom sqrt
2 x = sqrt(3)

ét
1 from math import * # importe tous les objets du module math avec leur nom
2 x = sqrt(3)

1
2
from math import sqrt as rc # importe la fonction sqrt du module math avec le nom rc
x = rc(3)
o m
La biliothèque standard contient de nombreux packages et modules. Mais vous pouvez
trouver aussi des centaines de milliers d’autres packages et modules dans l’Index des
on

Paquets Python (PyPI pour Python Package Index).

Vous pouvez développer vos propres modules pour pouvoir les réutiliser dans différents
projets. Quand vous faites un fichier source (fichier avec l’extension .py), vous
pouvez soit l’importer dans un autre programme comme un module, avec l’instruction
import , soit l’exécuter comme un script. Parfois dans le code, qui pourra soit être importé
comme module, soit exécuté comme un script, vous avez besoin de savoir dans quel cas
Éc

vous êtes, car certaines instructions ne doivent être exécutée que dans un seul des deux
cas. Pour déterminer dans le code si le module est importé ou s’il est directement exécuté
comme un script, vous pouvez tester la variable __name__ qui aura la valeur '__main__'
que si le fichier est exécuté comme un script, sinon sa valeur sera le nom du module.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
considérons le fichier testmod.py qui contient le code
L3

1 if __name__ == '__main__':
2 print('directement exécuté comme un script')
3 else:
4 print('importé comme module')

si ce script est exécuté, il affiche directement exécuté comme un script

par contre, s’il est importé dans un autre script avec l’instruction import testmod , alors
il affiche importé comme module
11.1. LE MODULE MATH 81

Un module est importé sous forme d’un objet. On peut le vérifier avec la fonction
type . La fonction dir permet de connaître tous les attributs définis par un objet. Elle
est souvent pratique en complément de la fonction help . Dans le cas d’un module, la
fonction dir nous permet de connaître tous les identificateurs (variables, fonctions. . . )
définis par le module.
Nous présentons brièvement quelques modules, de la bibliothèque standard ou installés
par la distribution , utiles à la science des données. Le chapitre 19 en présente
quelques autres.

e
11.1 Le module math

ri
Les principales fonctions et constantes du module math que nous pourrons utiliser sont
— les fonctions de partie entière
math.floor(x)

ét
donne la partie entière par défaut de x .
math.floor(3.7) vaut 3 .
math.ceil(x)
donne la partie entière par excès de x .
math.floor(3.7) vaut 4 . m
math.trunc(x)
donne x tronqué de sa partie décimale.
math.floor(3.7) vaut 3 .
o
— les fonctions combinatoires
math.factorial(n)
donne le nombre de permutations de n éléments : n !.
on

math.factorial(5) vaut 120 .

math.comb(n,k)
n!
donne le nombre de combianisons k parmi n : .
( n − k )!
math.comb(5,2) vaut 10 .
Éc

math.perm(n,k)
n!
donne le nombre d’arrangements k parmi n : .
k !×( n − k )!
math.perm(5,2) vaut 20 .
— les fonctions arithmétiques
math.gcd(a,b)
L3

donne le plus grand diviseur commun de a et b .

math.gcd(540,600) vaut 60 .

math.lcm(a,b)
donne le plus petit multiple commun de a et b .
math.lcm(204,306) vaut 612 .
— les fonctions logarithmiques et exponentielles
math.log10(x)
donne le logarithme en base 10 de x .
math.log10(1000) vaut 3.0 .
82 CHAPITRE 11. A. Tessier

math.sqrt(x)
donne la racine carré de x .
math.sqrt(25) vaut 5.0 .
— les constantes
math.inf
qui représente +∞.
-math.inf pour −∞.
math.nan

e
qui signifie « Not A Number » et représente un résultat qui n’est pas un nombre
(par exemple pour une fonction qui n’est pas définie pour certaines valeurs). Il

ri
est différent de tous les autres nombres et de lui-même : math.nan == math.nan
vaut False .
Pour tester si x vaut math.nan , on écrit math.isnan(x) .
math.pi

ét
qui donne une valeur approchée de π.
math.pi vaut 3.141592653589793 .
math.e
qui donne une valeur approchée de e.
math.e vaut 2.718281828459045 .
m
11.2 Le package NumPy
o
Si le module math propose quelques fonctions mathématiques de base, le package
NumPy numpy va beaucoup plus loin. Il propose de nombreuses fonctions mathématiques
et des outils pour la manipulation de tableaux de dimension quelconque, pour le scien-
on

tifique. Cette bibliothèque est tellement riche que nous n’en présentons ici qu’une petite
partie. Pour une vision complète, consultez le manuel de référence de l’API (Application
Programming Interface).
Dans le section 2.7 nous avons donné une idée de la manière de représenter les don-
nées en mémoire. En réalité, pour chaque type de données, il existe plusieurs représenta-
Éc

tions classiques. Par exemple, rien que pour les entiers, selon qu’on souhaite seulement
des entiers positifs ou aussi des entiers négatifs, seulement des entiers proche de 0 (qui
s’écrivent avec peu de chiffres) ou aussi des très grands entiers (qui s’écrivent avec beau-
coup de chiffres) . . . , on utilisera des codages différents. Alors que propose un seul
type pour les booléens, les entiers, les réels, les complexes, les chaînes de caractères. . . ,
NumPy en propose plusieurs. C’est au total 24 nouveaux types qui sont définis dans
NumPy. Pour les différencier des types de base de , ceux qui portent le même nom
L3

sont suffixés par _ dans NumPy. Nous utiliserons principalement numpy.bool_ pour les
booléens, numpy.int_ pour les entiers, numpy.double pour les réels

11.3 Le package pandas

11.4 Le package matplotlib
Chapitre 12

e
Les objets

ri
ét
o m
on
Éc
L3

83
84 CHAPITRE 12. A. Tessier

e
ri
ét
o m
on
Éc
L3
Chapitre 13

e
Programmation avancée

ri
ét
o m
on
Éc
L3

85
86 CHAPITRE 13. A. Tessier

e
ri
ét
o m
on
Éc
L3
Chapitre 14

e
Les types prédéfinis

ri
14.1 Les booléens

ét
Il s’agit des valeurs de vérité False (faux) et True (vrai). Par défaut, tous les objets
sont équivalents à True , à l’exception des objets suivants :
— None qui représente l’absence de valeur ;
— le nombre 0, quelque soit sa forme : 0 , 0.0 , 0j , . . . ;
— les itérables vides : '' , [] , () , {} , range(0) . . .
Les fonctions et opérateurs booléens ont comme résultat l’une des deux valeurs False
ou True , à l’exception des opérateurs or et and (voir section 15.3). Par exemple,
m
— 3 < 5 vaut True ;
o
— 5 <= 3 vaut False ;
— 2 == 1+1 vaut True ;
— (3 < 5) or (5 <= 3) vaut True ;
on

14.2 Les entiers, les réels, les complexes

14.2.1 Les entiers
Éc

Il s’agit des nombres positifs et négatifs qui ne contiennent pas de point décimal. Par
exemple, 3 ou -15 sont entiers, mais 3.0 n’est pas un entier pour . En effet,
type(3) vaut int alors que type(3.0) vaut float .
Les nombres entiers sont construits soient en donnant la suite des chiffres, précédée
éventuellement du signe, comme -15 , soit avec la fonction int qui prend en argument
un entier, un réel ou une chaîne contenant un nombre entier.
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int(-15) vaut -15
int(3.5) vaut 3 (c’est la partie entière du réel)
int(' -15 ') vaut -15

14.2.2 Les réels

Il s’agit des nombres positifs et négatifs qui s’écrivent avec un point décimal. Par
exemple, 3. ou 2.718e-15 sont réels, mais 3 n’est pas un réel.

87
88 CHAPITRE 14. A. Tessier

Comme pour les entiers, on peut aussi les construire avec la fonction float qui prend
en argument un entier, un réel ou une chaîne contenant un nombre réel.

14.2.3 Les complexes

Il s’agit des nombres qui contiennent une partie imaginaire. Par exemple, 3+0j ou
2.718e-15-3.14j sont complexes.
Comme pour les entiers et les réels, on peut aussi les construire avec la fonction

e
complex qui prend en argument un entier, un réel, une chaîne contenant un nombre réel
ou deux nombres réels qui donnent la partie réelle et la partie imaginaire.

ri
14.2.4 Les opérateurs et fonctions
x + y
retourne la somme.

ét
2 + 3 vaut 5 .
x - y
retourne la différence.
2 - 3 vaut -1 . m
x * y
retourne le produit.
2 * 3 vaut 6 .
o
x / y
retourne le quotient.
2 / 3 vaut 0.66666... .
on

x // y
retourne le quotient de la division euclidienne.
25 // 3 vaut 8 .
x % y
retourne le reste de la division euclidienne.
Éc

25 % 3 vaut 1 .
x ** y
retourne la puissance.
2 ** 3 vaut 8 .
+x
retourne le nombre.
L3

-x
retourne l’opposé.
abs(x)
retourne la valeur absolue.
divmod(x, y)
retourne le couple (x // y, y % y) .
pow(x, y)
retourne x ** y .
14.3. LES CHAÎNES DE CARACTÈRES 89

round(x)
retourne l’arrondi à l’entier.
round(x, y)
retourne l’arrondi de x avec y décimales.
La section 15.1 donne la priorité des opérateurs.
Le module math fourni des fonctions mathématiques supplémentaires.

e
14.2.5 Les méthodes
Les deux méthodes qui pourront nous intéresser sont

ri
x.is_integer()
retourne True si la valeur de x est entière, que x soit de type entier ou réel.
x.as_integer_ratio()

ét
retourne un couple (n, d) avec n entier et d entier positif, telle que la fraction
n / d vaut x et est sous forme irréductible.
(-3.5).as_integer_ratio() retourne (-7, 2) .

14.3 Les chaînes de caractères

m
On rappelle que les chaînes sont des objets non modifiables. Ceci signifie que toutes les
méthodes qui ont pour résultat une chaîne de caractères retournent une nouvelle chaîne
o
et ne modifie pas la chaîne d’origine.
on

14.3.1 Les opérateurs et fonctions

x + y où x y sont des chaînes
retourne la concaténation des deux chaines.
x * y où x est une chaîne et y un entier
retourne la chaîne x concaténée avec elle-même y fois. Si y ≤ 0, retourne la
Éc

chaîne vide '' .

y * x retourne le même résultat.
y in x où x et y sont des chaînes
retourne True si y est une sous-chaîne de x , False sinon.
y not in x où x et y sont des chaînes
retourne False si y est une sous-chaîne de x , True sinon.
L3

len(x) où x est une chaîne

retourne le nombre de caractères de la chaîne x .

14.3.2 Les méthodes minuscules/majuscules

x.capitalize()
retourne une copie de la chaîne avec le premier caractère en majuscule et le reste
en minuscule.
'la prograMMATION python'.capitalize() retourne 'La programmation python' .
90 CHAPITRE 14. A. Tessier

x.lower()
retourne une copie de la chaîne avec tous les lettres en minuscules.
'la prograMMATION python'.capitalize() retourne 'la programmation python' .

x.swapcase()
rentourne une copie de la chaîne où les caractères majuscules sont convertis en
minuscules et vice versa.
'la prograMMATION python'.swapcase() retourne 'LA PROGRAmmation PYTHON' .

x.title()

e
retourne une copie de la chaîne où les mots commencent par une capitale et les
autres lettres sont en minuscules.

ri
'la prograMMATION python'.title() retourne 'La Programmation Python' .

x.upper()
retourne une copie de la chaîne avec tous les lettres en majuscule.
'la prograMMATION python'.upper() retourne 'LA PROGRAMMATION PYTHON' .

ét
14.3.3 Les méthodes d’alignement et recadrage
x.center(y) où y est un entier
si y est inférieur à la longueur
de la chaîne, rentourne la chaîne x , sinon rentourne
m
une chaîne de longueur y qui contient la chaîne x centrée.
'la prograMMATION python'.center(30) retourne ' la prograMMATION python '.

x.center(y, z) où y est un entier et z une chaîne d’un caractère

o
idem ci-dessus, mais en utilisant le caractère z à la place d’espaces.
'la prograMMATION python'.center(30, '+') retourne '+++la prograMMATION python++++' .

x.ljust(y) , x.ljust(y, z)
on

comme x.center(y) ou x.center(y, z) , mais retourne la chaîne justifiée à gauche.

'la prograMMATION python'.ljust(30, '+') retourne 'la prograMMATION python+++++++' .

x.rjust(y) , x.rjust(y, z)
comme x.ljust(y) ou x.ljust(y, z) mais justifiée à droite.
Éc

'la prograMMATION python'.rjust(30, '+') retourne '+++++++la prograMMATION python' .

x.zfill(y) où y est un entier

retourne une copie de la chaîne remplie à gauche par ’0’ pour faire une chaîne de
longueur y , mais laisse le préfixe '+' ou '-' s’il est présent.
'3.14'.zfill(7) retourne '0003.14' .
'-3.14'.zfill(7) retourne '-003.14' .
L3

x.strip()retourne une copie de la chaîne sans les espaces au début et à la fin.

' la prograMMATION python '.strip() retourne 'la prograMMATION python' .

x.strip(y)
retourne une copie de la chaîne sans les caractères apparaissant dans y au début
et à la fin.
'la prograMMATION python'.strip('l apgnMo') retourne 'rograMMATION pyth' .

x.lstrip() , x.lstrip(y)
comme x.strip() ou x.strip(y) , mais seulement au début.
' la prograMMATION python '.lstrip() retourne 'la prograMMATION python ' .
14.3. LES CHAÎNES DE CARACTÈRES 91

x.rstrip() , x.rstrip(y)
comme x.strip() ou x.strip(y) , mais seulement à la fin.
'la prograMMATION python'.rstrip('l apgnMo') retourne 'la prograMMATION pyth' .

x.removeprefix(y) où y est une chaîne

si la chaîne ne commence pas pas y , renvoie une copie de l’original, sinon renvoie
une copie de la chaîne sans le préfixe y .
'la prograMMATION python'.removeprefix('la ') retourne 'prograMMATION python' .

e
x.removesuffix(y)
comme x.removeprefix(y) , mais pour le suffixe y .
retourne 'la prograMMATION' .

ri
'la prograMMATION python'.removesuffix(' python')

14.3.4 Les méthodes de découpage

ét
x.split()
retourne une liste des mots de la chaîne.
'la prograMMATION python'.split() retourne ['la', 'prograMMATION', 'python'] .

x.splitlines()
retourne une liste des lignes de la chaîne.
'la prograMMATION\npython'.splitlines()
m retourne ['la prograMMATION', 'python'] .
x.partition(y) où y est une chaîne
retourne un triplet contenant la partie avant y , puis y , puis la partie après y .
o
'la prograMMATION python'.partition('MMA') retourne ('la progra', 'MMA', 'TION python') .

x.rpartition(y)
on

comme x.partition(y) , mais découpe à la dernière occurence de y à la place de

la première.
'la prograMMATION python'.partition('M') retourne ('la prograM', 'M', 'ATION python') .

14.3.5 Les méthodes de test du contenu

Éc

x.isalpha()
retourne True si les caractères de la chaîne sont tous des lettres.
'12ab3C'.isalpha() retourne False .
'abc'.isalpha() retourne True .

x.isdigit()
L3

comme x.isalpha() , mais si les caractères de la chaîne sont tous des chiffres.
'12.3'.isdigit() retourne False .
'123'.isdigit() retourne True .
x.isnumeric() et x.isdecimal() sont très similaires.

x.isalnum()
comme x.isalpha() , mais si les caractères de la chaîne sont tous des lettres ou des
chiffres.
'3d2fd'.isalnum() retourne True .
'3d fd'.isalnum() retourne False .
92 CHAPITRE 14. A. Tessier

x.islower()
retourne True si toutes les lettres de la chaîne sont en minuscule.
'la prograMMATION python'.islower() retourne False .
'la programmation python'.islower() retourne True .
x.isupper()
comme str.islower() , mais en majuscules.
'LA PROG'.isupper() retourne True .
x.isspace()

e
retourne True si les caractères sont tous des espaces, tabulations, passage à la
ligne. . . .

ri
' \n '.isspace() retourne True .

14.3.6 Les méthodes de recherche

où y est une chaîne

ét
x.count(y)
retourne le nombre d’occurrences de y ne se chevauchant pas dans la chaîne.
'blablabla'.count('la') retourne 3 .
'blablabla'.count('blab') retourne 1 .
x.find(y) où y est une chaîne m
retourne l’indice de la première position de y dans la chaîne ou -1 si elle n’est
pas trouvée.
'blablabla'.find('ab') retourne 2 .
x.index(y) est très similaire.
o
x.rfind(y)
comme x.find(y) , mais pour la dernière position.
on

'blablabla'.rfind('ab') retourne 5 .
x.rindex(y) est très similaire.
x.startswith(y) où y est une chaîne ou un tuple de chaînes
retourne True si lachaîne commence par y , ou une chaîne du tuple y .
'la prograMMATION python'.startswith('la') retourne True .
Éc

'la prograMMATION python'.startswith(('pr', 'la', 'py')) retourne True .

'la prograMMATION python'.startswith(('pr', 'py')) retourne False .
x.endswith(y)
comme x.startswith(y) , mais si elle termine par à la place de commence par.
'la prograMMATION python'.endswith('thon') retourne True .
L3

14.3.7 Les autres méthodes

x.join(y) où y est un itérable qui contient des chaînes
retourne la chaîne concaténation des chaînes de l’itérable y séparées par la chaîne
x.
'_'.join(['la','programmation', 'python']) retourne 'la_programmation_python' .
x.replace(y, z) où y et z sont des chaînes
retourne une copie de la chaîne où toutes les occurrences de y sont remplacées par
z.
'la prograMMATION python'.replace(' p','#') retourne 'la#rograMMATION#ython' .
 14.3. LES CHAÎNES DE CARACTÈRES 93

14.3.8 Les chaînes de caractères formatées

Une chaîne de caractères formatée est une chaîne de caractère immédiatement précédée
d’un f ou un F. Il s’agit d’une chaîne et son type est str .
Dans la chaîne formatée, les expressions entre accolades sont évaluées. Pour placer une
accolade dans la chaîne, il faut la doubler.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

e
1 s1 = 'la prog{1+1}'

ri
2 s2 = f'la prog{1+1}'
3 s3 = f'la prog{{1+1}}'
4 x = 'py'
5 y = 'thon'
6 s4 = f'la prog {x+y}'

ét
s1 vaut 'la prog{1+1}'
s2 vaut 'la prog2'
s3 vaut 'la prog{1+1}'
s4 vaut 'la prog python' m
L’expression entre accolades peut être suivie d’un = éventuellement précédé ou suivi
o
d’espaces. Dans ce cas, c’est le texte de l’expression suivi du = puis de la valeur de
l’expression qui sont placés dans la chaîne, en conservant les espaces avant et après le = .
on

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
f'la prog {1+1=}' vaut 'la prog 1+1=2'
f'la prog {1+1 = }' vaut 'la prog 1+1 = 2'
Éc

L’expression entre accolades peut être suivie d’un : pour spécifier un formatage de
l’expression. Le langage de formatage est assez complexe et nous en faisons une présen-
tation simplifiée. Nous présentons les principales spécifications de formatage. Chacune
d’elles est optionnelle, mais l’ordre doit être respecté :

1. l’alignement (à gauche < , à droite > , centré ^ ) qui peut éventuellement être
L3

précédé par un caractère de remplissage à utiliser plutôt que l’espace (par défaut
l’alignement est à gauche, sauf pour les nombres où il est à droite) ;

2. le nombre de caractères minimum utilisés par l’expression ;

3. un point suivi du nombre de caractères maximum utilisés par l’expression qui

est alors tronquée, sauf si l’expression est un nombre, dans ce cas, il s’agit d’une
précision (voir le type ci-sessous) ;

4. le type (on ne présente que certains types pour les nombres) qui peut être
94 CHAPITRE 14. A. Tessier

e pour une notation scientifique, la précision donne le nombre de chiffres

après le point décimal dans la mantisse
f pour une notation décimale, la précision donne le nombre de chiffres
après le point décimal
g (valeur par défaut) pour la forme générale, la précision donne le nombre
de chiffres singificatifs utilisés en tout (avant et après l’éventuel point
décimal) et la notation décimale ou scientifique la plus appropriée est
utilisé
% pour une notation en pourcentage, le nombre est multiplié par 100, la

e
précision donne le nombre de chiffres après le point décimal, un % est
ajouté

ri
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
f'valeur {3.1415926:} !' vaut valeur 'la prog 3.1415926 !'
f'valeur {3.1415926:12} !' vaut valeur 'la prog 3.1415926 !'

ét
f'valeur {3.1415926:<12} !' vaut valeur 'la prog 3.1415926 !'
f'valeur {3.1415926:0>12} !' vaut valeur 'la prog 0003.1415926 !'
f'valeur {3.1415926:.3} !' vaut valeur 'la prog 3.14 !'
f'valeur {3.1415926:12.3} !' vaut valeur 'la prog 3.14 !'
f'valeur {3.1415926:^12.3} !' vaut valeur 'la prog 3.14 !'
f'valeur {3.1415926:*^12.3} !' vaut valeur 'la prog ****3.14**** !'
f'valeur {3.1415926:.5} !' vaut valeur 'la prog 3.1416 !'
m
f'valeur {3.1415926:e} !' vaut valeur 'la prog 3.141593e+00 !'
o
f'valeur {3.1415926:.2f} !' vaut valeur 'la prog 3.14 !'
f'valeur {3.1415926:.2%} !' vaut valeur 'la prog 314.16% !'
on

f'la prog {"python":}' vaut 'la prog python'

f'la prog {"python":12}' vaut 'la prog python '
f'la prog {"python":2}' vaut 'la prog python'
f'la prog {"python":.2}' vaut 'la prog py'
f'la prog {"python":12.2}' vaut 'la prog py '
Éc

f'la prog {"python":x>12.2}' vaut 'la prog xxxxxxxxxxpy'

14.4 Les listes

Une liste est une suite modifiable d’objets indicés à partir de 0. Le type correspondant
est list .
L3

On peut construire une liste en donnant ses éléments entre crochets, soit en exten-
sion en donnant chacun des éléments séparés par des virgules, soit en compréhension en
utilisant une expression compréhension.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
['a', 1, 3.5] est la liste qui contient, dans cet ordre, 'a' , 1 et 3.5
[2 * x for x in range(10) if x % 2 == 0] est la liste [0, 4, 8, 12, 16]

On peut aussi construire une liste avec la fonction list .

14.4. LES LISTES 95

list()
retourne la liste vide [] .
list(x) où x est un itérable
retourne la liste qui contient les élements de x .
list(range(10)) retourne [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] .
Les éléments d’une liste x sont indicés à partir de 0 jusqu’au nombre d’éléments moins
un c’est-à-dire len(x) - 1 .

e
14.4.1 Les opérateurs, fonctions et instructions
Si x est une liste

ri
len(x)
retourne le nombre d’éléments de x .
x[i] où i est un entier

ét
si 0 <= i < len(x) , retourne l’élément d’indice i de la liste, si -len(x) <= i < 0 ,
retourne l’élément d’indice len(x) - i de la liste, sinon provoque une erreur :
IndexError: list index out of range.
[0, 4, 8, 12, 16][1] vaut 4 .
[0, 4, 8, 12, 16][-2] vaut 12 . m
x[i:j] où i et j sont entiers
retourne la tranche qui va de l’élement d’indice i à l’élément qui précède celui
d’indice j . Si i n’est pas précisée alors l’indice de départ est 0 . Si j n’est pas
o
précisée alors l’indice d’arrivée est len(x) .
[0, 4, 8, 12, 16][:] vaut [0, 4, 8, 12, 16] .
[0, 4, 8, 12, 16][1:-2] vaut [4, 8] .
on

x[i:j:k] où i , j et k sont entiers

retourne la tranche qui va de l’élement d’indice i à l’élément qui précède celui
d’indice j par pas de k . Si i n’est pas précisée et 0 < k alors l’indice de départ
est 0 , si k < 0 alors c’est len(x)-1 c’est-à-dire -1 . Si j n’est pas précisée et
0 < k alors l’indice d’arrivée est len(x) , si k < 0 alors c’est -len(x)-1 . Si k
Éc

n’est pas précisée alors le pas est de 1 (un pas de 0 est interdit : ValueError:
slice step cannot be zero).
[0, 4, 8, 12, 16][::2] vaut [0, 8, 16] .
[0, 4, 8, 12, 16][::-2] vaut [16, 8, 0] .
x[i] = yoù i est un entier
remplace par y l’élément d’indice i dans la liste, provoque une erreur si i n’est
L3

pas une indice de la liste.

x[i:j] = y où i et j sont entiers et y un itérable
remplace la tranche x[i:j] par les éléments de l’itérable y . Notez que x[0:0] = y
ajoute les éléments de y au début de x et x[len(x):len(x)] = y ajoute les élé-
ments de y à la fin de x .
x[i:j:k] = y où i , j et k sont entiers et y un itérable
remplace un à un les éléments de la tranche x[i:j:k] par les éléments de l’itérable
y qui doit comporter autant d’éléments que la tranche x[i:j:k] , sinon provoque
une erreur.
96 CHAPITRE 14. A. Tessier

del x[i] où i est un entier

supprime l’élément d’indice i de la liste. C’est identique à x[i:i+1] = [] .
del x[i:j] où i et j sont entiers
supprime la tranche de la liste. C’est identique à x[i:j] = [] .
del x[i:j:k] où i , j et k sont entiers
supprime la tranche de la liste.
y in x
retourne True si un élément de x vaut y , False sinon.

e
y not in x
retourne True si aucun élément de x vaut y , False sinon.

ri
x + y où y est une liste
retourne une liste qui est la concaténation des deux listes x et y .
x += y où y est un itérable

ét
ajoute les éléments de y à x .
x * y où y est un entier
retourne une liste qui est la concaténation de x avec elle-même y fois.
y * x retourne la même liste.
x *= y où y est un entier
m
met à jour la liste x en répétant y fois son contenu.
min(x)
retourne le plus petit élément de x , ou provoque une erreur si la liste est vide ou
o
tous les éléments de la liste ne sont pas comparables entre eux.
max(x)
retourne le plus grand élément de x , ou provoque une erreur si la liste est vide ou
on

tous les éléments de la liste ne sont pas comparables entre eux.

Si y est un itérable qui ne contient que des éléments comparables entre eux
sorted(y)
retourne une nouvelle liste contenant les éléments de y en ordre croissant.
Éc

sorted(y, reverse=True)
retourne la liste contenant les éléments de y en ordre décroissant.
Notez qu’on peut également utiliser des objets slice pour désigner des tranches de
liste. Pour une liste x , x[i:j:k] est identique à x[slice(i,j,k)] .

14.4.2 Les méthodes

L3

x.append(y)
ajoute y à la fin de la liste.
x.copy()
retourne une copie de la liste. C’est identique à x[:] .
x.insert(i, y) où i est un entier
insert y à l’indice i . C’est identique à x[i:i] = [y] .
x.pop()
retourne le dernier élément de la liste, qui est supprimé.
14.5. LES TUPLES 97

x.pop(i) où i est un entier

retourne et supprime l’élément d’indice i de la liste.
x.sort()
trie sur place les éléments de la liste (qui doivent être comparables entre eux).
x.reverse()
inverse sur place les éléments de la liste. Attention, ce n’est pas identique à x[::-1]
qui retourne une nouvelle liste.
x.clear()

e
supprime tous les éléments de la liste. C’est identique à x[:]=[] .
x.extend(y) où y est un itérable

ri
ajoute à la liste les éléments de y . C’est identique à x += y .
x.count(y)
retourne le nombre d’occurrences de y dans la liste.

ét
x.index(y)
retourne l’indice de la première occurrence de y dans la liste, provoque une erreur
si y n’est pas dans la liste.
x.index(y, i) où i est un entier
retourne l’indice de la première occurrence de y dans la liste à partir de l’indice
m
i , provoque une erreur si y n’y est pas.
x.index(y, i, j) où i et j sont entiers
retourne l’indice de la première occurrence de y dans la liste entre les indices i
o
et j exclu, provoque une erreur si y n’y est pas.
x.remove(y)
supprime le premier élément égal à y , provoque une erreur si l’élément n’est pas
on

dans la liste.

14.5 Les tuples

Un tuple est une suite non modifiable d’objets indicés à partir de 0. Le type corres-
Éc

pondant est tuple .

On peut construire un tuple en donnant ses éléments entre parenthèses chacun des
éléments séparés par des virgules.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
('a', 1, 3.5) est le triplet qui contient, dans cet ordre, 'a' , 1 et 3.5
L3

On peut aussi construire un tuple avec la fonction tuple .

tuple()
retourne le tuple vide () .
tuple(x) où x est un itérable
retourne le tuple qui contient les élements de x .
tuple(range(10)) retourne (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) .
tuple(2 * x for x in range(10) if x % 2 == 0) retourne (0, 4, 8, 12, 16) .
98 CHAPITRE 14. A. Tessier

Les éléments d’un tuple x sont indicés à partir de 0 jusqu’au nombre d’éléments moins
un c’est-à-dire len(x) - 1 .
Attention, pour différencier un élément y du tuple qui contient l’élement y , on écrit
le tuple (y,) . La virgule de fin est obligatoire, car l’expression (y) est siplement y .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(3) est l’entier 3 , type((3)) vaut int
(3,) est le tuple qui contient l’entier 3 , type((3,)) vaut tuple

e
14.5.1 Les opérateurs, fonctions et instructions

ri
Si x est un tuple
len(x)
retourne le nombre d’éléments de x .
x[i] où i est un entier

ét
si 0 <= i < len(x) , retourne l’élément d’indice i , si -len(x) <= i < 0 , retourne
l’élément d’indice len(x) - i , sinon provoque une erreur : IndexError: tuple
index out of range.
x[i:j] où i et j sont entiers
retourne la tranche qui va de l’élement d’indice i à l’élément qui précède celui
m
d’indice j . Si i n’est pas précisée alors l’indice de départ est 0 . Si j n’est pas
précisée alors l’indice d’arrivée est len(x) .
x[i:j:k] où i , j et k sont entiers
o
retourne la tranche qui va de l’élement d’indice i à l’élément qui précède celui
d’indice j par pas de k . Si i n’est pas précisée et 0 < k alors l’indice de départ
on

est 0 , si k < 0 alors c’est len(x)-1 c’est-à-dire -1 . Si j n’est pas précisée et

0 < k alors l’indice d’arrivée est len(x) , si k < 0 alors c’est -len(x)-1 . Si k
n’est pas précisée alors le pas est de 1 (un pas de 0 est interdit : ValueError:
slice step cannot be zero).
y in x
retourne True si un élément de x vaut y , False sinon.
Éc

y not in x
retourne True si aucun élément de x vaut y , False sinon.
x + y où y est une liste
retourne une tuple qui est la concaténation des deux tuples x et y .
x * y où y est un entier
retourne une tuple qui est la concaténation de x avec lui-même y fois.
L3

y * x retourne le même tuple.

min(x)
retourne le plus petit élément de x , ou provoque une erreur si le tuple est vide ou
tous les éléments ne sont pas comparables entre eux.
max(x)
retourne le plus grand élément de x , ou provoque une erreur si le tuple est vide
ou tous les éléments ne sont pas comparables entre eux.
Notez qu’on peut également utiliser des objets slice pour désigner des tranches de
tuple. Pour une tuple x , x[i:j:k] est identique à x[slice(i,j,k)] .
14.6. LES INTERVALLES 99

14.5.2 Les méthodes

x.count(y)
retourne le nombre d’occurrences de y dans le tuple.
x.index(y)
retourne l’indice de la première occurrence de y dans le tuple, provoque une erreur
si y n’est pas dans le tuple.
x.index(y, i) où i est un entier

e
retourne l’indice de la première occurrence de y dans le tuple à partir de l’indice
i , provoque une erreur si y n’y est pas.

ri
x.index(y, i, j) où i et i sont entiers
retourne l’indice de la première occurrence de y dans le tuple entre les indices i
et j exclu, provoque une erreur si y n’y est pas.

ét
14.6 Les intervalles
Un intervalle est une suite non modifiable d’entiers, tel que l’on passe d’un entier au
suivant en ajoutant toujours le même entier qu’on appelle le pas, par exemple la suite
m
d’entiers 15, 20, 25, 30, 35, 40, 45 a un pas de 5. Les éléments de l’intervalle sont indicés
à partir de 0. Le type correspondant est range .
On construit un intervalle avec la fonction range .
o
range(y) où y est un entier
retourne l’intervalle des entiers de 0 à y exclu avec un pas de 1. Si y <= 0 , l’in-
tervalle est vide.
on

range(x, y) où x et y sont entiers

retourne l’intervalle des entiers de x à y exclu avec un pas de 1. Si y <= x ,
l’intervalle est vide.
range(x, y, k) où x , y et k sont entiers
retourne l’intervalle des entiers de x à y exclu avec un pas de k . Si 0 < k et
Éc

y <= x , l’intervalle est vide. Si k < 0 et x <= y , l’intervalle est vide. Si k == 0

c’est une erreur ValueError: range() arg 3 must not be zero.
L’avantage d’un intervalle sur une liste ou un tuple qui contiendrait les mêmes éléments
est que l’intervalle occupe toujours la même place en mémoire puisqu’il ne stocke que les
trois entiers : valeur de départ, valeur d’arrêt et pas.
L3

14.6.1 Les opérateurs, fonctions et instructions

Si x est un intervalle
len(x)
retourne le nombre d’éléments de x .
x[i] où i est un entier
si 0 <= i < len(x) , retourne l’élément d’indice i , si -len(x) <= i < 0 , retourne
l’élément d’indice len(x) - i , sinon provoque une erreur : IndexError: range
index out of range.
100 CHAPITRE 14. A. Tessier

x[i:j] où i et j sont entiers

retourne la tranche qui va de l’élement d’indice i à l’élément qui précède celui
d’indice j . Si i n’est pas précisée alors l’indice de départ est 0 . Si j n’est pas
précisée alors l’indice d’arrivée est len(x) .
x[i:j:k] où i , j et k sont entiers
retourne la tranche qui va de l’élement d’indice i à l’élément qui précède celui
d’indice j par pas de k . Si i n’est pas précisée et 0 < k alors l’indice de départ
est 0 , si k < 0 alors c’est len(x)-1 c’est-à-dire -1 . Si j n’est pas précisée et

e
0 < k alors l’indice d’arrivée est len(x) , si k < 0 alors c’est -len(x)-1 . Si k
n’est pas précisée alors le pas est de 1 (un pas de 0 est interdit : ValueError:
slice step cannot be zero).

ri
y in x
retourne True si un élément de x vaut y , False sinon.
y not in x

ét
retourne True si aucun élément de x vaut y , False sinon.
min(x)
retourne le plus petit élément de x , ou provoque une erreur si le tuple est vide ou
tous les éléments ne sont pas comparables entre eux.
max(x)
m
retourne le plus grand élément de x , ou provoque une erreur si le tuple est vide
ou tous les éléments ne sont pas comparables entre eux.
Notez qu’on peut également utiliser des objets slice pour désigner des tranches d’in-
o
tervalle. Pour une intervalle x , x[i:j:k] est identique à x[slice(i,j,k)] .

14.6.2 Les méthodes

on

x.count(y)
retourne le nombre d’occurrences de y dans l’intervalle (normalement 0 ou 1).
x.index(y)
retourne l’indice de la première occurrence de y dans l’intervalle, provoque une
Éc

erreur si y n’est pas dans l’intervalle.

14.7 Les dictionnaires

Les dictionnaires sont des objets modifiables et itérables. On les appelles aussi des
tableaux associatifs.
Il existe différentes manières de construire un dictionnaire.
L3

— {paires} , où paires est une suite de paires clé: valeur séparées par des virgules.
— {comprehension} , où comprehension est une définition en compréhension.
— dict() est le dictionnaire vide {} .
— dict(x) , où x est un objet itérable qui contient des couples (clé, valeur) , est le
dictionnaire qui associe la clé de chaque couple à la valeur.
— dict(mapping) , où mapping est une suite de identificateur=valeur séparés par des
virgules. Attention, les clés dans ce cas sont les chaînes de caractères qui corres-
pondent aux identificateurs. Ces derniers doivent respecter les règles des identifi-
cateurs en (voir le chapiter 16).
14.7. LES DICTIONNAIRES 101

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = dict(janvier='mercredi', février='samedi', mars='samedi', avril='mardi',

,→ mai='jeudi', juin='dimanche', juillet='mardi', août='vendredi',
,→ septembre='lundi', octobre='mercredi', novembre='samedi',
,→ décembre='lundi')
2 y = {'janvier': 'mercredi', 'février': 'samedi', 'mars': 'samedi', 'avril':
,→ 'mardi', 'mai': 'jeudi', 'juin': 'dimanche', 'juillet': 'mardi',
,→ 'août': 'vendredi', 'septembre': 'lundi', 'octobre': 'mercredi',
'novembre': 'samedi', 'décembre': 'lundi'}

e
,→

x == y vaut True

ri
Si la même clé apparaît plusieurs fois, la valeur associée est celle qui correspond à la
dernière apparition de la clé.
Les clés des dictionnaires sont obligatoirement d’un type non modifiable.
Un dictionnaire est itérable. L’itération produit successivement les clés dans l’ordre

ét
dans lequel elles ont été ajoutées au dictionnaire.

14.7.1 Les opérateurs, fonctions et instructions

Si x est un dictionnaire m
len(x)
retourne le nombre de clés de x .
x[y]
o
retourne l’élément de clé y du dictionnaire x ou une erreur KeyError: y si la clé
y n’est pas dans x .
on

x[y] = z
si elle existe, remplace par z la valeur pour la clé y , sinon ajoute la clé y avec
la valeur z .
del x[y]
si elle existe, supprime la clé y et la valeur associée du dictionnaire, sinon provoque
une erreur KeyError: y.
Éc

y in x
retourne True si la clé y est dans x , False sinon.
y not in x
retourne True si la y n’est pas dans x , False sinon.
x | y où y est un dictionnaire
retourne un dictionnaire qui contient toutes les associations clé-valeur des deux
L3

dictionnaires, si une clé est présente dans les deux, alors c’est la valeur dans le
dictionnaire y qui est retenue.
x |= y où y est un dictionnaire
met à jour le dictionnaire x avec toutes les associations clé-valeur de y .

14.7.2 Les méthodes

Les méthodes suivantes sont disponibles pour les dictionnaires, si x est un diction-
naire :
102 CHAPITRE 14. A. Tessier

x.get(y)
retourne la valeur associée à la clé y si elle existe, sinon retourne None .
x.get(y, z)
retourne la valeur associée à la clé y si elle existe, sinon retourne z .
x.setdefault(y)
si la clé y est dans le dictionnaire, retourne la valeur associée, sinon ajoute y avec
la valeur None et retourne None .

e
x.setdefault(y, z)
si la clé y est dans le dictionnaire, retourne la valeur associée, sinon ajoute y avec
la valeur z et retourne z .

ri
x.update(y) où y est un dictionnaire ou un itérable de couples (clé, valeur)
met à jour le dictionnaire avec les pairs clé-valeur de y .
x.pop(y)

ét
si elle existe, supprime la clé y et retourne la valeur associée, sinon provoque une
erreur KeyError: y.
x.pop(y, z)
si elle existe, supprime la clé y et retourne la valeur associée, sinon retourne z .
x.popitem()
m
supprime et retourne le dernier couple (clé, valeur) qui a été ajouté au dic-
tionnaire s’il n’est pas vide, sinon provoque une erreur KeyError: ’popitem():
dictionary is empty’.
o
x.clear()
supprime tous les clés et valeurs associées de x .
on

x.copy()
retourne un dictionnaire qui est une copie de x .
x.keys()
retourne un itérable contenant toutes les clés du dictionnaire.
x.values()
Éc

retourne un itérable contenant toutes les valeurs du dictionnaire.

x.items()
retourne un itérable contenant tous les couples (clé, valeur) du dictionnaire.

14.8 Les ensembles

L3

Il existe deux sortes d’ensemble :

— set qui sont des ensembles modifiables ;
— frozenset qui sont des ensembles non modifiables.
set() est l’ensemble modifiable vide, frozenset() est l’ensemble non modifiable vide. Si
x est un itérable, set(x) est l’ensemble modifiable construit à partir des éléments de x
et frozenset(x) le même ensemble mais non modifiable.
On peut aussi utiliser la définition en extension et la définition en compréhension
pour les ensembles modifiables en utilisant les accolades. Mais attention, {} n’est pas
l’ensemble vide, c’est le dictionnaire vide !
14.8. LES ENSEMBLES 103

14.8.1 Les opérateurs et fonctions

La fonction len , les opérateurs in et not in sont disponibles pour les ensembles,
ainsi que les opérateurs de comparaison == , != , < , <= , > , >= (la relation d’ordre est
l’inclusion).
On peut également utiliser les opérateurs suivants entre deux ensembles x et y , le
résultat est du même type que x :
x | y
pour l’union x ∪ y .

e
x & y
pour l’intersection x ∩ y .

ri
x - y
pour la différence x \ y .
x ^ y

ét
pour la différence symétrique x ∆ y .
On peut également utiliser les opérateurs en place suivants, où x est un ensemble
modifiable de type set et y est un ensemble :
x |= y
pour ajouter les éléments de y à x .
x &= y
m
pour garder dans x seulement les éléments qui sont dans y .
x -= y
o
pour retirer les éléments de y de x .
x ^= y
on

pour n’avoir dans x que les éléments qui sont dans l’un des deux ensembles, mais
pas dans les deux.

14.8.2 Les méthodes

Les méthodes suivantes sont disponibles pour tous les ensembles, x est de type set
Éc

ou frozenset :
x.copy()
retourne un ensemble, du même type que x , qui contient les mêmes élements que
x.
x.union(y) où y est un itérable
retourne un ensemble, du même type que x , qui contient tous les élements de x
L3

et y . Il peut y avoir plusieurs itérables en paramètre de la méthode union .

x.intersection(y) où y est un itérable
retourne un ensemble, du même type que x , qui contient tous les élements com-
muns à x et y . Il peut y avoir plusieurs itérables en paramètre de la méthode
intersection .
x.difference(y) où y est un itérable
retourne un ensemble, du même type que x , qui contient tous les élements de
x qui ne sont pas dans y . Il peut y avoir plusieurs itérables en paramètre de la
méthode difference .
104 CHAPITRE 14. A. Tessier

x.symmetric_difference(y) où y est un itérable

retourne un ensemble, du même type que x , qui contient tous les élements qui
sont soit x , soit dans y , mais pas dans les deux.
x.issubset(y) où y est un itérable
retourne True si tous les élements de x sont dans y .
x.issuperset(y) où y est un itérable
retourne True si tous les élements de y sont dans x .

e
x.isdisjoint(y) où y est un itérable
retourne True si x et y n’ont aucun élément en commun.
Les méthodes suivantes ne sont disponibles que pour les ensembles modifiables, x est

ri
de type set :
x.add(y)
ajoute l’élément y à x .

ét
x.remove(y)
retire l’élément y de x ou provoque une erreur si y n’est pas dans x .
x.discard(y)
retire l’élément y de x ou ne fait rien si y n’est pas dans x .
m
x.pop()
retire et retourne un élément quelconque de x .
x.clear()
o
retire tous les éléments de x .
x.update(y) où y est un itérable
ajoute tous les éléments de y à x . Il peut y avoir plusieurs itérables en paramètre
on

de la méthode update .
x.intersection_update(y) où y est un itérable
ne garde dans x que les éléments qui sont dans y . Il peut y avoir plusieurs itérables
en paramètre de la méthode intersection_update .
x.difference_update(y) où y est un itérable
Éc

retire de x tous les

éléments qui sont dans y . Il peut y avoir plusieurs itérables
en paramètre de la méthode difference_update .
x.symmetric_difference_update(y) où y est un itérable
ne garde dans x que les éléments qui sont soit dans x , soit dans y , mais pas dans
les deux.
L3
Chapitre 15

e
Les Opérateurs

ri
15.1 La priorité des opérateurs

ét
Le tableau suivant présente les opérateurs, uniquement ceux utilisés dans cet ensei-
gnement, par ordre de priorité, des plus prioritaires au moins prioritaires. Les opérateurs
d’une même case ont même priorité.

opérateur signification m exemple valeur

** puissance 10 ** 3 100
- opposé de -5 -5
* multiplié par 10 * 3 30
o
/ divisé par 10 / 3 3.33. . .
// divisé par† 10 // 3 3
& modulo 10 % 3 1
on

+ plus 10 + 3 13
- moins 10 - 3 7
== égal à 1+1 == 2 vrai
!= différent de 3 != 5 vrai
< inférieur à 5 < 4 faux
<= inférieur ou égal à 3 <= 7 vrai
Éc

> supérieur à 5 > 4 vrai

>= supérieur ou égal à 2 >= 2 vrai
in dans 'b' in 'abc' vrai
not in pas dans 2 not in [1,2,3] faux
is est 'b' is 'abc' faux
not is n’est pas 3 not is 3 faux
L3

not non not True faux

and et 1 < 2 and 7 > 3 faux
or ou 1 < 2 or 7 > 3 vrai
if else si sinon 3 if 1<2 else 7 3
†
Au sens du calcul du quotient de la division euclidienne.

Pour l’opérateur ** , l’opérande droite est évaluée avant l’opérande gauche. Par exemple
pour (1+1)**(2+2) , il y aura d’abord l’évluation de 2+2 , puis l’évaluation de 1+1 , enfin
l’évaluation de 2**4 .
Les autres opérateurs binaires sont évalués de gauche à droite.

105
106 CHAPITRE 15. A. Tessier

15.2 L’opérateur ternaire

L’opérateur ternaire n’est pas à confondre avec l’instruction conditionnelle.
— L’instruction conditionnelle n’est pas une expression, elle n’a pas de valeur. C’est
une instruction composée qui contient elle-même des instructions.
— L’opérateur ternaire est utilisé dans une expression qui a une valeur. L’expression
ne peut pas contenir d’instructions (autres que des expressions).
L’expression s’écrit x if y else z , où x , y et z sont des expressions. Sa valeur est
x si y est équivalente à True , sinon c’est z .

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

ri
25 if 3 < 4 else 12 vaut 25 et 25 if 4 < 3 else 12 vaut 12

Pour l’évaluation de x if y else z , il y a d’abord l’évaluation de y , puis l’évaluation

de x si y vaut True ou l’évaluation de z si y vaut False .

ét
15.3 Les opérateurs logiques
Il y a trois opérateurs logiques qui sont not (négation, non), and (conjonction, et),
or (disjonction, ou). On rappelle les tables de vérités de ces trois opérateurs :

x
m y x and y x or y
x not x False False False False
o
False True False True False True
True False True False False False
True True True True
on

On peut retenir que and est vrai dans un seul cas : quand les deux sont vrais ; et or est
faux dans un seul cas : quand les deux sont faux.
L’opérateur or a comme résultat False ou True . En revanche, les opérateurs or et
and ont toujours comme résultat l’une des deux opérandes. Pour le or , le résultat est
la valeur de l’opérande de gauche si elle est équivalente à True , dans ce cas, l’opérande
Éc

de droite n’est même pas évaluée. Dans le cas contraire, le résultat est la valeur de l’opé-
rande de droite. Pour le and , le résultat est la valeur de l’opérande de gauche si elle est
équivalente à False , l’opérande de droite n’est pas évaluée. Sinon le résultat est la valeur
de l’opérande de droite. Par exemple :
— False and True vaut False ; mais None and True vaut None ; 0.0 and True vaut
0.0 ;
L3

— True and 3 vaut 3 ; 1<2 and 3 vaut 3 ; 'abc' and [] vaut [] ;

— True or False vaut True ; mais 3 or False vaut 3 ;
— False or [1,2,3] vaut [1,2,3] .
Les opérateurs logiques sont moins prioriétaires que les autres opérateurs (à l’exception
de if else ) :
— not True == False est équivalent à not (True == False) qui vaut True , alors que
(not True) == False vaut True ;
— 3 < 5 or 7 > 2 est équivalent à (3 < 5) or (7 > 2) qui vaut True .
L’opérateur not est plus prioriétaire que l’opérateur and , lui-même plus prioritéaire que
or :
 15.4. LES OPÉRATEURS DE COMPARAISON 107

— not 2 < 3 or 5 < 4 and 6 < 7 est équivalent à

(not (2 < 3)) or ((5 < 4) and (6 < 7)) qui vaut True
— 3 < 5 or 7 > 2 or 2 < 8 est équivalent à ((3 < 5) or (7 > 2)) or (2 < 8) qui vaut
True .
Même quand les parentèses ne sont pas obligatoires, il est conseillé de les mettre si elles fa-
cilitent la lecture de l’expression. Par exemple, pour le premier item ci-dessus, on préfèrera
écrire (not 2 < 3) or (5 < 4 and 6 < 7) .

e
15.4 Les opérateurs de comparaison

ri
Il y a huit opérateurs de comparaison qui sont == (égal, =), != (différent, 6=), <
(inférieur, <), <= (inférieur ou égal, ≤), > (supérieur, >), >= (supérieur ou égal, ≥), is
(même objet), is not (objet différent). C’est opérateurs ont comme résultat un booléen
False ou True .
De manière générale, les opérateurs de comparaisons sont définis quand ils ont un

ét
sens :
— 1 < 2.5 vaut True , mais 1 < [2,3] est une erreur ;
— 'albatros' < 'zoo' vaut True , mais 'ab' < ['a','c'] est une erreur.
Comme on le voit dans le deuxième item ci-dessus, la comparaison d’itérables du même
type se fait selon l’ordre lexicographique. C’est-à-dire qu’on compare les éléments de l’ité-
m
rable deux à deux dans l’odre jusqu’à en trouver deux différents (s’il ne sont pas compa-
rables, alors c’est une erreur) ou atteindre la fin d’une des itérations : 'albatros' < 'zoo' ,
car 'a' < 'z' , et 'zo' < 'zoo' car ils commencent par les mêmes éléments mais le pre-
o
mier est plus court (on dit que le premier est un préfixe du deuxième). On a [1,2] < [2,1]
qui vaut True car 1 < 2 , mais [1,2] < (2,1) ou [1,2] < ['a',1] sont des erreurs.
Il ne faut pas confondre les opérateurs == et is ou les opérateurs != et is not .
on

L’opérateur == indique (quand il est défini pour les deux opérandes en question) que les
valeurs de l’opérande gauche et l’opérande droite sont identiques. L’opérateur is indique
que l’objet à gauche est le même objet que l’objet à droite, au sens ou l’opérande gauche
référence le même emplacement mémoire que l’opérande droite. Le plus simple est de
l’expliquer avec trois variables x , y , z initialisées par :
Éc

1 x = [1,2] # on crée un nouvel objet liste [1,2] en mémoire, x référence cet objet
2 y = [1,2] # on crée un nouvel objet liste [1,2] en mémoire, y référence cet objet
3 z = x # z référence le même objet que x (correspond au même objet en mémoire)

on a alors :
— x == y qui vaut True ;
— x is y qui vaut False ;
L3

— x == z qui vaut True ;

— x is z qui vaut True ;
L’opérateur != est la négation de == et l’opérateur is not est la négation de is .

15.5 Les opérateurs in et not in

Le sens de l’opérateur in est que son opérande gauche est dans son opérande droite.
Par exemple, 'a' in ['a','b','c'] vaut True , mais 'd' in ['a','b','c'] vaut False .
L’opérateur not in est la négation de in .
 108 CHAPITRE 15. A. Tessier

Pour que x in y ait un sens, il faut que y dispose d’une méthode __contains__()
ou, à défaut, que y soit itérable.
Dans le cas où y a une méthode __contains__() , l’expression x in y est équivalente
à l’expression y.__contains__(x) . Par exemple, les chaînes de caractères disposent d’une
méthode __contains__() , y.__contains__(x) vaut True si la chaîne x est une sous-chaîne
de y . Par conséquent, l’expression 'bc' in 'abcd' vaut True , mais 'bd' in 'abcd' ou
'cb' in 'abcd' valent False . Notez que '' in y vaut True pour toute chaîne y .
Pour les listes, les tuples, les ensembles, les dictionnaires. . . , x in y a le sens naturel

e
de x est égal à un élément de y . Par exemple, 3 in [1,'a',3.0,8.5] vaut True , car
3 == 3.0 . En revanche, [1,2] in [1,2,3] vaut False , car la liste [1,2] n’est pas un
élément de la liste [1,2,3] .

ri
Nous allons définir un objet Intervalle(min,max) qui n’est pas itérable, mais dispose
d’une méthode __contains__() :

class Intervalle:

ét
1
2 def __init__(self, min, max):
3 self.min = min
4 self.max = max
5 def __contains__(self,x):
6 return self.min <= x <= self.max
m
L’expression 3.5 in Intervalle(1,9) vaut True , car on a 1 <= 3.5 et 3.5 <= 9 , mais
12 in Intervalle(1,9) vaut False . Par contre, 'bzk' in Intervalle(1,9) provoque une
erreur car 1 et 'bzk' ne sont pas comparables, mais 'bzk' in Intervalle('a','d') vaut
o
True , car 'a' <= 'bzk' et 'bzk' <= 'z' .
Dans le cas où y est un itérable qui n’a pas de méthode __contains__() , l’expression
x in y vaut True s’il y a au moins un élément z de y pour lequel y == z ou y is z .
on

Nous allons définir un objet Compteur(n) itérable (et utilisable une fois seulement) :

1 class Compteur:
2 def __init__(self, n):
3 self.cur = 0
4 self.max = n
def __iter__(self):
Éc

5
6 return self
7 def __next__(self):
8 self.cur += 1
9 if self.cur > self.max:
10 raise StopIteration
11 return self.cur

L’expression 3 in Compteur(9) vaut True , tout comme l’expression 3.0 in Compteur(9) ,

L3

mais l’expression 3.5 in Compteur(9) vaut False .

Vous comprendrez bien le fonctionnement de in en testant le code suivant

1 x = Compteur(6) # on définit un premier compteur x de 1 à 6

2 y = Compteur(6) # on définit un second compteur y de 1 à 6
3
4 # on lance le compteur x
5 for c in x:
6 print(c)
7
 15.5. LES OPÉRATEURS IN ET NOT IN 109

8 # on lance une deuxième fois le compteur x (qui n'est pas réutilisable)

9 for c in x:
10 print(c)
11
12 # on teste si 3 est un élément du compteur y
13 print(3 in y)
14
15 # on lance le compteur y
16 for c in y:
print(c)

e
17

ri
ét
o m
on
Éc
L3
110 CHAPITRE 15. A. Tessier

e
ri
ét
o m
on
Éc
L3
Chapitre 16

e
Les identificateurs

ri
Un identificateur est un nom qui sert comme référence pour un objet stocké en mé-
moire. Les identificateurs s’écrivent avec :

ét
— les lettres (avec ou sans accent et quel que soit l’alphabet) 1 ;
— les chiffres arabes ;
— le tiret bas _.
Un identicateur ne peut pas commencer par un chiffre arabe.
On distingue différentes manières d’écrire les identificateurs dans les langages de pro-
grammation :
1. minuscules_avec_tiret_bas
m
2. MAJUSCULES_AVEC_TIRET_BAS
o
3. Capitalises_Avec_Tiret_Bas
4. capitalisesVersion1
on

5. CapitalisesVersion2
En , on utilise de préférence la première : minuscules_avec_tiret_bas .
Certains identificateurs sont interdits, car il s’agit de mots réservés du langage :

False await else import pass

None break except in raise
Éc

True class finally is return

and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield

Le tiret bas _ au début d’un identificateur donne un sens particulier :

L3

— L’identicateur _ seul est utilisé de trois manières différentes :

1. dans une clause case _: d’une instruction match pour indiquer un attrape-tout
( _ est un filtre qui réussit toujours) ;
2. c’est une variable de l’interpète interactif qui contient la valeur de la dernière
évaluation au prompt ;
3. on l’utilise quand on ne souhaite pas donner un nom particulier à une variable,
par exemple for _ in range(3): print('python') .
1. De préférence, on n’utilise que les lettres de l’alphabet latin, sans accent.

111
112 CHAPITRE 16. A. Tessier

— Un identificateur qui commence par un unique _ dans un module un_module n’est

pas importé par l’instruction from un_module import * .
— Un identificateur qui commence par deux _ et termine par deux _ a un sens spécial
défini par la librairie standard. Vous ne devriez pas utiliser de tels identificateurs
en dehors de ceux définis dans la librairie standard, avec le sens attendu.
— Un identificateur qui commence par deux _, mais ne termine pas par deux _,
permet de simuler un nom privé dans une classe, puisque cette notion n’existe pas
en . En pratique, l’identificateur __un_ident de la classe une_classe sera
réécrit _une_classe__un_ident . Il s’agit d’un « affreux bricolage » pour pallier une

e
faiblesse de .

ri
ét
o m
on
Éc
L3
 Chapitre 17

e
Les instructions

ri
17.1 Les instructions simples

ét
17.1.1 L’évaluation d’expression
La plus simple des expression simples, est l’évaluation d’une expression.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1+1 est une instruction
m
elle consiste à évaluer l’expression 1+1 , mais rien n’est fait du résultat, cela n’a de sens
qu’en mode interactif
print(1) est une instruction
o
elle consiste à évaluer l’expression print(1) , c’est-à-dire appeler la fonction print avec
1 en argument, qui a pour effet d’afficher 1, rien n’est fait du résultat qui est d’ailleurs
la valeur None
on

17.1.2 L’affectation
C’est instruction consiste à lier un identificateur à un objet en mémoire. Si l’identi-
ficateur référençait déjà un autre objet, alors sa valeur est modifiée pour qu’il référence
Éc

le nouvel objet. Elle s’écrit x = e , où e est une expression qui sera évaluée et x est
l’identificateur qui référencera la valeur de l’expression e .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
x = 1+1 est une instruction
elle consiste à évaluer l’expression 1+1 , puis x référence cette valeur, ici 2
L3

17.1.3 L’instruction pass

Cette instruction ne fait rien, mais est utile partout où une instruction est obligatoire.
Par exemple, je veux définir une fonction f qui a un paramètre x , mais qui ne fait
rien pour le moment, car j’écrirai le code plus tard.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def f(x):
2 pass

113
 114 CHAPITRE 17. A. Tessier

17.1.4 L’instruction del

Cette instruction sert à supprimer des éléments. Sa forme générale est del e1, e2, ..., eN ,
où les eI sont des cibles.
Si eI est un identificateur, cela retire l’identificateur de l’espace de noms auquel il
appartient. Si eI est la sélection d’un élément d’un itérable qui supporte la suppression
d’élément, alors l’élément est supprimé. Si eI est une tranche d’un itérable qui supporte
la suppression de tranche, alors la tranche est supprimé.

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

x = 1

ri
1

2 del x

après ce code, x n’est pas défini, l’expression x provoque l’erreur : NameError: name
’x’ is not defined

ét
1 x = list(range(10))
2 del x[2:7:2]
3 del x[1]

après la première instruction, x vaut [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] m

après la deuxième instruction, x vaut [0, 1, 3, 5, 7, 8, 9]
après la troisième instruction, x vaut [0, 3, 5, 7, 8, 9]
o
De la même manière que permet d’ajouter dynamiquement un attribut à un
objet, l’instruction del peut détuire un attribut. Normalement, un langage orienté objet
ne permet pas de faire cela. Il est fortement déconseillé de le faire si vous ne comprenez
on

pas exactement ce que vous faites et toutes les conséquences que cela entraîne.

17.1.5 L’instruction break

L’instruction break , à l’intérieur d’une boucle ( while ou for ), termine la boucle à
laquelle elle appartient, sans exécuter l’éventuelle clause else de la boucle.
Éc

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = [4, 2, 3, 1, 3, 5]
2 y = []
3 for i in x:
4 if i == 3:
L3

5 break
6 y.append(i)
7 else:
8 y.append('FIN')

si 3 n’est pas élément de x , recopie les éléments de x dans la liste y et ajoute 'FIN'
à la fin
si 3 est élément de x , recopie tous les éléments de x qui précèdent le premier 3 dans
la liste y
après le code, y vaut [4, 2]
 17.1. LES INSTRUCTIONS SIMPLES 115

17.1.6 L’instruction continue

L’instruction continue , à l’intérieur d’une boucle ( while ou for ), fait passer direc-
tement au tour de boucle suivant.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 x = [4, 2, 3, 1, 3, 5]
2 y = []
for i in x:

e
3
4 if i == 3:
5 continue
y.append(i)

ri
6
7 else:
8 y.append('FIN')

recopie tous les éléments de x , sauf les 3 , dans la liste y et ajoute 'FIN' à la fin

ét
après le code, y vaut [4, 2, 1, 5, 'FIN']

17.1.7 L’instruction return

L’instruction return e s’utilise dans une fonction (ou une méthode). Elle a deux effets,
— elle met fin à l’exécution du code de la fonction ;
m
— elle indique la valeur de retour de la fonction qui est la valeur de e , ou None s’il
n’y a pas d’expression e précisée derrière return .
o
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
on

1 def f(x):
2 return x + 1

f est la fonction qui retourne son argument + 1

Éc

17.1.8 L’instruction yield

Cette instruction yield e s’utilise dans une fonction (ou une méthode) génératrice
qui sera alors utilisée comme un itérateur. Elle a deux effets,
— elle suspend l’exécution du code de la fonction, qui reprendra après ce point au
moment de produire la valeur suivante de l’itération ;
— elle indique la valeur produite par la fonction génératrice qui est la valeur de e .
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def f(x):
2 while 0 < x:
3 yield x
4 x -= 1
5
6 y = []
7 for i in f(3):
8 y.append(i)
 116 CHAPITRE 17. A. Tessier

l’itérateur créé par f(3) va produire les valeurs 3 , puis 2 , puis 1

après le code, y vaut [3, 2, 1]

17.1.9 L’instruction global

Cette instruction global x s’utilise dans une fonction (ou une méthode, ou une classe)
pour pouvoir ensuite modifier la valeur d’une variable globale x .

e
17.1.10 L’instruction nonlocal

ri
Cette instruction nonlocal x s’utilise dans une fonction imbriquée (ou une méthode
imbriquée, ou une classe imbriquée) pour pouvoir ensuite modifier la valeur de la variable
locale x de la fonction (ou la méthode, ou la classe) dans laquelle elle est imbriquée.

ét
17.1.11 L’instruction import
L’instruction import a cinq formes :
— import un_module qui crée un identificateur un_module référençant le module un_module ;
— import un_module as mm qui crée un identificateur mm référençant le module un_module ;
— from un_module import un_objet qui crée un identificateur un_objet référençant
l’objet un_module.un_objet ;
m
— from un_module import * qui pour chaque objet du module crée un identificateur
o
de même nom qui référence l’objet en question ;
— from un_module import un_objet() as obj qui crée un identificateur obj qui réfé-
rence l’objet un_module.un_objet .
on

17.1.12 L’instruction raise

Dans l’instruction raise e , l’expression e est une instance de BaseException pour
les exceptions prédéfinies ou une instance de Exception pour les autres. Elle a pour effet
de lever l’exception e . S’il n’y a pas d’expression e , l’exception courante est propagée,
Éc

et s’il n’y a pas d’exception courante, c’est l’exception RuntimeError qui est levée.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 def f(x):
2 if type(x) != int:
raise Exception('il faut une valeur entière')
L3

4 return x + 1
5
6 y = f(3)
7 z = f(3.5)

le code s’arrête sur l’instruction ligne 7 avec l’erreur : Exception: il faut une valeur
entière
après le code, y vaut 4, mais z n’est pas définie

La section 17.2.8 donne la hiérarchie des types exceptions.

17.2. LES INSTRUCTIONS COMPOSÉES 117

17.1.13 L’instruction assert

L’instruction assert permet d’insérer des tests pendant la mise au point du code.
Les instructions assert présentent l’avantage de rester dans le code mais elles peuvent
être désactivées au lancement du code si on le souhaite. C’est contrôlé par la variable
__debug__ , si elle est vraie, les assertions sont activées, sinon elles sont désactivées.
Il existe deux formes pour cette instruction.
assert e
si l’expression e est équivalente à True , l’instruction assert ne fait rien, sinon,

e
elle lève une exception AssertionError .
L’instruction est équivalente au code

ri
1 if __debug__:
2 if not e: raise AssertionError

ét
assert e, x
si l’expression e est équivalente à True , l’instruction assert ne fait rien, sinon,
elle lève une exception AssertionError(x) .
L’instruction est équivalente au code

1
2
if __debug__:
if not e: raise AssertionError(x)
o m
17.2 Les instructions composées
on

Une instruction composée est une instruction qui contient d’autres instructions qui
peuvent être des instructions simples ou elles-mêmes composées. L’instruction composée
est consitutée d’une ou plusieurs clauses. Chaque clause commence par un en-tête (qui
débute par un mot clé et se termine par : ) et est suivi d’un corps composé d’une suite
d’une ou plusieurs instructions (le corps ne peut pas être vide, on peut utiliser l’instruction
pass si besoin). Toutes les en-têtes d’une instruction composée ont la même indentation.
Éc

Toutes les instructions du corps d’une clause ont la même indentation qui est supérieure
à l’indentation de l’en-tête de la clause. La forme générale d’une clause d’une instruction
composée est

mot_clé · · · : en-tête
L3

instruction_1 clause
.
. corps
.
instruction_n

Exceptionnellement, dans le cas où le corps ne contient que des instructions simples et

si cela améliore la lisibilité, les instructions peuvent être sur la même ligne à la suite de
l’en-tête et séparées par des points-virgules.

mot_clé · · · : instruction_1 ; · · · ; instruction_n

 118 CHAPITRE 17. A. Tessier

17.2.1 L’instruction if
Elle commence par une clause if , suivie éventuellement de clauses elif et d’une
éventuelle clause else .
L’en-tête d’une clause if est if e: . Si l’expression e est équivalente à True , le corps
de la clause est exécutée et l’instruction if est terminée. Sinon, l’exécution se poursuit
par la clause suivante.
L’en-tête d’une clause elif est elif e: . Si l’expression e est équivalente à True ,
le corps de la clause est exécutée et l’instruction if est terminée. Sinon, l’exécution se

e
poursuit par la clause suivante.
L’en-tête d’une clause else est else: . Le corps de la clause est exécutée et l’instruc-
tion if est terminée.

ri
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
supposons l’existance d’une variable x

ét
1 if x == 1:
2 y = 'x vaut 1'
3 elif x == 2:
4 y = 'x vaut 2'
5 elif x == 3:
6 y = 'x vaut 3'
7

8
else:
y = 'x ne vaut ni 1, ni 2, ni 3'
o m
17.2.2 L’instruction match
Le fonctionnement de l’instruction match faisant appel aux notions de filtrage qui ne
on

sont pas présentées ici, nous n’en donnons qu’une version simplifiée où il s’agit de filtrer
seulement sur la valeur d’une expression.
Elle ne contient qu’une clause match dont le corps (qui ne peut être vide) est composé
uniquement de clauses case .
L’en-tête de la clause match est match e: . L’en-tête de la clause case est case e1 | e2 | ... | eN:
Éc

ou case _: . L’expression e est évaluée, puis les clauses case sont examinées dans l’ordre.
Le corps de la première clause case qui contient une expression eI égale à e est exé-
cutée, on dit que la clause case a réussi, et l’instruction match est terminée. La clause
case _: est particulière puisqu’elle réussit toujours quel que soit la valeur de e . On
l’appelle l’attrape-tout. Si elle est présente, elle est logiquement la dernière, puisque les
suivantes ne serviraient à rien.
L3

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
supposons l’existance d’une variable x

1 match x:
2 case 1:
3 y = 'x vaut 1'
4 case 2 | 3:
5 y = 'x vaut 2 ou 3'
6 case _:
7 y = 'x ne vaut ni 1, ni 2, ni 3'
 17.2. LES INSTRUCTIONS COMPOSÉES 119

17.2.3 L’instruction while

Elle commence par une clause while , suivie d’une éventuelle clause else .
L’en-tête de la clause while est while e: . Si l’expression e est équivalente à True ,
le corps de la clause est exécutée puis l’instruction while est à nouveau exécutée. Sinon,
l’éventuelle clause else est exécutée, puis l’instruction while est terminée.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

e
1 x = 5
2 y = []
while 1 <= x:

ri
3
4 y.append(x)
5 x -= 1
6 else:
7 y.append(0)

ét
après ce code, x vaut 0 et y vaut [5, 4, 3, 2, 1, 0]

L’exécution de l’instruction break dans le corps de la clause while , termine immé-

diatement l’instruction while sans exécuter la clause else si elle est présente. m
L’exécution de l’instruction continue dans le corps de la clause while , termine im-
médiatement l’exécution de la corps de la clause while , puis l’instruction while est à
nouveau exécutée.
o
17.2.4 L’instruction for
on

Elle commence par une clause for , suivie d’une éventuelle clause else .
L’en-tête de la clause for est for x1, x2, ..., xN in e: , où les xI sont des va-
riables. L’expression e est un itérateur, un générateur ou un itérable. Dans tous les cas,
l’expression e est évaluée pour produire un itérateur. L’itérateur produit une itération,
c’est-à-dire des valeurs les unes après les autres. Pour chaque valeur de cette itération :
Éc

1. elle est affectée au tuple x1, x2, ..., xN . Si le tuple n’a qu’une seule variable x1 ,
la valeur est affectée à x1 . S’il a N variables x1, x2, ..., xN , la valeur doit être
elle même un itérable qui contient exactement N éléments qui sont affectés, dans
l’ordre, aux variables x1, x2, ..., xN .
2. Le corps de la clause for est exécutée.
L3

Quand l’itérateur ne produit plus de valeur, la clause else , si elle est présente, est exé-
cutée.
L’exécution de l’instruction break dans le corps de la clause for , termine immédia-
tement l’instruction for , sans exécuter la clause else si elle est présente.
L’exécution de l’instruction continue dans le corps de la clause for , termine immé-
diatement l’exécution de la corps de la clause for , puis passe à la valeur suivante produite
par l’itérateur.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 120 CHAPITRE 17. A. Tessier

1 frigo = [['pommes', 8], ['poires', 2], ['prunes', -2], ['abricots', 4]]

2 resultat = ''
3 for fruit, stock in frigo:
4 if stock < 0:
5 resultat = 'erreur, il y a un stock négatif !'
6 break
7 resultat += f'il y a {stock} {fruit}\n'
8 else:
9 resultat += 'et c\'est tout'

e
après ce code, fruit vaut 'prunes' , stock vaut -2 et resultat contient le texte

ri
erreur, il y a un stock négatif !

si on change la première ligne par

frigo = [['pommes', 8], ['poires', 2], ['abricots', 4]]

ét
1

après le code, fruit vaut 'abricots' , stock vaut 4 et resultat contient le texte

il y a 8 pommes
il y a 2 poires
il y a 4 abricots
et c'est tout
o m
17.2.5 L’instruction def
L’instruction def permet de définir une fonction référencée par un identificateur.
on

Elle ne contient qu’une clause def , dont la forme la plus simple de l’en-tête est
def f(x1, x2, ..., xN): .
L’identificateur (le nom) de la fonction est f . Les identificateurs des paramètres sont
les xI . Il est possible de donner une valeur par défaut dI à un paramètre xI en le
remplaçant dans l’en-tête par xI=dI .
L’évaluation d’une expression f(e1, e2, ..., eN) consiste à exécuter le corps de la
Éc

clause def , avec, dans l’espace de nommage de la fonction, les identificateurs xI qui ont
comme valeurs les eI . Les eI sont appelés les arguments de la fonction. Il est possible
de nommer les arguments avec le nom du paramètre qui correspond. Dans ce cas, on écrit
xI=eI à la place de eI et l’on peut changer l’ordre des arguments. Attention, dans ce cas,
les arguments avant le premier argument nommé et ceux après le dernier argument nommé
seront donnés dans l’ordre, tous les autres arguments seront obligatoirement nommés.
L3

Si l’on souhaite comme argument pour un paramètre xI la valeur par défaut dI ,

il suffit de ne pas préciser l’argument. Attention, dans ce cas, les arguments avant le
premier argument non donné et ceux après le dernier argument non donné seront donnés
dans l’ordre, tous les autres arguments donnés seront obligatoirement nommés.
L’instruction return dans le corps de la fonction termine l’exécution du corps. Si
elle précise une epxression : return e , alors la valeur de e est la valeur de retour de la
fonction. Sinon c’est la valeur None qui est retournée.
Une instruction return n’est pas obligatoire à la fin du corps de la fonction, car, si
elle n’est pas présente, elle est ajoutée automatiquement.
Il est possible d’utiliser également l’instruction yield dans le corps de la fonction qui
 17.2. LES INSTRUCTIONS COMPOSÉES 121

devient alors une fonction génératrice qui pourra être utilisée comme un itérable.
On peut également
— faire précéder l’instruction def de décorateurs @e ;
— insérer des paramètres de type entre l’identificateur de la fonction et la liste des
paramètres ;
— utiliser les symboles spéciaux / ou * dans la liste des paramètres pour délimiter les
paramètres par position avant / , par position ou nommés entre / et * , nommés
après * ;
— utiliser les opérateurs de déballage * et ** sur les identificateurs de paramètres ;

e
— ajouter une annotation de type pour les paramètres, xI:typeI pour dire que le
paramètre xI est de type typeI , mais c’est malheureusement de l’ordre du com-

ri
mentaire ;
— ajouter une annotation de type ->typeF après la liste des paramètres pour indiquer
que la valeur de retour est de type typeF , mais c’est malheureusement de l’ordre
du commentaire.

ét
Tout cela dépasse le cadre de ce cours.

17.2.6 L’instruction with

L’instruction with permet d’encapsuler, par un gestionnaire de contexte, l’exécutionm
d’instructions. Elle offre un mécanisme qui simplifie la gestion de l’entrée et de la sortie
du contexte.
Elle ne contient qu’une clause with , dont l’en-tête est de la forme with e1 as x1, e2 as x2,... eN as
Remarquez, que c’est équivalent à
o
1 with e1 as x1:
with e2 as x2:
on

2
3 ...
4 with eN as xN:

Les eI sont des expressions de contexte, dont l’évaluation donne un gestionnaire de

contexte. Les as xI sont optionnels, mais le plus souvent présents. S’ils sont présents, les
xI sont des identificateurs qui référencent les valeurs des eI .
Éc

Voici un exemple simple d’utilisation pour gérer correctement la fermeture d’un fichier,
même si des erreurs d’entrée-sortie se produisent.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 fic = open('mon_fichier.txt', 'wt') # ouverture du fichier en mode création

2 fic.write('Ceci est un test.') # écriture d'une ligne dans le fichier
L3

3 fic.close() # fermeture du fichier

si l’instruction fic.write('Ceci est un test.') provoque une erreur, l’interprète

peut garder un contexte fic mal fermé

1 fic = open('mon_fichier.txt', 'wt') # ouverture du fichier en mode création

2 with fic: # gère proprement la fermeture du fichier
3 fic.write('Ceci est un test.')

ou de manière plus synthétique

 122 CHAPITRE 17. A. Tessier

1 with open('mon_fichier.txt', 'wt') as fic:

2 fic.write('Ceci est un test.')

Avec l’instruction with le fichier sera proprement « fermé », c’est-à-dire qu’on sortira
proprement du contexte, mais si des erreurs se sont produites. On pourrait obtenir le
même résultat avec une instruction try .

e
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

fic = open('mon_fichier.txt', 'wt')

ri
1
2 try:
3 fic.write('Ceci est un test.')
4 finally:
5 fic.close()

ét
17.2.7 L’instruction class
L’instruction class permet de définir une classe référencée par un identificateur. Pour
, cela définit un nouveau type.
m
L’instruction class ne contient qu’une clause class , dont la forme la plus simple de
l’en-tête est class x: class x(e1, e2, ..., eN): .
Dans l’en-tête, x est l’identificateur (le nom) de la classe, les eI sont les classes dont
o
elle hérite.
La classe object est mère de toutes les classes. l’en-tête class x: est équivalente à
l’en-tête class x(object): .
on

Comme pour l’en-tête d’une clause def , l’en-tête class x(e1, e2, ..., eN): peut être
précédée de décorateurs et on peut insérer des paramètres de type entre l’identicateur de
classe et la liste des classe dont elle hérite. Mais on n’aborde pas ces notions plus complexes
ici.
Éc

17.2.8 L’instruction try

L’instruction try permet de capturer et traiter les exceptions.
Elle commence par une clause try , suivie éventuellement de clauses except , d’une
éventuelle clause else , d’une éventuelle clause finally . Au moins une clause except ou
la clause finally doit être présente. La clause else n’est possible que s’il y a au moins
une clause except .
L3

L’en-tête d’une clause try est try: .

L’en-tête d’une clause except est except: ou except E as e: , où E est une expression
(qui correspond à un type d’exception) et e est un identificateur (auquel sera affecté
l’exception). Une clause except: capture toutes les exceptions. Une clause except E as e:
capture les exception de type E ou d’une classe fille de E .
L’en-tête d’une clause else est else: .
L’en-tête d’une clause finally est finally: .
Le fonctionnement de l’instruction try est le suivant. Le corps de la clause try est
exécuté.
17.2. LES INSTRUCTIONS COMPOSÉES 123

— Si l’exécution n’a levé aucune exception, la clause else est exécutée† si elle est
présente, puis la clause finally si elle est présente, puis l’instruction try est
terminée.
— Si l’exécution a levé une exception
— si des clauses except sont présentes et l’une au moins capture l’exception, le
corps de la première clause except qui capture l’exception est exécutée, puis
la clause finally si elle est présente, puis l’instruction try est terminée
— sinon, la clause finally est exécutée, puis l’instruction try est terminée

e
†
Si le corps de la clause try s’est terminé par une instruction break , continue ou return
(l’instruction try est dans une boucle ou une définion de fonction ou méthode) alors la
clause else n’est pas exécutée. Notez que la clause finally est toujours exécutée, même

ri
si un exception est levée, même si une instruction break , continue ou return est exécutée
dans le corps de la la clause try .
La classe mère de toutes les exceptions est BaseException . La hiérarchie des exceptions
est la suivante :

ét
BaseException
— BaseExceptionGroup
— GeneratorExit
— KeyboardInterrupt
— SystemExit
— Exception
— ArithmeticError
m
— FloatingPointError
o
— OverflowError
— ZeroDivisionError
— AssertionError
on

— AttributeError
— BufferError
— EOFError
— ExceptionGroup [BaseExceptionGroup]
— ImportError
— ModuleNotFoundError
Éc

— LookupError
— IndexError
— KeyError
— MemoryError
— NameError
— UnboundLocalError
L3

— OSError
— BlockingIOError
— ChildProcessError
— ConnectionError
— BrokenPipeError
— ConnectionAbortedError
— ConnectionRefusedError
— ConnectionResetError
— FileExistsError
— FileNotFoundError
124 CHAPITRE 17. A. Tessier

— InterruptedError
— IsADirectoryError
— NotADirectoryError
— PermissionError
— ProcessLookupError
— TimeoutError
— ReferenceError
— RuntimeError
— NotImplementedError

e
— RecursionError
— StopAsyncIteration

ri
— StopIteration
— SyntaxError
— IndentationError
— TabError

ét
— SystemError
— TypeError
— ValueError
— UnicodeError
— UnicodeDecodeError m
— UnicodeEncodeError
— UnicodeTranslateError
— Warning
— BytesWarning
o
— DeprecationWarning
— EncodingWarning
— FutureWarning
on

— ImportWarning
— PendingDeprecationWarning
— ResourceWarning
— RuntimeWarning
— SyntaxWarning
Éc

— UnicodeWarning
— UserWarning
L3
Chapitre 18

e
Les fonctions prédéfinies

ri
Il existe quelques fonctions prédéfinies en . On donne les principales, en se li-
mitant à leur plus simple utilisation, certaines fonctions peuvent également être utilisées

ét
avec d’autres paramètres que ceux indiqués.
Elles sont regroupées par thématique.

18.1 La fonction d’aide m

help(x)
retourne une aide relative à x . Cette fonction n’a d’intérêt qu’au prompt en mode
interactif, par exemple dans la console .
o
Essayez par exemple help(sorted) .

18.2 Les fonctions numériques

on

abs(x) où x est un nombre

retourne la valeur absolue de x : | x |.
abs(-3.5) retourne 3.5 .
divmod(x, y) où x et x sont entier ou réel
Éc

retourne le couple (x // y, x % y) .
divmod(25, 3) retourne (8, 1) .
pow(x, y) où x et x sont des nombres
retourne x à la puissance y (équivalent à x ** y) ).
pow(2, 3) retourne 8 .
round(x) où x est entier ou réel
L3

retourne x arrondi à l’entier le plus proche. round(-3.6) retourne round(-4) ;

round(x, n) où x et est entier ou réel et n est entier
retourne le nombre x arrondi à n chiffres après la virgule. round(3.14159,2)
retourne round(3.14) ;
sum(x) où x est un itérable contenant des nombres
retourne la somme des éléments de x .
sum([2, 4, 5]) retourne 11 .
Les deux fonctions suivantes ne se limitent pas aux nombres, mais sont le plus souvent
utilisées avec des entiers ou des réels.

125
126 CHAPITRE 18. A. Tessier

max(x1, x2, ..., xN) (peut s’utiliser avec un nombre quelconques d’arguments, au
moins deux) les arguments doivent être comparables entre eux
retourne le plus grand des arguments.
max(5.7, 4.8) retourne 5.7 .
min(x,y) (peut s’utiliser avec un nombre quelconques d’arguments, au moins deux)
les arguments doivent être comparables entre eux
retourne le plus petit des arguments.
min(5.7, 4.8) retourne 4.8 .

e
Les deux fonctions suivantes permettent la conversion entre entier et caractère selon
le codage unicode.

ri
chr(x) où x est entier
retourne la chaîne de un caractère qui contient le caractère de code unicode x .
chr(8364) retourne '€' .
ord(x) où x est une chaîne de un caractère

ét
retourne le code unicode du caractère x .
ord('€') retourne 8364 .

18.3 Les fonctions constructeurs d’objets

m
Il s’agit des fonctions, qui permettent de construire un objet instance d’une classe en
utilisant le nom du type. En effet, chaque classe dispose d’une fonction qui a le même
o
nom que la classe et qui permet de construire une instance de la classe en fonction de
certains paramètres.
Nous présentons ici les constructeurs des types prédéfinis.
on

object()
retourne l’objet vide.
Assez peu utile, si ce n’est que la classe object est la classe parente de toutes les
autres classes !
bool()
Éc

retourne la valeur False .

bool(x)
retourne la valeur False si x est
— None
— le nombre 0, quelque soit sa forme : 0 , 0.0 , 0j , . . .
— un séquence ou collection vide : '' , [] , () , {} , range(0) . . .
L3

et retourne True pour toutes les autres valeurs de x .

bool(0.0) retourne False .
int()
retourne l’entier 0 .
int(x) où x est un entier, un réel ou une chaîne de caractères
retourne l’entier qui correspond à x .
int(-3.8) retourne -3 . int(' 250 \n') retourne 250 .
float()
retourne 0.0 .
18.3. LES FONCTIONS CONSTRUCTEURS D’OBJETS 127

float(x) où x est un entier, un réel ou une chaîne de caractères

retourne le réel qui correspond à x .
float(3) retourne float(3.0) .
float('-3.5e+2') retourne -350 .
complex()
retourne le complexe 0j .
complex(x) où x est un entier, un réel, un complexe ou une chaîne de caractères
retourne le complexe qui correspond à x .

e
complex(3.5) retourne (3.5+0j) .
complex(' -1.5+7j\n') retourne (-1.5+7j) .

ri
complex(x, y) où x et y sont entiers ou réels
retourne le complexe x + yj .
complex(-1.5,7) retourne (-1.5 + 7j) .

ét
str()
retourne la chaîne de caractères vide '' .
str(x)
retourne la transformation en chaîne de caractères de l’objet x . C’est généralement
la valeur de repr(x) (sauf si x est déjà une chaîne).
str(1.25e-2) retourne '0.0125' .
range(y) où y est un entier
m
retourne l’intervalle qui va de 0 à y exclus.
o
range(6) correspond à l’intervalle d’entiers [[0; 6[[, c’est-à-dire [[0; 5]].

range(x, y) où x et y sont des entiers

on

retourne l’intervalle qui va de x à y exclus.

range(3, 6) correspond à l’intervalle d’entiers [[3; 6[[, c’est-à-dire [[3; 5[[.

range(x, y, z) où x , y et z sont des entiers

retourne l’intervalle qui va de x à y exclus par pas de z . range(3, 6, 2) cor-
respond à l’intervalle qui contient les entiers 3 et 5. range(6, 3, -1) correspond à
Éc

l’intervalle qui contient dans l’ordre les entiers 6, 5 et 4.

list()
retourne une liste vide [] .
list(x) où x est un itérable
retourne une liste construite à partir des éléments de x .
liste('DÉG') retourne ['D', 'É', 'G'] .
L3

tuple()
retourne le tuple vide () .
tuple(x) où x est un itérable
retourne un tuple construit à partir des éléments de l’itérable x .
tuple(['D', 'É', 'G'] retourne ('D', 'É', 'G') .

slice(y) où y est un entier

retourne un objet représentant une tranche qui va de 0 à y exclu. w[slice(y)]
est équivalent à w[:y] .
128 CHAPITRE 18. A. Tessier

slice(x, y) où x et y sont entier

retourne un objet représentant une tranche qui va de x à y exclu. w[slice(x, y)]
est équivalent à w[x:y] .
slice(x, y, z) où x , y et z sont entier
retourne un objet représentant une tranche qui va de x à y exclu par pas de z .
w[slice(x, y, z)] est équivalent à w[x:y:z] .
(6,5,3,8,2,1,4)[slice(4,1,-1)] vaut le tuple (2, 8, 3) .

e
dict()
retourne un dictionnaire vide {} .

ri
dict(x) où x est une liste de couples (clé, valeur)
retourne un nouveau dictionnaire construit à partir de x .
dict([('x', 1), ('y', 2)]) retourne le dictionnaire {'x': 1, 'y': 2} .

frozenset()

ét
retourne l’ensemble non modifiable vide ∅.
frozenset(x) où x est un itérable
retourne un nouvel ensemble (non modifiable) construit à partir des éléments de
x.
frozenset([3, -2, 5]) retourne l’ensemble non modifiable frozenset({3, 5, -2}) .
m
Notez qu’il n’y a pas d’ordre pour les éléments d’un ensemble.
set()
retourne l’ensemble vide ∅.
o
set(x) où x est itérable
retourne l’ensemble des éléments de x .
on

set([3, -2, 5]) retourne l’ensemble {3, 5, -2} . Notez qu’il n’y a pas d’ordre
pour les éléments d’un ensemble.
type(x)
retourne un objet type qui représente le type (la classe) de x .
type(3.2) retourne float .
Éc

super(x)
retourne un objet mandataire qui délègue les appels de méthodes à la classe parent
de x . Cela permet, d’accéder à des méthodes héritées qui ont été remplacées.
Les deux fonctions suivantes ne sont pas constructeurs d’objets mais permettent de
savoir, pour la première, si un objet est instance d’une classe et, pour la deuxième, si une
classe est une sous-classe d’une autre classe.
L3

isinstance(x, y) où y est une classe ou un tuple de classes ou une union de classes

retourne un booléen qui indique si l’objet x est une instance de la classe y ou
d’une classe fille de y (ou d’une des classes du tuple y ou de l’union de classes
y ).
isinstance(12, int) retourne True .
isinstance(12.0, int) retourne False
isinstance([1, 2, 3], list) retourne True
isinstance(12.0, (list, float, int)) retourne True
isinstance(12.0, list | float | int)) retourne True .
18.4. LES FONCTIONS SUR LES ITÉRABLES 129

issubclass(x,y) où y est une classe ou un tuple de classes ou une union de classes

retourne un booléen qui indique si la classe x est une classe fille de y (ou d’une
des classes du tuple y ou d’une de l’union de classes y ).
issubclass(float, object) retourne True .

18.4 Les fonctions sur les itérables

e
max(x) où x est un itérable
retourne le (premier) plus grand élément de x ou provoque une erreur si les élé-
ments ne sont pas tous comparables entre eux.

ri
max([2, -3, 1]) retourne 2 .

min(x) où x est un itérable

retourne le (premier) plus petit élément de x ou provoque une erreur si les éléments
ne sont pas tous comparables entre eux.

ét
min([2, -3, 1]) retourne -3 .

all(x) où x est un itérable

retourne False si au moins un élément de x est équivalent à False .
all([1,2.2,'abc']) retourne True , mais all([1,0.0,'abc']) retourne False .
m
any(x) où x est un itérable
retourne True si au moins un élément de x est équivalent à True .
any((0,0.0,False)) retourne False , tout comme any({}) .
o
sum(x) où x est un itérable contenant des nombres
retourne la somme des éléments de x .
sum([2, 4, 5]) retourne 11 .
on

sorted(x) où x est un itérable dont tous les éléments sont comparables

retourne la liste des éléments de x triés en ordre croissant.
La valeur True pour le paramètre optionnel reverse indique l’ordre décroissant.
sorted({2, -3, 1}) retourne [-3, 1, 2] . sorted([2, -3, 1], reverse=True) retourne
[2, 1, -3] .
Éc

Les fonctions suivantes retournent un itérateur.

iter(x) où x est un itérable

retourne un itérateur des éléments de x .
iter([2, -3, 1]) retourne un itérateur qui produira l’itération 2 , -3 , 1 .

reversed(x) où x est un itérable

L3

retourne un itérateur à l’envers, du dernier au premier élément de x . x doit être

inversable (chaîne de caractères, liste, tuple, dictionnaire. . . ).
reverse([2, -3, 1]) retourne l’itérateur qui produira l’itération 1 , -3 , 2 .

filter(f, x) où f est une fonction et x un itérable

retourne un itérateur des éléments e de l’itérable x pour lesquels f(e) retourne
True .

1 def pair(x):
2 return x % 2 == 0
130 CHAPITRE 18. A. Tessier

filter(pair, [12, 6, 5, -7, 2])retourne un itérateur qui produira l’itération 12 ,

6 et 2 . filter(lambda x: x % 2 == 0, [12, 6, 5, -7, 2]) retourne un itérateur
qui produira la même itération.
map(f, x) où f est une fonction et x un itérable
retourne un itérateur des f(e) pour tous les éléments e de x .
map(abs, [2, -3, 1]) retourne un itérateur qui produira l’itération 2 , 3 et 1
map(lambda x : 2 * x, [2, -3, 1]) retourne un itérateur qui produira l’itération
4 , -6 et 2 .

e
enumerate(x) où x est un itérable
retourne un itérateur des couples (position, valeur) des éléments de x .

ri
enumerate('DÉG') retourne un itérateur qui produira l’itération (0, 'D') , (1, 'É') ,
(2, 'G') .
enumerate(x, y) où x est un itérable et y un entier
retourne un itérateur des couples (position, valeur) des éléments de x en les indi-

ét
çant à partir de y .
enumerate('DÉG', 7) retourne un itérateur qui produira l’itération (7, 'D') , (8, 'É') ,
(9, 'G') .
zip(x1, x2, ..., xN) (peut s’utiliser avec un nombre quelconque d’arguments) où les
arguments sont des itérables
m
retourne un itérateur dont les éléments sont des tuples constitués d’un élément de
chaque itérable. L’itérateur s’arrête à la fin de l’itérable le plus court.
zip('abcd', (-1, -2, -3), range(100)) retourne un itérateur qui produira l’itéra-
o
tion ('a', -1, 0) , ('b', -2, 1) , ('c', -3, 2) .
La fonction suivante, n’est pas une fonction sur un itérable, mais une fonction sur un
on

itérateur.
next(x) où x est un itérateur
retourne l’élément suivant de l’itérateur x .
Si x = iter([2, -3, 1]) , la première fois next(x) retourne 2 , la fois suivante
next(x) retourne -3 , la troisième fois next(x) retourne 1 et les fois suivantes,
Éc

next(x) est une erreur : StopIteration.

18.5 Les fonctions sur les conteneurs

len(x) où x est un conteneur (comme une chaîne de caractère, une liste, un tuple,
un intervalle, un dictionnaire, un ensemble. . . )
L3

retourne le nombre d’éléments de x .

len('DÉG') retourne 3 .
len([4, 5]) retourne 2 .

18.6 Les fonctions d’entrée-sortie

input()
attend un entrée sur l’entrée standard (le clavier, dans la console de ) et
retourne la chaîne de caractères qui correspond à cette entrée.
18.7. LES FONCTIONS EN LIEN AVEC LES ATTRIBUTS D’OBJETS 131

x = input() , va attendre une entrée au clavier. Si l’utilsateur tape python<Entrée>,

alors la variable x aura la valeur 'python' .
input(x)
affiche x sur la sortie standard (l’écran, dans la console de ), puis attend
un entrée sur l’entrée standard (le clavier, dans la console de ) et retourne
la chaîne de caractères qui correspond à cette entrée.
print(x1, x2, ..., xN) (peut s’utiliser avec un nombre quelconque d’arguments)
affiche les chaînes str(x1) à str(xN) , séparées par un espace et suivies d’un pas-

e
sage à la ligne sur la sortie standard (l’écran, dans la console de ).
On peut aussi donner des valeurs pour les paramètres supplémentaires sep , end
et file :

ri
— sep est la chaîne de caractères qui sépare les valeurs ;
— end est la chaîne de caractères de fin ;
— file est un objet fichier texte ouvert en écriture.
Sans paramètre, print() produit un simple passage à la ligne.

ét
print('1+1 =', 1+1, '!') affiche à l’écran 1+1 = 2 ! et passe à la ligne
print(1, 2, 3, sep='xx', end='yy') affiche à l’écran 1xx2xx3yy sans passer à la
ligne.
open(x, y) où x et y sont des chaînes de caractères
retourne un objet fichier qui correspond au fichier nommé x ouvert avec le mode
m
y . Il existe des paramètres supplémentaires qu’on ne décrit pas ici. Le mode est
une chaîne de caractères dont les caractères ont la signification suivante :
caractère signification
o
'r' ouverture en lecture (échoue si le fichier n’existe pas)
'w' ouverture en écriture (écrase le fichier s’il existe déjà)
on

'x' ouverture en écriture (échoue si le fichier existe déjà)

'a' ouverture en ajout (crée le fichier s’il n’existe pas)
'+' ouverture en lecture et écriture
'b' ouverture en mode binaire
't' ouverture en mode texte
open('fichier.txt', 'rt') retourne un objet fichier pour le fichier texte fichier.txt
Éc

du répertoire courant ouvert en lecture.

18.7 Les fonctions en lien avec les attributs d’objets

dir(x)
retourne la liste de toutes les méthodes et attributs de l’objet x .
L3

getattr(x, y) où y est une chaîne de caractères

retourne la valeur de l’attribut nommé y de x . getattr(x, 'attr') , est la valeur
de x.attr .
getattr(2.7, '__doc__') retourne la chaîne de documentation du type float .
getattr(2.7, 'maison') provoque une erreur : ’float’ object has no attribute
’maison’.
getattr(x, y, z) où y est une chaîne de caractères
retourne la valeur de l’attribut nommé y de x s’il existe, sinon retourne z .
getattr(2.7, 'maison', "2.7 n'a pas de maison") retourne "2.7 n'a pas de maison" .
132 CHAPITRE 18. A. Tessier

setattr(x, y, z) où y est une chaîne de caractères

affecte la valeur z à l’attribut nommé y de l’objet x . setattr(x, 'attr', z) est
équivalent à x.attr = z .
hasattr(x, y) où y est une chaîne de caractères
retourne un booléen qui indique si x a un attribut nommé y .
getattr(2.7, '__doc__') retourne True .
getattr(2.7, 'maison') retourne False .

e
18.8 Les fonctions générales sur les objets

ri
repr(x)
retourne une chaîne de caractères représentant l’objet x . Le plus souvent, repr(x)
sert comme valeur retournée par str(x) , mais on saisit la différence, par exemple
si x est une chaîne de caractère : repr('abc') vaut "'abc'" alors que str('abc')

ét
vaut 'abc' . Par défaut, pour un objet x qui n’a pas redéfini sa méthode __repr__() ,
repr(x) retourne une chaîne de caractères qui contient le nom du type de l’objet
et son adresse en mémoire.
repr(1.5e3) retourne '1500.0' . m
hash(x)
retourne un entier qui est la valeur de hachage de x .
o
18.9 Les « méta fonctions »
on

eval(x) où x est une chaîne de caractères

retourne l’évaluation de l’expression contenu dans la chaîne x . Pour une expression
e , eval(repr(e)) devrait être la valeur de e .
eval("'1+2'+'3+4'") évalue l’expression '1+2'+'3+4' et retourne '1+23+4' .
Si a est une variable qui vaut 2 , alors eval('a+1') évalue a+1 et retourne 3 .
Éc

exec(x) où x est une chaîne de caractères

exécute le code contenu dans la chaîne x et retourne None .
Après eval('y=1') , qui retourne None , la variable y vaut 1 .
L3
 Chapitre 19

e
Les modules et packages prédéfinis

ri
Pour pouvoir être utilisé, un module doit être importé avec une instruction import .
Cette instruction peut prendre cinq formes différentes. Par exemple, si je souhaite

ét
utiliser la fonction sqrt du module math , qui retourne la racine carrée de son argument,
√
pour affecter à x la valeur de 3 :

1 import math # importe le module math avec le nom math

m
2 x = math.sqrt(3)
o
1 import math as m # importe le module math avec le nom m
2 x = m.sqrt(3)
on

1 from math import sqrt # importe la fonction sqrt du module math avec le nom sqrt
2 x = sqrt(3)
Éc

1 from math import * # importe tous les objets du module math avec leur nom
2 x = sqrt(3)

1 from math import sqrt as rc # importe la fonction sqrt du module math avec le nom rc
L3

2 x = rc(3)

19.1 Le module math

Le module math fourni
— des fonctions arithmétiques

133
134 CHAPITRE 19. A. Tessier

fonction signification exemple valeur

math.floor(x) bxc math.floor(3.7) 3
math.ceil(x) dxe math.ceil(3.2) 4
math.trunc(x) [ x ] math.trunc(-3.7) −3
n

math.comb(n,k) math.comb(5,2) 10
k
k
math.perm(n,k) An math.perm(5,2) 20
math.factorial(n) n! math.factorial(5) 120

e
math.gcd(a,b) pgcd( a , b ) math.gcd(540,600) 60
math.lcm(a,b) ppcm( a , b ) math.lcm(204,306) 612
— des fonctions logarithmiques et exponentielles

ri
fonction signification exemple valeur
√
math.sqrt(x) x math.sqrt(2) 1, 41421 . . .
math.log10(x) log x math.log10(1000) 3

ét
math.log(x) ln x math.log(17) 2.83321 . . .
math.exp(x) e x math.exp(1) 2.71828 . . .
— des fonctions trigonométriques et hyperboliques
fonction signification exemple valeur
math.cos(x) cos x m math.cos(1) 0
math.sin(x) sin x math.sin(0) 0
math.tan(x) tan x math.tan(0) 0
math.acos(x) arc cos x math.acos(1) 0
math.asin(x) arc sin x math.asin(0)
o
0
math.atan(x) arc tan x math.atan(0) 0
math.cosh(x) cosh x math.cosh(0) 1
on

math.sinh(x) sinh x math.sinh(0) 0

math.tanh(x) tanh x math.tanh(0) 0
math.acosh(x) acsh x math.acosh(1) 0
math.asinh(x) asnh x math.asinh(0) 0
math.atanh(x) atnh x math.atanh(0) 0
— des constantes
Éc

constante valeur
math.pi π = 3.14159 . . .
math.e e = 2.71828 . . .
math.inf +∞
-math.inf −∞
math.nan not a number
L3

19.2 Le module random

Le module random. . .

19.3 Le module statistics

Le module statistics. . .
19.4. LE MODULE DATETIME 135

19.4 Le module datetime

Le module datetime. . .

19.5 Le module array

Le module array. . .

e
19.6 Le module decimal

ri
Le module decimal. . .

19.7 Le package NumPy

ét
19.8 Le package pandas
19.9 Le package matplotlib m
o
on
Éc
L3
136 CHAPITRE 19. A. Tessier

e
ri
ét
o m
on
Éc
L3
Bibliographie

e
[1] The Python Software Foundation. Python documentation. Python Software Foun-
dation License Version 2. 2001-2024.

ri
[2] Gérard Swinnen. Apprendre à programmer avec Python 3 . Licence Creative Com-
mons BY-NC-SA 2.0 FR. Edition Eyrolles, 2012.
[3] The NumPy Project. NumPy documentation. NumFOCUS sponsored project.

ét
[4] The pandas Project. pandas documentation. NumFOCUS sponsored project.
[5] The Matplotlib development team. Using Matplotlib. 2002-2024.
o m
on
Éc
L3

137