Cours Programmation Python v1 2021

PROGRAMMATION PYTHON
Jamâl-Dine DISSOU
Version 1.0 - Novembre 2021

Page 2 sur 91
1. INTRODUCTION À PYTHON
Python est un langage de programmation interprété, qui se veut simple à

comprendre, modulable et aux applications multiples. C’est aujourd’hui un des
langages les plus utilisés et les plus plébiscités par les développeurs.
Cette première leçon a pour but de présenter le langage Python et de poser
quelques concepts fondamentaux relatifs aux langages de programmation qui
nous seront utiles par la suite.
1.1. Python, un langage de programmation
Un ordinateur est une machine dont la fonction principale est de traiter des
données, c’est-à-dire d’exécuter des séries d’instructions pour effectuer différentes
tâches.
En tant que développeurs, nous allons vouloir fournir nos séries d’instructions aux
ordinateurs afin qu’ils exécutent certaines tâches précises dans un certain ordre.
Pour cela, il va falloir que l’ordinateur nous comprenne et il va donc falloir qu’on
exprime nos instructions dans un langage qu’il comprend. Le souci, ici, est que les
ordinateurs ne comprennent qu’un seul langage : le binaire ou “langage machine”
qui est très opaque pour nous (les Humains) et très long à écrire.
Pour pallier à ce problème, certaines personnes ont créé ce qu’on appelle des
langages de programmation. Le but premier de tout langage de programmation
est de passer des instructions à l’ordinateur.
Schématiquement, on utilise des langages de programmation car il est plus facile

de nous exprimer et d’expliciter nos séries d’instruction en suivant leurs
conventions d’écriture plutôt que de passer nos instructions directement en
binaire à l’ordinateur.
Le langage de programmation se charge de la conversion : il reçoit nos

instructions et les transforme en binaire pour les passer à l’ordinateur afin que
celui-ci les exécute.
Dr Jamâl-Dine DISSOU - 2021

Page 3 sur 91
Tous les langages de programmation ne sont pourtant pas égaux : certains sont
plus facilement compréhensibles pour nous que d’autres et certains nous
permettent de transmettre uniquement certaines instructions à l’ordinateur.
Python est un langage de programmation dit de “très haut niveau”. Cela signifie
qu’il possède un haut niveau d’abstraction par rapport au langage machine. Pour
le dire très simplement : plus un langage de programmation est de “haut niveau”,
plus sa syntaxe se rapproche de notre langage (l’anglais) plutôt que du langage
machine. Un langage de haut niveau est donc plus facile à comprendre et à
utiliser qu’un langage de plus bas niveau.
1.2. Python, un langage interprété
Comment font les langages de programmation pour transformer nos instructions

en instructions compréhensibles par un ordinateur ? Ils leur faut un traducteur.
Certains langages utilisent un interpréteur comme traducteur tandis que d’autres
utilisent un compilateur.
Un interpréteur se distingue d’un compilateur par le fait que, pour exécuter un

programme, les opérations d’analyse et de traductions sont réalisées à chaque
exécution du programme (par un interprète) plutôt qu’une fois pour toutes (par
un compilateur).
L’interprétation repose sur l’exécution dynamique du programme par un autre

programme (l’interpréteur), plutôt que sur sa conversion en un autre langage (par
exemple le langage machine).
Ainsi, contrairement au compilateur, l’interpréteur exécute les instructions du

programme (ou en évalue les expressions), au fur et à mesure de leur lecture pour
interprétation. Du fait de cette phase sans traduction préalable, l’exécution d’un
programme interprété est généralement plus lente que le même programme
compilé.
En revanche, les langages interprétés sont généralement plus simples à

appréhender puisqu’on ne passe pas par une étape de compilation avant
d’exécuter son programme et la portabilité.

Page 4 sur 91
En effet, un langage comme Python fonctionnera avec n’importe quel système

d’opération (OS) du moment que l’OS en question possède l’interpréteur Python.
Un compilateur, de l’autre côté, va produire un programme écrit en langage
assembleur et ce langage assembleur va être différent pour chaque OS. Par
conséquent, les programmes compilés ne peuvent s’exécuter que sur des
ordinateurs dotés de la même architecture que l’ordinateur sur lequel ils ont été
compilés.
1.3. Python, un langage extensible et polyvalent
Python est modulable et extensible : une fois qu’on connait les bases du langage,
on va pouvoir relativement simplement ajouter de nouvelles fonctions ou
modules pour étendre les possibilités de ce langage.
Python est un langage de programmation conçu dès le départ pour être “full
stack”, c’est-à-dire pour avoir de multiples applications à la différence du PHP par
exemple qui a clairement été imaginé pour fonctionner dans un contexte Web.
Ce langage est un langage orienté objet à la base mais Python supporte également
d’autres paradigmes comme la programmation procédurale et fonctionnelle. Un
paradigme est une “façon de coder” ou une “façon d’imaginer le code et de le
structurer”. Nous reviendrons là dessus plus tard.
1.4. Un point sur les versions Python
En informatique, les langages évoluent par “version”. Les équipes qui créent un
langage travaillent sans cesse à l’amélioration de celui-ci mais chaque
changement fait sur le langage n’est pas immédiatement intégré au langage ni
disponible au public.
Au contraire, une liste de modifications / ajouts sont faits au langage en arrière

plan et, dès que l’équipe gérant l’évolution du langage juge les changements
suffisamment importants et stables, une nouvelle “version” du langage qui
incorpore ces changement est distribuée.

Page 5 sur 91
La première grosse mise à jour de Python date de 2000 avec la version Python 2.
Les versions se sont ensuite enchainées normalement avec Python 2.1, 2.2, 2.3, etc.
jusqu’en 2009 avec la sortie de Python 3.
Pour Python 3, l’équipe qui gère l’évolution du Python a fait le choix audacieux de
partir sur de nouvelles bases et de casser la compatibilité avec les anciennes
versions.
Généralement, lorsqu’un langage évolue et que de nouvelles versions paraissent,

les équipes de développement font bien attention à proposer une compatibilité
ascendante, c’est-à-dire à faire en sorte que les codes créés sous d’anciennes
versions fonctionnent toujours avec les nouvelles versions des langages. En effet,
sans ce principe de compatibilité, la plupart des programmes et des sites Web ne
fonctionneraient pas puisque les développeurs de ceux-ci devraient absolument
les modifier à chaque nouvelle version d’un langage utilisé pour coller aux
nouvelles normes.
A l’inverse, le fait de proposer une comptabilité ascendante entre chaque version

pose de vrais problèmes d’héritage aux développeurs d’un langage puisque ces
derniers sont obligés de conserver certaines syntaxes et fonctionnalités
totalement obsolètes.
Voulant modifier en profondeur leur langage et proposer une version beaucoup

plus “propre” et au goût du jour, la Python Software Foundation (l’équipe chargée
du développement du Python) a donc décidé de faire table rase pour Python 3 et
de partir sur de nouvelles bases.
Le souci ici est que Python 2.x était déjà très populaire à l’époque et que cela allait
mettre de nombreuses personnes dans l’embarras. L’équipe de Python a donc fait
le choix de conserver deux versions du langage : Python 2.x et Python 3.x et de les
faire évoluer de front. Pour être tout à fait précis, la version 3 est la version dont
les fonctionnalités allaient continuer d’évoluer tandis que la version 2 n’allait
recevoir que des mises à jour liées à la sécurité.
Aujourd’hui encore, on retrouve ces deux versions de Python qui co-existent. Pour nous, cependant,
le problème ne se pose pas : nous travaillerons bien évidemment avec la dernière version en date
de Python qui est à l’heure où j’écris la version 3.7.3.

Page 6 sur 91
2. L’ENVIRONNEMENT DE TRAVAIL PYTHON
Dans cette leçon, nous mettons en place notre environnement de travail en nous
équipant des logiciels nécessaires pour pouvoir développer en Python.
2.1. Coder en Python : simple et gratuit
Python est un langage Open Source. Cela signifie que ses sources et son
interpréteur sont disponibles au public et donc que n’importe qui peut
commencer à développer ses propres programmes Python gratuitement.
Pour coder en Python, un seul programme va être strictement obligatoire :

l’interpréteur Python qui va pouvoir être utilisé de manière dynamique et nous
afficher les résultats de nos codes immédiatement.
En pratique, cependant, nous voudrons souvent enregistrer nos différents scripts

dans des fichiers plutôt que d’écrire des séries d’instructions à exécuter
immédiatement. Pour cela, nous avoir besoin d’un éditeur de texte ou d’un IDE
(Environnement de Développement Intégré).
2.2. L’interpréteur Python
Python est un langage interprété, ce qui signifie qu’on va avoir besoin d’un
programme nommé interpréteur pour convertir nos instructions Python en un
langage compréhensible par notre ordinateur.
L’interpréteur Python est disponible en téléchargement gratuit sur le site officiel

du langage, dans la rubrique téléchargement
: https://www.python.org/downloads/.
Sur cette page, commencez par télécharger la dernière version stable de Python
qui correspond à votre système. L’interpréteur sera parmi les fichiers téléchargés.

Page 7 sur 91
Notez que si vous utilisez un Mac un interpréteur Python devrait déjà être installé
sur votre machine par défaut. Cependant, l’interpréteur pré-installé risque de
correspondre à une ancienne version et nous voulons dans ce cours travailler avec
la dernière version stable du langage (Python 3.7.3 à l’heure de ce cours).
Une fois que vous avez téléchargé la ressource Python disponible sur le site officiel,
ouvrez la en double cliquant dessus. Un processus d’installation démarre. Si vous
êtes sur Windows, cochez la case “Ajouter Python 3.x au PATH”. Suivez ensuite le
processus d’installation comme pour n’importe quel autre logiciel.
Vous venez d’installer l’interpréteur Python ainsi que d’autres ressources pour
vous aider dans vos développements Python, notamment IDLE et Python
Launcher si vous utilisez un Mac.
IDLE est un environnement de développement intégré spécialement pour Python

qui nous permet d’exécuter directement du code Python. Python Launcher
permet lui d’exécuter du code Python créé dans des fichiers séparés .py en double
cliquant simplement sur ces fichiers. Ces deux logiciels sont extrêmement
puissants et pratiques, même si nous ne nous en servirons pas dans ce cours pour
faciliter la compréhension et le suivi de tous.
Pour exécuter nos scripts Python, il va falloir les passer à l’interpréteur. Pour cela,
nous allons utiliser l’invite de commande (Windows) ou le terminal (Mac).
L’invite de commande se trouve dans le menu Démarrer de Windows sous le

nom cmd. Le terminal se trouve dans le dossier Applications, puis Utilitaire de
Mac. Dès que vous trouvez l’invite de commande ou le terminal, ouvrez le. Une
fenêtre noire devrait apparaitre.
Une fois que vous êtes dans l’invite de commande ou dans le terminal,
commencez par vérifier que l’interpréteur Python a bien été installé. Pour cela,
tapez la commande python -V (avec un V majuscule) et pressez la touche Entrée. Si
vous êtes sur Mac, Python 2.7 devrait déjà être installé et sera probablement la
version renvoyée. Tapez plutôt la commande python3 -V. La version de
l’interpréteur Python installée devrait vous être renvoyée.
Pour appeler l’interpréteur, tapez simplement python3 (ou python3.7 dans le cas où
il y aurait une ambiguïté) (Mac) ou python (Windows). Si la version de
l’interpréteur vous est renvoyée te que vous voyez un triple chevron $gt;$gt;$gt;,

Page 8 sur 91
c’est gagné ! Ce triple chevron est le moyen pour l’interpréteur de nous dire “je
suis prêt à recevoir la prochaine instruction”.
A partir de là, nous avons deux options : on va pouvoir soit directement écrire nos
instructions Python dans l’invite de commande ou dans le terminal pour les
exécuter immédiatement, soit créer des fichiers de script Python avec
l’extension .py avec un éditeur de texte et les passer ensuite à l’interpréteur. Dans
l’image ci-dessus, par exemple, j’ai tapé et exécuté une première instruction
Python print() qui sert simplement à afficher un message.
Ecrire son code directement dans l’invite de commande / le terminal est très
pratique pour tester rapidement un code. Cependant, en conditions “réelles”, c’est-
à-dire lorsque vous devrez créer de vrais programmes contenant potentiellement
plusieurs scripts ou lorsque vous voudrez distribuer votre code, vous stockerez vos
instructions dans des fichiers .py que vous allez créer avec un éditeur de texte ou
un IDE.
2.3. L’éditeur de texte
Un éditeur de texte nous permet tout simplement d’écrire des lignes de code et
d’enregistrer nos fichiers au bon format.
Il existe des centaines d’éditeur prêt à télécharger sur le Web et la majorité d’entre
eux sont gratuits. Je n’ai pas de conseil spécifique à vous donner quant au choix de
votre éditeur de texte : essayez simplement d’en trouver un avec lequel vous êtes à
l’aise et si possible installez plutôt un IDE (Environnement de Travail Intégré)
qu’un simple éditeur.

Page 9 sur 91
Les IDE disposent de fonctionnalités supplémentaires comme des mécanismes

d’auto-complétion du code ou encore de systèmes de détection des erreurs de
syntaxe dans un code et de proposition de modification.
Vous pouvez utiliser Brackets, Atom, Sublime Text ou encore Komodo si vous
préférez.
Notez par ailleurs qu’il existe certains éditeurs spécialement conçus pour écrire du
code Python dont le célèbre PyCharm notamment.

Page 10 sur 91
3. SYNTAXE DE BASE ET EXÉCUTION D’INSTRUCTIONS PYTHON
Dans cette leçon, nous allons découvrir quelques éléments de syntaxe de base de
Python. Nous allons également exécuter nos première instructions Python en
utilisant l’interpréteur de manière interactive ou en créant un fichier Python
qu’on va ensuite passer à l’interpréteur.
3.1. Créer un fichier Python
Nous avons deux choix pour exécuter du code Python : on peut soit écrire
directement notre code dans l’invite de commande (Windows) ou dans le terminal
(Mac) afin que l’interpréteur Python interprète directement notre code et nous
renvoie son résultat ou on peut créer des fichiers Python avec un ensemble
d’instructions à l’intérieur et qu’on va ensuite passer à l’interpréteur.
L’intérêt principal d’un fichier est qu’il peut être sauvegardé et distribué. En
conditions réelles, vous utiliserez donc souvent votre éditeur de texte et créerez
des fichiers Python pour mener à bien des projets.
Dans ce cours, j’écrirai directement dans mon terminal pour vous montrer les
résultats d’instructions simples et nous ne créerons des fichiers que lorsque cela
sera nécessaire. Cependant, pour cette première leçon concrète, je voulais tout de
même vous montrer comment créer un fichier Python et comment exécuter ce
fichier.
Pour créer un fichier Python, nous allons déjà ouvrir notre éditeur de texte, allons
ouvrir un nouveau fichier et enregistrer ce fichier en lui donnant une
extension .py. On peut appeler ce fichier cours.py par exemple et l’enregistrer dans
un dossier Python sur notre bureau.
Ici, on commence par enregistrer notre fichier au format Python avant même
d’écrire un quelconque code car cela va permettre à notre éditeur de reconnaitre
le type de code qu’on souhaite écrire et d nous proposer des fonctionnalités
relatives à cela. Par ailleurs, il est possible que votre éditeur vous propose
d’installer des extensions spécifiques Python pour faciliter l’écriture, l’affichage et
le debugging de votre code. Si c’est le cas, n’hésitez pas à les installer.

Page 11 sur 91
Ensuite, ajoutez les lignes de code suivantes dans votre fichier (nous allons
expliquer par la suite ce qu’elles signifient) :
3.2. Exécuter un fichier Python
Pour exécuter un fichier Python et obtenir le résultat des opérations faites dans ce
fichier, commencez déjà par ouvrir votre invite de commande ou votre terminal.
Ici, si vous avez bien ajouté Python au PATH, vous n’avez qu’à taper cours.py pour
exécuter le code du fichier “cours.py”. Si votre système possède plusieurs versions
de Python, comme c’est le cas sur Mac, il faudra préciser la version utilisée : on
tapera alors python3 cours.py.
Si Python n’a pas été ajouté au PATH, il va falloir préciser où le fichier se trouve.
Pour cela, on va commencer par taper la commande cd Desktop. La
commande cd signifie “change directory” (“changer de dossier”).
Ensuite, on n’a plus qu’à préciser l’emplacement de notre fichier par rapport à
notre bureau (Desktop), c’est à dire dans notre cas Python/cours.py (Mac)
ou Python\cours.py (Windows) pour exécuter notre fichier, en précisant
éventuellement également une version si plusieurs versions sont installées sur
notre système (python3 Python/cours.py pour Mac).

Page 12 sur 91
3.3. Exécuter du Python en tapant directement dans l’invite de commande ou

le terminal
L’interpréteur Python peut être utilisé de manière interactive, c’est-à-dire qu’on

va pouvoir directement lui fournir du code Python à exécuter et il nous renverra
les résultats immédiatement.
Cette fonctionnalité est très utile lorsqu’on souhaite tester rapidement des bouts
de code ou pour l’apprentissage.
Pour utiliser l’interpréteur Python de cette manière, on va déjà devoir l’appeler

depuis l’invite de commande ou le terminal. Pour cela, on écrit la
commande Python3.7 et on presse Entrée pour valider.
Ensuite, on a plus qu’à écrire nos différentes instructions et à presser Entrée afin
que l’interpréteur les interprète immédiatement.
3.4. Syntaxe de base de Python : indentation, commentaires et print()
Chaque langage informatique est basé sur une série de règles et de conventions. La
syntaxe d’un langage définit ses différents éléments et la façon dont on va pouvoir
et devoir les utiliser.
J’aimerais pour le moment m’arrêter sur deux éléments de syntaxe de base que
sont les commentaires et l’indentation ainsi que sur la fonction print().

Page 13 sur 91
Les commentaires Python
Les commentaires sont des éléments de langage qu’on retrouve dans de nombreux
langages de programmation.
Les commentaires servent à “commenter” le code : ils vont être ignorés lors de
l’exécution du code (ils n’auront aucun impact sur le script) et vont donc être
totalement transparents pour l’utilisateur final.
On utilise généralement les commentaires pour documenter un code (pour soi ou

pour d’autres développeurs si le code a vocation à être distribué) ou pour
empêcher son exécution. En Python, on utilise le signe # pour écrire un
commentaire dans notre code.
Python n’a pas de syntaxe particulière pour écrire des commentaires multi-lignes.
Pour écrire un commentaire sur plusieurs lignes, on insérera un # au début de
chaque ligne.
L’indentation Python
L’indentation correspond au fait de créer des retraits au niveau de certaines lignes

de code. Dans la grande majorité des langages, l’indentation n’a qu’une visée
esthétique : elle permet à un script d’être plus lisible pour un développeur.
Généralement, une bonne indentation est censée représenter les dépendances au

sein d’un code : on ajoutera un retrait à chaque fois qu’une instruction est incluse
/ dépend d’une autre.
En Python, l’indentation a un tout autre rôle : elle est utilisée par Python pour
définir des blocs de code, c’est-à-dire pour indiquer à l’interpréteur quelle
instruction appartient à quelle autre.
Si on indente mal notre code Python, celui-ci ne s’exécutera tout simplement pas
et Python renverra une erreur. Pas de panique, nous allons apprendre au cours de
ce cours à quelle moment indenter. Cela est cependant relativement évident et ne
devrait pas vous poser de problème : dès qu’il y a une relation de dépendance, il
faudra ajouter un retrait (une fabulation).

Page 14 sur 91
Dans le code ci-dessus, par exemple, nous avons utilisé une structure
conditionnelle if. Le principe de cette structure est simple : on lui fournit un test
et SI le test est validé, alors on exécute un code. Le code à exécuter dépend du
résultat du test; on effectuera donc un retrait pour mentionner ce code afin que
Python puisse bien s’apercevoir qu’il dépend de la structure conditionnelle.
Si vous avez l’habitude d’autres langages de programmation comme le PHP par

exemple cela peut être un peu déconcertant au départ. Vous pouvez alors
considérer que l’indentation remplace l’usage des accolades.
La fonction print()
Les fonctions sont d’autres éléments de langage que nous étudierons plus tard.
Grosso-modo, une fonction est définie par un nom et une série d’instructions.
Lorsqu’on appelle une fonction (en utilisant son nom et un couple de parenthèses
juste derrière), elle exécute toutes les instructions qu’elle contient. Les fonctions
servent généralement à effectuer une action précise qui peut être plus ou moins
complexe.
La fonction print() permet tout simplement d’afficher le message qu’on va lui

passer entre ses parenthèses. A première vue, la fonction print() ne parait pas très
utile, et c’est pourtant l’une des fonctions qu’on utilisera le plus.
En effet, cette fonction va être très précieuse puisqu’elle va également nous

permettre d’afficher des résultats auquel on n’a pas directement accès. Nous
illustrerons cela dans la suite de ce cours; faites moi confiance pour le moment.

Page 15 sur 91
4. LES VARIABLES PYTHON
Dans cette leçon, nous allons découvrir un élément fondamental des langages de
programmation : les variable. Nous allons expliquer ce que sont les variables en
informatique, les usages qu’on va pouvoir en faire et comment créer des variables
Python.
4.1. Qu’est-ce qu’une variable ?
Une variable, dans le domaine de la programmation informatique, est un

conteneur qui sert à stocker une valeur. Les variables possèdent deux
caractéristiques fondamentales :
Les variables ont une durée de vie limitée (une variable ne vit

généralement que le temps de l’exécution d’un script ou de la fonction qui
l’a définie), ce qui signifie qu’on ne va pas pouvoir utiliser les variables pour
stocker des données de manière pérenne ;
 La valeur d’une variable peut varier : les variables peuvent peuvent stocker
différentes valeurs au cours de leur vie (la nouvelle valeur remplaçant
l’ancienne).
Les variables donc être au coeur de nos scripts puisqu’elles vont nous permettre de
conserver des valeurs le temps d’un script et d’effectuer toutes sortes de
manipulations sur ces valeurs en toute simplicité.
4.2. Comment déclarer une variable en Python ?
Python ne possède pas de syntaxe particulière pour créer ou “déclarer” une

variable : les variables Python sont automatiquement créées au moment où on
leur assigne une valeur.
Pour créer une variable en Python, on va donc devoir choisir un nom et affecter
une valeur à ce nom, c’est-à-dire stocker une valeur dans notre variable.

Page 16 sur 91
Le choix du nom pour nos variables est libre en Python. Il faut cependant
respecter les règles usuelles suivantes :
 Le nom doit commencer par une lettre ou par un underscore ;

 Le nom d’une variable ne doit contenir que des caractères alphanumériques courants (pas
d’espace dans le nom d’une variable si de caractères spéciaux comme des caractères
accentués ou tout autre signe) ;
 On ne peut pas utiliser certains mots qui possèdent déjà une signification spéciale pour le
langage (on parle de mots “réservés”).
Notez que les noms de variables en Python sont sensibles à la casse, ce qui signifie
qu’on va faire une différence entre l’emploi de majuscules et de minuscules : un
même nom écrit en majuscules ou en minuscules créera deux variables
totalement différentes.
Pour affecter ou “assigner” une valeur à une variable, nous allons utiliser un
opérateur qu’on appelle opérateur d’affectation ou d’assignation et qui est
représenté par le signe =. Attention, le signe = ne signifie pas en informatique
l’égalité d’un point de vue mathématique : c’est un opérateur d’affectation.
Le signe = ne sert pas à dire que la valeur est égale au nom de variable ou que la
variable “vaut” cette valeur, il indique simplement qu’on affecte ou qu’on stocke
une certaine valeur dans un conteneur.
D’un point de vue mathématique, par exemple, écrire x = x + 2 n’a aucun sens car
la variable x ne peut être égale qu’à elle même. En informatique, cependant, c’est
tout à fait possible puisque l’opérateur = n’est pas un opérateur d’égalité mais
d’affectation. Ecrire x = x + 2 signifie qu’on affecte une nouvelle valeur à x qui est
égale à l’ancienne valeur de x à laquelle on ajoute 2.
Notez déjà qu’on va également pouvoir effectuer des affectations multiples en

Python, c’est-à-dire affecter plusieurs valeurs à plusieurs variables très facilement

Page 17 sur 91
en utilisant la syntaxe nom_variable_1, nom_variable_2, nom_variable_3 = valeur1,

valeur2, valeur3.
4.3. Que peut stocker une variable Python ?
Les variables vont pouvoir stocker différents types de valeurs comme des
nombres, des chaines de caractères, des booléens, et plus encore.
Il est important de connaitre le type de valeur stocké dans une variable car nous
n’allons pas pouvoir effectuer les même opérations avec une variable qui stocke
un nombre ou avec une variable qui stocke une chaine de caractères par exemple.
Nous étudierons les spécificités liées à chaque type de valeur que peut stocker une
variable Python dans la prochaine leçon.
4.4. Afficher et modifier le contenu d’une variable Python
Nous allons pouvoir réaliser toutes sortes d’opérations avec nos variables. La plus
basique d’entre elles consiste à afficher le contenu d’une variable. Pour afficher la
valeur d’une variable Python, il suffit d’écrire son nom, ou éventuellement
d’utiliser la fonction print() en renseignant le nom de la variable entre les
parenthèses/

Page 18 sur 91
Comme je l’ai précisé plus haut, l’une des caractéristiques fondamentales des
variables va être de pouvoir stocker différentes valeurs durant sa vie. Ainsi, on
peut tout à fait affecter une nouvelle valeur à une variable. Une variable «
classique » ne va pouvoir stocker qu’une valeur à la fois. En affectant une nouvelle
valeur à une variable, la valeur précédente est ainsi écrasée.
Pour comprendre ce code, vous devez savoir qu’ici les instructions sont exécutées
linéairement, c’est-à-dire dans leur ordre d’écriture. On commence par affecter la
valeur 29 à notre variable age et la valeur Pierre à notre variable prenom, puis on
affiche le contenu de ces variables.
On affecte ensuite de nouvelles valeurs dans nos variables. Ces nouvelles valeurs
remplacent (“écrasent”) les précédentes. Lorsqu’on affiche à nouveau le contenu de
nos variables, les valeurs renvoyées sont les dernières stockées.
4.5. Quelle est l’utilité des variables Python ?
Les variables sont des éléments de base présents dans la quasi-totalité des
langages de programmation car elles vont s’avérer indispensables dans de très
nombreuses situations.
Il est difficile à ce niveau du cours d’illustrer concrètement la puissance des

variables. Le grand intérêt des variables va résider dans le fait qu’on va disposer
d’un nom fixe (un “label”) qui va nous servir à manipuler des valeurs qui peuvent
changer ou qu’on peut ne pas encore connaitre.
Imaginons par exemple qu’on crée un programme qui va effectuer des calculs à
partir d’une valeur qui va lui être envoyée uniquement lorsque ce programme sera
exécuté. Lors de la création du programme, on ne connait pas cette valeur et cette
valeur va pouvoir être différente entre différentes exécutions du programme.

Page 19 sur 91
On va pouvoir indiquer que cette valeur (inconnue pour le moment) devra être
stockée dans telle variable au début du programme et ensuite définir les
différentes opérations qui devront être effectuées sur cette valeur en utilisant le
nom de la variable (qui sera remplacée par sa valeur effective lorsque le
programme s’exécutera).

Page 20 sur 91
5. LES TYPES DE DONNÉES OU TYPES DE VALEURS PYTHON

Dans cette leçon, nous allons définir ce qu’est un type de données et passer en revue les types de
données Python les plus courants et simples à appréhender.
5.1. Qu’est-ce qu’un type de données ?
En programmation, les données qu’on va pouvoir manipuler avec un langage sont

généralement classées par “type”.
Un “type” de données pour un langage est défini par les manipulations qu’on va
pouvoir faire sur ces données : on va pouvoir effectuer les mêmes opérations sur
chaque donnée d’un même type et des opérations différentes sur différents types
de données.
Prenons un nombre entier par exemple. Il semble tout à fait logique de pouvoir
effectuer des opérations mathématiques de base avec ce nombre : addition,
soustraction, multiplication, etc. En revanche, on ne va pas pouvoir effectuer les
mêmes opérations / manipulations sur un texte, puisque multiplier un texte par
quelque chose par exemple n’a aucun sens.
5.2. Les types de données Python
Python définit de nombreux types de données qu’on va pouvoir stocker dans nos
variables et manipuler à loisir ensuite : nombres entiers, décimaux, complexes,
chaines de caractères, booléens, listes, tuples, dictionnaires, etc.
Dans cette leçon, nous allons nous contenter de passer en revue les types de
données les plus simples à se représenter (nombres, chaines et booléens). Les
autres types de données feront l’objet de leçons séparées.
Les types numériques int, float et complex
Python définit trois types de valeurs numériques supportées :
 Le type int qui représente tout entier positif ou négatif ;

Page 21 sur 91
 Le type float qui représente les nombres décimaux et certaines expressions scientifiques
comme le e pour désigner une exponentielle par exemple;
 Le type complex qui représente les nombres complexes ou nombres imaginaires et qui se
sert de la lettre j pour représenter la partie imaginaire d’un nombre.
Le type de données “nombre entier” ou int pour être technique (“int” = “integer” =
entier) couvre tous les nombres entiers positifs ou négatifs. On va pouvoir
effectuer toutes sortes d’opérations arithmétiques avec ce premier type de
données : addition, soustraction, multiplication, division, élévation à la puissance,
etc.
Pour effectuer des opérations arithmétiques entre différentes valeurs numérique,

nous allons devoir utiliser des opérateurs arithmétique ( + pour l’addition, - pour la
soustraction, etc.).
On va pouvoir effectuer ces opérations directement entre nombres et se servir de

Python comme d’une calculatrice ou affecter ces nombres à des variables et
utiliser nos variables pour effectuer nos opérations :
Ici, on commence par effectuer des opérations entre nombres : addition,

soustraction, multiplication, division et élévation à la puissance. Notez que pour
réaliser une division entière, on utilise l’opérateur //. On peut également utiliser
l’opérateur / pour réaliser une division “classique” mais dans ce cas le résultat sera
toujours considéré comme étant de type float (nombre décimal). Finalement, on
utilise l’opérateur ** pour élever un nombre à la puissance.
On peut également stocker des nombres dans des variables et utiliser ces variables
pour effectuer nos calculs. Ici, on commence par définir une variable x et on lui

Page 22 sur 91
attribue la valeur 5. On effectue ensuite différentes opérations. Notez que durant

tous ces calculs x continue de stocker 5 puisqu’on n’affecte jamais de nouvelles
valeurs à x. Finalement, on définit une deuxième variable y = 10 et on demande à
Python de calculer x + y, c’est-à-dire de nous donner le résultat de l’addition des
deux valeurs contenues dans x et dans y.
Le type de données “nombre décimal” ou float couvre tous les nombres décimaux
(c’est-à-dire les nombres à virgule) ainsi que certaines expressions scientifiques
comme le e qui désigne une exponentielle.
Attention ici : dans le monde de la programmation, les notations anglo-saxonnes

sont la norme. Il faudra donc bien faire attention à utiliser un . et non pas
une , pour les décimaux.
Nous allons grosso-modo pouvoir réaliser les mêmes opérations avec des données
de type float qu’avec des données de type int (même si le traitement en arrière
plan va être différent).
Il y a différentes choses à noter par rapport au type float en Python :
 Toute opération arithmétique entre nombres de type float donne un résultat de

type float ;
 Toute opération arithmétique entre nombres de types int et float donne un résultat de
type float ;
 La division classique donne toujours un résultat de type float.
On effectue plusieurs opérations arithmétiques d’un coup sur nos dernières lignes
dans l’exemple ci-dessus. Dans ce cas là, il faudra faire attention à l’ordre des
opérations. L’ordre des opérations va être le même qu’en mathématiques : les

Page 23 sur 91
calculs de puissance seront effectués en priorité, puis la multiplication et la

division, puis enfin l’addition et la soustraction.
On va également pouvoir utiliser des parenthèses pour imposer un ordre de

priorité de calculs différents. Dans ce cas là, ce qui se trouve entre parenthèses
sera calculé en premier.
Finalement, le type de données “nombre complexe” ou complex représente les

nombres complexes. On va utiliser la lettre j ou J pour représenter la partie
complexe d’un nombre. Comme la plupart d’entre vous n’auront que rarement
affaire aux nombres complexes et que ce cours n’est pas un cours de
mathématiques, je n’entrerai pas dans le détail ici.
Le type str ou chaine de caractères
Les chaines de caractères sont ce qu’on appelle communément du texte. Pour

définir une chaine de caractères ou pour stocker une chaine de caractères dans
une variable, il faudra l’entourer de guillemets simples ou doubles droits.
Si notre chaine de caractères contient elle même des guillemets simples

(apostrophes) ou doubles, il faudra les échapper les uns ou les autres en fonction
du délimiteur choisi pour qu’ils soient correctement interprétés car sinon Python
pensera qu’ils servent à indiquer la fin de la chaine. Le caractère d’échappement
en Python est l’antislash \.

Page 24 sur 91
Dans l’exemple ci-dessus, on veut afficher et stocker la chaine Je m’appelle “Pierre

Giraud” qui contient à la fois des guillemets simples ou apostrophes et des
guillemets doubles. Il va donc falloir qu’on échappe les uns ou les autres en
fonction du caractère de délimitation de chaine choisi afin d’indiquer au Python
que les guillemets simples ou doubles à l’intérieur de notre chaine ne
représentent pas la fin de la chaine, c’est-à-dire pour lui indiquer qu’ils ne
possèdent pas ce sens spécial de délimiteurs.
Notez qu’on peut également utiliser une syntaxe alternative utilisant des triples
guillemets simples ou doubles pour entourer notre chaine et qui nous dispense
ainsi d’avoir à échapper les apostrophes et les guillemets dans notre chaine :
Lorsqu’on utilise l’interpréteur en mode interactif, comme on le fait dans ce

cours, l’interpréteur affiche les chaines entre guillemets simples. On peut utiliser
la fonction print() pour afficher les chaînes de manière plus lisible, en retirant
notamment les guillemets simples et doubles :
J’ai dit plus haut que pour définir une chaine de caractères il fallait l’entourer de
guillemets simples ou doubles droits. Réciproquement, toute valeur entourée par
des guillemets simples ou doubles sera considéré par Python comme une valeur
de type str (“str” = “string” = chaine de caractères).
Ainsi, si on stocke un ou plusieurs caractères représentant des chiffres comme “1”,

“2”, “123”, etc. en les entourant de guillemets simples ou doubles ceux-ci seront
considérés comme des valeurs de type str et non comme des valeurs de type int,
code>float ou complexe et on ne pourra pas effectuer les mêmes opérations.

Page 25 sur 91
Comme vous pouvez le voir, on n’obtient pas du tout les mêmes résultats
lorsqu’on additionne deux nombres ou lorsqu’on additionne (ou plus exactement
concatène) deux chaines.
Lorsqu’il est utilisé avec deux chaines, l’opérateur + est un opérateur de

concaténation et pas d’addition. “Concaténer” signifie “mettre bout à bout”. Nous
reparlerons de ce concept dans la prochaine leçon.
Finalement, vous pouvez également remarquer que Python nous renvoie une
erreur lorsqu’on tente d’additionner / de concaténer un entier avec une chaine.
Le type de valeurs bool ou booléen
Le dernier type de valeurs simple Python que je tenais à vous présenter est le
type bool (pour “booléen”).
Le type de valeur booléen est un type qui ne contient que deux valeurs qui servent
à représenter deux états. Les deux valeurs sont True (vrai) et False (faux). Attention
en Python à bien indiquer des majuscules car dans le cas contraire Python ne
reconnaitra pas ces booléens.
Pour stocker un booléen dans une variable, il ne faut pas utiliser de guillemets : si
on les utilise, ce seront les chaines de caractères “True” et “False” qui seront
stockés et on ne va pas pouvoir effectuer les mêmes opérations.
Les valeurs booléennes sont très utilisées en informatique. Elles sont notamment
très utiles pour valider ou invalider un test et sont au coeur des différentes
structures de contrôle en général.

Page 26 sur 91
5.3. Utiliser la fonction type() pour connaitre le type d’une valeur
On voudra souvent s’assurer qu’une variable contient bien une valeur d’un certain
type, notamment pour pouvoir effectuer différentes manipulations avec cette
variable.
Pour connaitre le type de valeur stockée dans une variable, on peut utiliser la
fonction Python type(). On va passer la variable à tester en argument de cette
fonction (c’est-à-dire écrire le nom de la variable entre les parenthèses de la
fonction). La fonction type() va alors tester la valeur contenue dans la variable et
renvoyer le type de cette valeur.
Ne faites pas attention pour le moment à l’indication “class” également renvoyée

par la fonction type(), nous verrons ce que ça signifie bien plus tard dans ce cours.

Page 27 sur 91
6. LES OPÉRATEURS PYTHON
Dans cette nouvelle leçon, nous allons définir ce qu’est un opérateur, établir la
liste des types d’opérateurs disponibles en Python et apprendre à en manipuler
certains.
6.1. Définition et liste des opérateurs Python
Un opérateur est un signe ou un symbole qui va nous permettre de réaliser une

opération. Le signe = par exemple est en Python l’opérateur d’affectation simple :
il permet d’affecter une valeur à une variable.
Python dispose de nombreux opérateurs qui peuvent être classés selon les
catégories suivantes :
 Les opérateurs arithmétiques ;

 Les opérateurs d’affectation ou d’assignation ;
 Les opérateurs de chaines ;
 Les opérateurs de comparaison ;
 Les opérateurs logiques ;
 Les opérateurs d’identité ;
 Les opérateurs d’appartenance ;
 Les opérateurs binaires.
Dans cette leçon, nous allons nous concentrer sur les opérateurs arithmétiques,
les opérateurs de chaines et sur les opérateurs d’affectation.
Nous étudierons les autres types d’opérateurs plus tard dans ce cours, lorsque nous
en aurons besoin pour illustrer certaines notions de Python.
6.2. Les opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations

mathématiques comme des additions, soustractions, multiplication, etc. entre
différentes variables contenant des valeurs numériques.

Page 28 sur 91
Python reconnait et accepte les opérateurs arithmétiques suivants :
Opérateur Nom
+ Addition
– Soustraction
* Multiplication
/ Division
% Modulo
** Puissance
// Division entière
Certains opérateurs nécessitent certainement qu’on s’attarde dessus.
Le modulo correspond au reste d’une division Euclidienne (division entière) tandis

que l’opérateur // permet d’obtenir le résultat entier d’une division (ou la partie
entière de ce résultat pour être tout à fait exact).
Le résultat de 13//3, par exemple, sera 4 tandis que le résultat de 13%3 sera 1 car
dans le cas d’une division entière 13/3 = 4 avec reste = 1.
L’opérateur puissance permet d’élever le nombre à gauche de l’opérateur à une

certaine puissance mentionnée à droite de l’opérateur. La “puissance” correspond
à la multiplication d’un nombre par lui même. Par exemple, écrire 2 ** 4
correspond à multiplier 2 par lui-même 4 fois ( = 2 * 2 * 2 * 2 = 16).

Page 29 sur 91
6.3. Les opérateurs de chaines
Les opérateurs de chaines vont nous permettre de manipuler des données de

type str (chaines de caractères) et par extension des variables stockant des
données de ce type.
Python met à notre disposition deux opérateurs de chaine : l’opérateur de

concaténation + et l’opérateur de répétition *.
L’opérateur de concaténation va nous permettre de mettre bout à bout deux

chaines de caractères afin d’en former une troisième, nouvelle.
L’opérateur de répétition va nous permettre de répéter une chaine un certain

nombre de fois.
Ces deux symboles remplissent donc un rôle relativement similaire que lorsqu’ils
sont utilisés avec des données de type numériques mais attention tout de même
de ne pas confondre le + utilisé pour additionner deux nombres et le + utilisé pour
concaténer deux chaines de caractères : on distingue ici bien deux opérateurs
différents même si le même symbole est utilisé.

Page 30 sur 91
6.4. Les opérateurs d’affection simple et composés Python
Nous connaissons déjà bien l’opérateur d’affectation simple Python =. Cet

opérateur permet d’affecter ou d’assigner une valeur à une variable.
Python reconnait également des opérateurs d’affectation qu’on appelle

“composés” et qui vont nous permettre d’effectuer deux opérations à la suite : une
première opération de calcul suivie immédiatement d’une opération d’affectation.
Ces opérateurs vont donc nous permettre de réduire la taille de notre code en
nous offrant une écriture simplifiée. Voici la liste des opérateurs d’affectation
supportés par Python et leur équivalent en “version longue” :
Equivalent
Opérateur Exemple Description
à
= x=1 x=1 Affecte 1 à la variable x
Ajoute 1 à la dernière valeur connue de x et affecte la

+= x += 1 x=x+1
nouvelle valeur (l’ancienne + 1) à x
Enlève 1 à la dernière valeur connue de x et affecte la

-= x -= 1 x=x–1
nouvelle valeur à x
Mutliplie par 2 la dernière valeur connue de x et affecte la

*= x *= 2 x=x*2
Divise par 2 la dernière valeur connue de x et affecte la

/= x /= 2 x=x/2
Calcule le reste de la division entière de x par 2 et affecte

%= x %= 2 x=x%2
ce reste à x

Page 31 sur 91
Equivalent
Opérateur Exemple Description
à
Calcule le résultat entier de la division de x par 2 et

//= x //= 2 x = x // 2
affecte ce résultat à x
Elève x à la puissance 4 et affecte la nouvelle valeur dans

**= x **= 4 x = x ** 4
x
Vous pouvez également déjà noter qu’il existe également les opérateurs
d’affectation combinés &=, |=, ^=, >>= et <<= qui vont permettre d’effectuer des
opérations dont nous discuterons plus tard et d’affecter le résultat de ces
opérations directement à une variable.
Entrainons nous immédiatement avec ces opérateurs pour commencer à se

familiariser avec eux :

Page 32 sur 91
7. LES LISTES PYTHON
Dans cette leçon, nous allons découvrir un premier type de données composites
Python : les listes. Nous allons comprendre l’intérêt de ce type de données et
apprendre à les manipuler.
7.1. Présentation des listes Python
Jusqu’à présent, nous n’avons stocké qu’une seule valeur à la fois dans nos
variables. Les listes sont un type de données très particulier au sens où elles
représentent des données composées ou combinées. Une liste est en effet par
définition composée d’une suite de valeur ou d’éléments.
Pour définir une nouvelle liste en Python, on va devoir utiliser une paire de
crochets [ ]. Nous allons placer les différents éléments de notre liste dans ces
crochets en les séparant par des virgules. On peut par exemple créer une liste de 5
éléments et la placer dans une variable liste comme ceci :
Notre liste est ici composée de 5 valeurs de type numérique. On va pouvoir stocker
tous types de valeurs dans une liste, comme des chaines de caractères par exemple
:
De plus, vous devez savoir que tous les éléments d’une liste n’ont pas à être du
même type, on va très bien pouvoir créer des listes composées de nombres,
chaines et booléens par exemple :

Page 33 sur 91
Note : Si vous avez déjà étudié un langage de script par le passé, les liste doivent
vous faire penser à ce qu’on appelle communément dans ces autres langages des
tableaux. En effet, les listes Python sont très proches des tableaux (numérotés)
qu’on peut retrouver dans de nombreux autres langages.
7.2. Récupérer une ou plusieurs valeurs dans une liste
Les listes Python sont par défaut indexées ou indicées. Cela signifie que chaque
valeur d’une liste est lié à un indice qu’on va pouvoir utiliser pour récupérer cette
valeur en particulier.
Les listes possèdent des indices numériques qui commencent à 0. La première

valeur d’une liste possède donc toujours l’indice 0, la deuxième valeur l’indice 1, la
troisième valeur l’indice 2 et etc.
Pour récupérer une valeur en particulier dans une liste, on va devoir préciser le
nom de la liste suivi de l’indice de cette valeur entre crochets. Notez que les
indices négatifs sont acceptés; dans ce cas on partira de la fin de la liste (l’indice -1
correspond au dernier élément, -2 à l’avant dernier et etc.).
On va également pouvoir récupérer une tranche de valeurs dans une liste, c’est-à-
dire un ensemble de valeurs qui se suivent. Pour cela, on utilisera le
symbole : entre les crochets avec 0, 1 ou 2 indices autour.
Si on utilise : sans indice, alors une copie superficielle de la liste sera renvoyée. Si
on mentionne un indice avant : mais pas d’indice après, alors une copie
superficielle partielle de la liste de départ sera renvoyée, en commençant à copier
à partir de l’indice donné. Si au contraire on mentionne un indice après : mais pas
d’indice avant, une copie superficielle partielle de la liste de départ sera renvoyée
qui commence au début de la liste et jusqu’à l’indice donné. Enfin, si deux indice
sont mentionnés de part et d’autre de :, la tranche de valeurs correspondant à ces
indices sera renvoyée.

Page 34 sur 91
Vous devez également savoir que ce qu’on a vu jusqu’ici sur les listes s’applique
également aux chaines de caractères. Les chaînes de caractères peuvent en effet
également être indexées, ce qui signifie qu’on peut accéder aux caractères par leur
position). Cela est logique après tout : les chaines de caractères sont des
“séquences” de caractères tandis que les listes sont des “séquences” de valeurs.
Comme pour les listes, le premier caractère d’une chaîne possède l’indice 0, le
deuxième l’indice 1 et etc; On va également pouvoir utiliser des indices négatifs et
récupérer des tranches avec :.
Notez qu’il n’existe pas de type distinct pour les caractères en Python : un
caractère est simplement une chaîne de longueur 1.
7.3. Ajouter, supprimer, modifier des éléments d’une liste
A la différence des types de données simples comme les chaines qui sont
immuables, les listes sont un type de données altérable ce qui signifie qu’on va
pouvoir altérer leur structure ou modifier leur contenu en ajoutant, supprimant
ou remplaçant des valeurs.
En effet, vous devez bien comprendre qu’une fois qu’on définit une valeur “chaine
de caractères” par exemple, celle-ci ne peut plus être modifiée par la suite. Les
seules opération qu’on va pouvoir faire vont être de créer une nouvelle chaine en
concaténant deux chaines d’origine (qui une nouvelle fois ne seront pas modifiées)

Page 35 sur 91
ou de remplacer une chaine par une autre valeur en affectant une nouvelle valeur
dans une variable (ce qui a pour effet d’écraser la chaine de départ).
Au contraire des chaines, on va tout à fait pouvoir ajouter, modifier ou supprimer

des valeurs dans une liste. Pour cela, on va mentionner le nom de notre liste avec
l’indice de la ou des éléments à ajouter / modifier et leur affecter une nouvelle
valeur. Les affectations de tranches sont possibles :
Notez finalement également qu’on va aussi pouvoir utiliser les opérateurs de

concaténation et de répétition avec des listes :

Page 36 sur 91
8. LES TUPLES PYTHON
Dans cette leçon, nous allons nous intéresser à un nouveau type de données composites Python
qui peut faire penser aux listes à premières vue : les tuples. Nous allons souligner les différences
entre les listes et les tuples, voir les cas d’usage des tuples et apprendre à créer des tuples.
8.1. Présentation des tuples et cas d’utilisation
Les chaines de caractères et les listes sont deux types séquentiels de données : ce
sont des données qui sont organisées sous la forme de séquence de caractères ou
de valeurs. Les tuples sont un autre type séquentiel de données.
Les tuples ressemblent aux listes : un tuple consiste en différentes valeurs

entourées par des virgules. Notez qu’on encadre généralement les valeurs d’un
tuple avec un couple de parenthèses même si cela n’est pas obligatoire.
Les tuples peuvent contenir différents types de valeurs comme des nombres, des
chaines, des listes etc. et même d’autres tuples imbriqués. Illustrons
immédiatement cela :
La grande différence entre un tuple et une liste est qu’un tuple est une donnée
immuable à la différence d’une liste qui est altérable. Cela signifie qu’on ne va pas
pouvoir modifier les valeurs d’un tuple après sa création.
Il va donc être intéressant d’utiliser des tuples plutôt que des listes dans les cas où
on veut s’assurer que les données ne soient pas modifiées dans un programme.

Page 37 sur 91
8.2. Création d’un tuple vide ou à une valeur
Notez que dans le cas où on souhaite créer un tuple vide, on utilisera une paire de
parenthèses vides. Si on souhaite créer un tuple avec une seule valeur, alors il
faudra faire suivre cette valeur d’une virgule.
8.3. Le déballage de séquence
Une fonctionnalité intéressante des tuples est le “déballage de séquence”. Un

déballage de séquence correspond à une façon rapide d’affecter les différentes
valeurs d’un tuple dans des variables séparées. Pour cela, il va nous falloir autant
de variables qu’il y a de valeurs dans notre tuple. Ensuite, il va falloir respecter la
syntaxe variable1, variable2 … = tuple comme ceci :
Attention ici : il faut bien faire attention à écrire les variables qui vont recevoir les
valeurs du tuple avant le tuple car dans le cas contraire cela ne fonctionnerait
pas.

Page 38 sur 91
9. LES DICTIONNAIRES PYTHON
Dans cette leçon, nous allons nous intéresser à un autre type de données Python
composites : les dictionnaires. Nous allons découvrir l’intérêt des dictionnaires et
apprendre à manipuler ce nouveau type de données.
9.1. Présentation des dictionnaires Python
Les dictionnaires sont un type natif de données Python. Ce type de données peut,
de la même façon que les données séquentielles, contenir plusieurs valeurs et
chaque valeur va être indexée ce qui signifie qu’un indice unique va être attribué à
chaque valeur.
La grande différence entre les données séquentielles et les dictionnaires se situe

dans la façon d’indexer les valeurs et dans la nature de l’index. Dans le cas des
séquences, les différentes valeurs dont associées à des index numériques
commençant à 0.
Les dictionnaires nous laissent une bien plus grande liberté ici puisqu’on va
pouvoir choisir nous mêmes nos clefs (ou index ou indice) et attribuer la clef de
notre choix à chaque valeur à partir du moment où cette clef n’est pas déjà
utilisée dans ce dictionnaire et où la clef est une valeur immuable. La
conséquence de cela est que les valeurs d’un dictionnaire ne sont pas ordonnées à
la différence des valeurs d’une séquence.
Si vous avez des notions en PHP ou dans certains autres langages de script, vous
pouvez retenir que les dictionnaires Python sont l’équivalent des tableaux
associatifs dans ces langages.

Page 39 sur 91
9.2. Création d’un dictionnaire Python
Pour créer un nouveau dictionnaire, nous allons devoir utiliser un couple

d’accolades { } et définir les paires clef : valeur à l’intérieur des accolades comme
ceci :
Comme vous pouvez le voir dans l’exemple ci-dessus, on utilise une nouvelle fois le
syntaxe avec des crochets pour lire les différentes valeurs de notre dictionnaire.
Pour être tout à fait précis, on passe ici une clef entre crochets pour récupérer la
valeur qui lui est associée.
9.3. Ajout et modification de valeurs dans un dictionnaire
Les dictionnaires sont altérables, ce qui signifie qu’on va pouvoir modifier ou

ajouter des valeurs dans un dictionnaire après sa création.
Pour cela, on va tout simplement utiliser le nom de notre dictionnaire suivi d’un
couple de crochets [ ] en passant une clef entre ces crochets puis affecter une
valeur à cette clef. Dans le cas où la clef existe déjà, l’ensemble clef : valeur n’est
pas ajouté mais la valeur originellement liée à la clef est plutôt remplacée par la
nouvelle valeur.
Illustrons immédiatement cela avec quelques exemples de manipulation des

données de dictionnaires Python :

Page 40 sur 91
Pour supprimer une paire clef : valeur d’un dictionnaire, nous allons utiliser
l’instruction del (abréviation de “delete” = supprimer en anglais) suivi du nom du
dictionnaire avec la clef de l’élément à supprimer entre crochets comme ceci :

Page 41 sur 91
10. LES ENSEMBLES OU SETS PYTHON
Dans cette leçon, nous allons voir un nouveau type de données Python : les
ensembles ou “set”. Nous allons découvrir l’intérêt de ce type de données et
comment créer des ensembles Python.
10.1. Présentation des ensembles ou sets Python
Les ensemble ou sets forment un autre type de données composites Python. Un

ensemble est une collection d’éléments non ordonnée, sans index et qui ne peut
pas posséder l’élément dupliqué.
Une des utilisation les plus courantes des ensembles est de les utiliser pour
supprimer des valeurs doublons à partir d’un autre type de données.
Pour créer un ensemble, nous allons utiliser une paire d’accolades { } en placer les
différents éléments de notre ensemble entre ces accolades en les séparant avec
une virgule.
Notez que pour créer un ensemble vide il faudra utiliser la fonction set() car la
syntaxe { } va créer un dictionnaire vide et non pas un ensemble vide.
10.2. Récapitulatif sur les types de données et sur les types composites Python
Dans cette partie, nous avons étudié des types de données simples et des types de
données composites (des données composées de plusieurs éléments) Python.

Page 42 sur 91
Les types de données simples étudiés sont les Nombre (entier, décimaux ou
complexes), les Booléens et les Chaines de caractères. Il sont facile à manier et il
est simple de savoir quand utiliser une type plutôt qu’un autre.
Les types de données composite étudiés sont les listes, les tuples, les dictionnaires
et les ensembles. Il est généralement moins évident de choisir quel type de
données utiliser ici car on a tendance à penser “qu’ils se ressemblent tous”.
Voici donc un résumé des grandes caractéristiques de ces types et se qui les
différencie :
 Les listes sont des collections d’éléments ordonnés et altérables qui peuvent contenir
plusieurs fois la même valeur ;
 Les tuples sont des collections d’éléments ordonnés et immuables qui peuvent contenir
plusieurs fois la même valeur ;
 Les dictionnaires sont des collection d’éléments non ordonnés mais indexés avec des clefs
de notre choix et altérables qui n’acceptent pas de contenir plusieurs fois le même
élément ;
 Les ensembles sont des collections d’éléments non ordonnées, non indexés et non
modifiables qui n’acceptent pas de contenir plusieurs fois le même élément.

Page 43 sur 91
11. LES STRUCTURES CONDITIONNELLES IF, IF…ELSE ET IF…ELIF…ELSE EN

PYTHON
Dans cette nouvelle partie, nous allons étudier et comprendre l’intérêt des
structures de contrôle en Python. Une structure de contrôle est un ensemble
d’instructions qui permet de contrôler l’exécution du code.
Il existe différents types de structures de contrôle. Les deux types de structures les
plus communément utilisées sont les structures de contrôle conditionnelles qui
permettent d’exécuter un bloc de code si une certaine condition est vérifiée et les
structures de contrôle de boucle qui permettent d’exécuter un bloc de code en
boucle tant qu’une condition est vérifiée.
11.1. Présentation des conditions Python
Les structures de contrôle conditionnelles (ou plus simplement conditions) vont

nous permettre d’exécuter différents blocs de code selon qu’une condition
spécifique soit vérifiée ou pas.
Nous allons très souvent utiliser les conditions avec des variables : selon la valeur
stockée dans une variable, nous allons vouloir exécuter un bloc de code plutôt
qu’un autre.
Python nous fournit les structures conditionnelles suivantes :
 La condition if (“si”) ;
 La condition if…else (“si…sinon”) ;
 La condition if…elif…else (“si…sinon si… sinon”) .
Nous allons étudier et comprendre l’intérêt de chacune de ces conditions dans la
suite de cette leçon. Avant de les étudier, cependant, nous allons devoir présenter
un nouveau type d’opérateurs : les opérateurs de comparaison qui vont être au
centre de nos conditions.

Page 44 sur 91
11.2. Les opérateurs de comparaison
Comme je l’ai précisé plus haut, nous allons souvent construire nos conditions
autour de variables : selon la valeur d’une variable, nous allons exécuter tel bloc de
code ou pas.
Pour pouvoir faire cela, nous allons comparer la valeur d’une variable à une
certaine autre valeur donnée et selon le résultat de la comparaison exécuter un
bloc de code ou pas. Pour comparer des valeurs, nous allons devoir utiliser des
opérateurs de comparaison.
Voici ci-dessous les différents opérateurs de comparaison disponibles en Python

ainsi que leur signification :
Opérateur Définition
== Permet de tester l’égalité en valeur et en type
!= Permet de tester la différence en valeur ou en type
< Permet de tester si une valeur est strictement inférieure à une autre
> Permet de tester si une valeur est strictement supérieure à une autre
<= Permet de tester si une valeur est inférieure ou égale à une autre
>= Permet de tester si une valeur est supérieure ou égale à une autre
Notez bien ici que ces opérateurs ne servent pas à indiquer à Python que telle
valeur est supérieure, égale, inférieur ou différente à telle autre valeur. Lorsqu’on
utilise un opérateur de comparaison, on demande au contraire à Python de tester
si telle valeur est supérieure, égale, inférieur ou différente à telle autre valeur.
Python va donc comparer les deux valeurs et toujours renvoyer un booléen
: True si la comparaison est vérifiée ou False dans le cas contraire.

Page 45 sur 91
Notez également que les opérateurs de comparaison d’égalité et de différence

testent l’égalité et la différence à la fois sur les valeurs et sur les types. Ainsi, si on
demande à Python de tester l’égalité entre la chaine de caractères “4” et le chiffre
4, celui-ci renverra False puisque pour lui ces deux valeurs ne sont pas égales.
Regardez plutôt les exemples suivants pour vous en persuader :
Vous pouvez retenir ici que c’est cette valeur booléenne renvoyée par le Python à
l’issue de toute comparaison que nous allons utiliser pour faire fonctionner nos
conditions.
11.3. La condition if en Python
La structure conditionnelle if est une structure de base qu’on retourne dans de

nombreux langages de script. Cette condition va nous permettre d’exécuter un
code si (et seulement si) une certaine condition est vérifiée.
On va en fait passer une expression à cette condition qui va être évaluée par
Python. Cette expression sera souvent une comparaison explicite (une
comparaison utilisant les opérateurs de comparaison) mais pas nécessairement.
Si Python évalue l’expression passée à True, le code dans la condition if sera

exécuté. Dans le cas contraire, le code dans if sera ignoré.
Prenons immédiatement un premier exemple afin de nous familiariser avec le

fonctionnement et la syntaxe de cette condition :

Page 46 sur 91
Nous créons ici deux conditions if. Comme vous pouvez le voir, la syntaxe générale
d’une condition if est if condition : code à exécuter. Pensez bien à indiquer le : et à
bien indenter le code qui doit être exécuté si la condition est vérifiée sinon votre
condition ne fonctionnera pas.
Dans le premier if, nous demandons à Python dévaluer la comparaison x > y.

Comme notre variable x stocke 8 et que notre variable y stocke 4, Python valide
cette comparaison et renvoie True. La condition if reçoit True et le code qu’elle
contient est exécuté.
Dans notre deuxième if, on demande cette fois-ci à Python de nous dire si le
contenu de x est égal au chiffre 5. Ce n’est pas le cas et donc Python
renvoie False et le code dans ce if n’est donc pas exécuté.
Au final, vous pouvez retenir que toute expression qui suit un if va être évaluée
par Python et que Python renverra toujours soit True, soit False. Nous n’avons
donc pas nécessairement besoin d’une comparaison explicite pour faire
fonctionner un if.
Pour comprendre cela vous devez savoir qu’en dehors des comparaisons Python
évaluera à True toute valeur passée après if à l’exception des valeurs suivantes qui
seront évaluées à False :
 La valeur 0 (et 0.0) ;

 La valeur None ;
 Les valeurs chaine de caractères vide ””, liste vide [], dictionnaire vide {} et tuile vide ().

Page 47 sur 91
11.4. La condition if… else en Python
Avec la condition if, nous restons relativement limités puisque cette condition
nous permet seulement d’exécuter un bloc de code si que le résultat d’un test soit
évalué à True.
La structure conditionnelle if…else (« si… sinon » en français) est plus complète

que la condition if puisqu’elle nous permet d’exécuter un premier bloc de code si
un test renvoie True ou un autre bloc de code dans le cas contraire.
La syntaxe d’une condition if…else va être la suivante :
Ici, on demande dans notre première condition à Python d’évaluer si la valeur

de x est différente du chiffre 5 ou pas. Si c’est le cas, Python
renverra True (puisqu’on lui demande ici de tester la différence et non pas
l’égalité) et le code du if sera exécuté. Dans le cas contraire, c’est le code du else qui
sera exécuté.
Notre deuxième condition fait exactement le même travail mais cette fois si on
compare la valeur de yà 5.
Notez bien ici qu’on n’effectuera jamais de test dans un else car le else est par
définition censé prendre en charge tous les cas non pris en charge par le if.

Page 48 sur 91
11.5. La condition if… elif… else en Python
La condition if…elif…else (« si…sinon si…sinon ») est une structure conditionnelle

encore plus complète que la condition if…else qui vannons permettre cette fois-ci
d’effectuer autant de tests que l’on souhaite et ainsi de prendre en compte le
nombre de cas souhaité.
En effet, nous allons pouvoir ajouter autant de elif que l’on souhaite entre le if de
départ et le else de fin et chaque elif va pouvoir posséder son propre test ce qui va
nous permettre d’apporter des réponses très précises à différentes situations.
Il faut cependant faire attention à un point en particulier lorsqu’on utilise une

structure Python if… elif… else : le cas où plusieurs elif possèdent un test évalué
à True par Python. Dans ce cas là, vous devez savoir que seul le code du
premier elif (ou du if si celui-ci est évalué à True) va être exécuté. En effet, Python
sort de la structure conditionnelle dans son ensemble sans même lire ni tester la
fin de celle-ci dès qu’un cas de réussite à été rencontré et que son code a été
exécuté.

Page 49 sur 91
12. CRÉER DES CONDITIONS PYTHON COMPLEXES
Dans cette nouvelle leçon, nous allons aller plus loin avec les conditions Python est voir comment
créer des conditions complexes en utilisant notamment les opérateurs logiques et les opérations
d’appartenance.
12.1. Imbriquer des conditions
Souvent, nous allons vouloir comparer plusieurs valeurs au sein d’une même
condition, c’est-à-dire n’exécuter son code que si plusieurs conditions sont
vérifiées.
Pour faire cela, nous allons pouvoir soit utiliser plusieurs opérateurs de
comparaison, soit les opérateurs logiques, soit imbriquer plusieurs conditions les
unes dans les autres.
Les opérateurs logiques vont nous permettre de créer des conditions plus
puissantes mais dans certains cas il sera plus intéressant et plus rapide
d’imbriquer des conditions.
Dans cet exemple, on imbrique deux structures if…else l’une dans l’autre. La
première structure demande à Python de tester si notre variable x contient un
nombre strictement inférieur à 5. Si c’est le cas, on rentre dans le if et on teste
donc la condition du deuxième if. Dans le cas contraire, on va directement
au else de fin.
Notre deuxième condition teste si y contient une valeur strictement inférieure à

10. Si c’est le cas, on exécute le code dans la condition. Sinon, on va directement
au else de cette condition imbriquée.

Page 50 sur 91
12.2. Utiliser les opérateurs logiques avec les conditions
Les opérateurs logiques vont être principalement utilisés avec les conditions
puisqu’ils vont nous permettre d’écrire plusieurs comparaisons au sein d’une
même condition ou encore d’inverser la valeur logique d’un test.
Opérateur Définition
and Renvoie True si toutes les deux expressions sont évaluées à True
or Renvoie True si une des comparaisons vaut True
not Renvoie True si la comparaison vaut False (et inversement)
Les opérateurs logiques and et or vont nous permettre de passer plusieurs tests
pour évaluation à Python. On va par exemple pour tester si une
variable x contient une valeur inférieure à 5 et / ou si y contient une valeur
inférieure à 10 au sein d’une même condition.
Dans le cas où on utilise and, chaque expression devra être évaluée à True par
Python pour que le code dans la condition soit exécuté.
Dans le cas où on utilise or, il suffit qu’une expression soit évaluée à True par
Python pour que le code dans la condition soit exécuté.

Page 51 sur 91
Ici, vous pouvez noter que Python a l’inverse de la plupart des autres langages
possède une syntaxe très logique et très intuitive qui va nous permettre
d’effectuer plusieurs tests dans une condition “comme si” on utilisait un opérateur
logique and en utilisant tout simplement plusieurs opérateurs de comparaison à
la suite.
Je vous recommande cependant plutôt d’utiliser des opérateurs logiques dans

cette situation afin de rendre votre code plus clair.
Finalement, l’opérateur logique not est très particulier puisqu’il nous permet
d’inverser la valeur logique d’un test : si Python renvoie False à l’issue d’une
évaluation par exemple et qu’on utilise l’opérateur not sur cette expression
l’opérateur inversera la valeur renvoyée par Python et la valeur finale passée à la
condition sera True.
12.3. Présentation des opérateurs d’appartenance ou d’adhésion
Python met à notre disposition deux opérateurs d’appartenant qui vont nous
permettre de tester si une certaine séquence de caractères ou de valeurs est
présente ou pas dans une valeur d’origine.
Ces opérateurs ne vont fonctionner qu’avec des séquences (chaines de caractères,

listes, etc.) et ne vont donc pas marcher avec des valeurs de type numérique par
exemple.
L’opérateur in permet de tester si une certaine séquence de caractères ou de

valeurs est présente dans une valeur d’origine et renvoie True si c’est le cas.

Page 52 sur 91
L’opérateur not in permet au contraire de tester si une certaine séquence de

caractères ou de valeurs n’est pas présente dans une valeur d’origine et
renvoie True si c’est le cas.
Comme des valeurs booléennes sont renvoyées, on va tout à fait pouvoir utiliser ce
type d’opérateurs au sein de nos conditions même si ils sont communément plus
utilisés au sein de boucles qu’on étudiera dans la prochaine leçon.
12.4. Un point sur l’ordre de priorité des opérateurs
Dans les exemples précédents, nous avons utilisé plusieurs opérateurs différents
dans nos conditions : des opérateurs de comparaisons divers, des opérateurs
logiques, etc.
Rien ne nous empêche à priori de rajouter des opérateurs arithmétiques et

d’utiliser plusieurs opérateurs logiques dans ces mêmes conditions.
A partir de là, cependant, il faut commencer à être très rigoureux pour obtenir des
résultats conformes à nos attentes et il va notamment falloir bien connaitre
l’ordre de priorité d’application des différents opérateurs en Python.
Ci-dessous, vous pourrez trouver l’ordre de traitement de chaque opérateur

Python (classés du plus prioritaire au moins prioritaire). Certains nous sont
encore inconnus, je vous demande de ne pas vous en préoccuper pour le moment.
Opérateur Description
() Opérateur de groupement
** Elévation à la puissance

Page 53 sur 91
Opérateur Description
~ Opérateur d’inversion de bit
Opérateurs arithmétiques multiplication, division

*, /, %
et modulo
<<, >> Décalage de bits à gauche ou à droite
& Définit chaque bit à 1 si les deux bits valent 1
Définit chaque bit à 1 si seulement l’un des deux

^
bits vaut 1
Définit chaque bit à 1 si au moins l’un des deux

|
bits vaut 1
Opérateurs de comparaison, d’appartenance et

==, !=, <, <=, >, >=, in, not in, is, is not
d’identité
not Opérateur logique (booléen) inverse ou “non”
and Opérateur logique (booléen) “et”
or Opérateur logique (booléen) “ou”

Page 54 sur 91
13. LES BOUCLES PYTHON FOR ET WHILE
Les boucles, tout comme les conditions, sont une structure de contrôle Python de
base et il est donc essentiel de comprendre comment elles fonctionnent et de
savoir les utiliser.
13.1. Présentation des boucles en Python
Les boucles vont nous permettre d’exécuter plusieurs fois un bloc de code, c’est-à-
dire d’exécuter un code « en boucle » tant qu’une condition donnée est vérifiée.
Lorsqu’on code, on va en effet souvent devoir exécuter plusieurs fois un même

code. Utiliser une boucle nous permet de n’écrire le code qu’on doit exécuter
plusieurs fois qu’une seule fois.
Nous allons ainsi pouvoir utiliser les boucles pour parcourir les valeurs d’une
variable de liste liste ou pour afficher une suite de nombres.
Nous avons accès à deux boucles en Python :
 La boucle while (“tant que…”) ;

 La boucle for (“pour…”).
Le fonctionnement général des boucles sera toujours le même : on pose une
condition qui sera généralement liée à la valeur d’une variable et on exécute le
code de la boucle « en boucle » tant que la condition est vérifiée.
Pour éviter de rester bloqué à l’infini dans une boucle, vous pouvez donc déjà
noter qu’il faudra que la condition donnée soit fausse à un moment donné (pour
pouvoir sortir de la boucle). Selon le type de condition, on va avoir différents
moyens de faire cela. Nous allons voir les plus courants dans la suite de cette
leçon.

Page 55 sur 91
13.2. La boucle Python while
La boucle while va nous permettre d’exécuter un certain bloc de code « tant

qu’une » condition donnée est vérifiée. Sa syntaxe est la suivante :
On commence ici par créer une variable x et on stocke la valeur 0 dedans.
On crée ensuite notre boucle while qui va baser sa condition de sortie autour de la
valeur de la variable x.
Littéralement, cette boucle signifie “tant que x stocke une valeur strictement
inférieure à 10, affiche la valeur de x puis ajoute 1 à cette valeur”.
Lors du premier tour dans la boucle, x stocke la valeur 0 qui est bien inférieure à
10. On rentre donc dans la boucle, on affiche la valeur de x et on ajoute 1 à cette
valeur.
Une fois arrivés en fin de boucle, on retourne au début de la boucle. On teste à

nouveau si x contient une valeur inférieure à 10. C’est le cas puisque x stocke
désormais 1. On affiche à nouveau la valeur de x et on lui ajoute à nouveau 1.
On retourne à nouveau au début de la boucle et etc. Jusqu’à ce que la condition de

sortie soit vérifiée, c’est-à-dire jusqu’à ce que x stocke une valeur supérieure ou
égale à 10. Dans ce cas là, la boucle est ignorée et on passe à l’instruction suivante.
Note : Lorsqu’on ajoute 1 à une variable, on dit qu’on l’incrémente. À l’inverse,

lorsqu’on enlève 1 à la valeur d’une variable, on dit qu’on la décrémente. Les
opérations d’incrémentation et de décrémentation sont très fréquentes au sein
des boucles. On s’en sert généralement pour que la condition d’exécution de la
boucle soit fausse à un moment donnée.

Page 56 sur 91
13.3. La boucle Python for
La boucle Python for possède une logique et une syntaxe différente de celles des
boucle for généralement rencontrées dans d’autres langages.
En effet, la boucle for Python va nous permettre d’itérer sur les éléments d’une
séquence (liste, chaine de caractères, etc.) selon leur ordre dans la séquence.
La condition de sortie dans cette boucle va être implicite : on sortira de la boucle

après avoir parcouru le dernier élément de la séquence.
La syntaxe de cette boucle va être la suivante :
13.4. La fonction range()
On va pouvoir utiliser la fonction range() pour itérer sur une suite de nombres
avec une boucle for.
Cette fonction permet de générer une suite de valeurs à partir d’une certain
nombre et jusqu’à un autre avec un certain pas ou intervalle.
Dans son utilisation la plus simple, nous allons nous contenter de passer un
nombre en argument (entre les parenthèses) de range(). Dans ce cas, la fonction
génèrera une suite de valeurs de 0 jusqu’à ce nombre – 1 avec un pas de
1. range(5) par exemple génère les valeurs 0, 1, 2, 3 et 4.
Si on précise deux nombres en arguments de cette fonction, le premier nombre

servira de point de départ pour la génération de nombres tandis que le second
servira de point d’arrivée (en étant exclus). range(5, 10) par exemple permet de
générer les nombres 5, 6, 7, 8 et 9.

Page 57 sur 91
Finalement, on peut préciser un troisième et dernier nombre en argument

de range() qui nous permet de préciser son pas, c’est-à-dire l’écart entre deux
nombres générés. Ecrire range(0, 10, 2) par exemple permet de générer les nombres
0, 2, 4, 6 et 8.
On va pouvoir utiliser la fonction range() plutôt qu’une variable de type séquence

avec nos boucles for pour itérer sur une suite de nombres.
13.5. Les instructions break et continue
Les instructions break et continue sont deux instructions qu’on retrouve dans de
nombreux langages et qui sont souvent utilisées avec les boucles mais qui peuvent
être utilisées dans d’autres contextes.
L’instruction break permet de stopper l’exécution d’une boucle lorsqu’une certaine

condition est vérifiée. On l’inclura souvent dans une condition de type if.
Par exemple, on va pouvoir stopper l’exécution d’une boucle lorsqu’une variable

contient une valeur en particulier.

Page 58 sur 91
L’instruction continue permet elle d’ignorer l’itération actuelle de la boucle et de

passer directement à l’itération suivante. Cette instruction va donc nous
permettre d’ignorer toute ou partie de notre boucle dans certaines conditions et
donc de personnaliser le comportement de notre boucle.

Page 59 sur 91
14. INTRODUCTION AUX FONCTIONS PYTHON
Dans cette nouvelle partie, nous allons étudier une autre notion incontournable
de tout langage de programmation qui se respecte : les fonctions. Nous allons
notamment définir ce qu’est une fonction et comprendre l’intérêt d’utiliser ces
structures puis nous verrons comment créer nos propres fonction en Python ainsi
que certains concepts avancés relatifs aux fonctions.
14.1. Qu’est-ce qu’une fonction ?
Une fonction est un bloc de code nommé. Une fonction correspond à un ensemble
d’instructions créées pour effectuer une tâche précise, regroupées ensemble et
qu’on va pouvoir exécuter autant de fois qu’on le souhaite en “l’appelant” avec son
nom. Notez “qu’appeler” une fonction signifie exécuter les instructions qu’elle
contient.
L’intérêt principal des fonctions se situe dans le fait qu’on va pouvoir appeler une
fonction et donc exécuter les instructions qu’elle contient autant de fois qu’on le
souhaite, ce qui constitue au final un gain de temps conséquent pour le
développement d’un programme et ce qui nous permet de créer un code beaucoup
plus clair.
Il existe deux grands “types” de fonctions en Python : les fonctions prédéfinies et

les fonctions créées par l’utilisateur.
14.2. Les fonctions prédéfinies Python
Les fonction prédéfinies sont des fonctions déjà créées et mises à notre disposition
par Python. Dans ce cours, nous avons déjà utilisé des fonctions prédéfinies
comme la fonction print() ou la fonction type() par exemple.
Ici, je tiens à rappeler qu’en programmation rien n’est magique : la

“programmation”… ne représente que des séries d’instruction programmées.

Page 60 sur 91
Lorsqu’on a utilisé print() pour afficher des données pour la première fois
ou type() pour connaitre le type d’une donnée, on ne s’est pas posé la question de
ce qu’il se passait en arrière plan.
En fait, ces deux fonctions sont des fonctions complexes et qui contiennent de
nombreuses lignes d’instructions leur permettant d’accomplir une tâche précise :
l’affichage d’un résultat ou la détermination du type d’une valeur en l’occurence.
Cette complexité nous est cachée : nous n’avons qu’à appeler nos fonctions pour
qu’elles fassent leur travail et n’avons pas à écrire la série d’instructions qu’elles
contiennent à chaque fois et c’est tout l’intérêt des fonctions.
Python, dans sa version 3.7.4, met à notre disposition quasiment 70 fonctions

prédéfinies (sans compter les fonctions des modules ou extensions dont nous
parlerons plus tard). Vous pouvez déjà trouver la liste ci-dessous. Nous serons
amenés à utiliser la plupart d’entre elles dans ce cours ; nous les définirons à ce
moment là. Considérez le tableau ci-dessous comme une simple référence.
Liste des fonction prédéfinies Python 3.7.4
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()

Page 61 sur 91
Liste des fonction prédéfinies Python 3.7.4
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import()__
complex() hasattr() max() round()
14.3. Les fonction Python définies par l’utilisateur
En plus des fonction prédéfinies, Python nous laisse la possibilité de définir nos
propres fonctions. Ces fonctions ne seront bien évidemment disponibles et
utilisables que dans l’espace où elles ont été définies, c’est-à-dire uniquement au
sein de nos scripts et non pas pour l’ensemble des développeurs utilisant Python.
On va vouloir créer nos propres fonctions Python lorsque nos programmes

utilisent de manière répétées une même série d’instructions : plutôt que de
réécrire ces instructions à chaque fois, autant utiliser une fonction !
Les fonctions vont aussi être de très bons outils d’abstraction lorsqu’on voudra
distribuer notre code : on préférera souvent fournir des fonctions à utiliser aux

Page 62 sur 91
autres développeurs plutôt que de les laisser se débrouiller avec des séries
d’instructions “sauvages”.
Pour définir une nouvelle fonction en Python, nous allons utiliser le mot
clef def qui sert à introduire une définition de fonction. Ce mot clef doit être suivi
du nom de la fonction, d’une paire de parenthèses au sein desquelles on pourra
fournir une liste de paramètres (nous reviendrons là dessus plus tard) et de : pour
terminer la ligne comme ceci def ma_fonction():.
Le nom d’une fonction Python doit respecter les normes usuelles concernant les
noms : un nom de fonction doit commencer par une lettre ou un underscore et
ne contenir que des caractères alphanumériques classiques (pas d’accent ni de
cédille ni aucun caractère spécial).
Notez que les noms de fonctions sont sensibles à la casse en Python, ce qui signifie
que les
fonctions ma_fonction(), Ma_fonction(), ma_FONCtion() et MA_FONCTION() par
exemple seront des fonctions bien différentes pour Python.
Nous allons ensuite placer la liste des différentes instructions de notre fonction à
la ligne suivant sa définition et en les indentant par rapport à la définition afin
que Python comprenne que ces instructions appartiennent à notre fonction.
Notez que la première instruction d’une fonction peut être une chaîne de
caractères littérale qui sera alors utilisée comme chaine de documentation de la
fonction.
Créons immédiatement deux fonctions bonjour() et BONJOUR() toutes simples dont

le but va être d’afficher un message en exécutant elles-mêmes une
fonction print(). On va faire cela comme cela :
Nous avons ici défini nos deux premières fonctions. Ces fonctions ne sont pas très
utiles ici : elles se contentent simplement d’exécuter une fonction print() mais
c’est déjà un bon début !

Page 63 sur 91
Maintenant que nos fonctions sont créées, nous allons devoir les appeler pour
exécuter le code qu’elles contiennent. Pour cela, nous allons utiliser leur nom suivi
d’un couple de parenthèses. On va pouvoir appeler nos fonctions autant de fois
qu’on le souhaite dans notre script : c’est tout l’intérêt des fonctions !
14.4. Les paramètres et arguments des fonctions
Les fonctions que nous avons créées ci-dessus se contentent d’exécuter toujours la
même fonction print() et donc de renvoyer toujours le même message.
Elles ne sont pas très utiles en l’état. Un autre aspect fondamental des fonctions
est qu’elles vont pouvoir accepter des informations qui viennent de l’extérieur,
c’est-à-dire qui sont externes à leur définition et qui vont les amener à produire
des résultats différents. Souvent même, les fonctions vont avoir besoin qu’on leur
passe des informations externes pour fonctionner normalement.
C’est par exemple le cas des fonctions print() et type() : ces deux fonctions
permettent d’afficher un message et de déterminer le type d’une donnée. Pour
afficher un message, print() va avoir besoin qu’on lui passe les données qu’elle doit
afficher. De même, type() va avoir besoin qu’on lui fournisse la donnée dont elle
doit déterminer le type.
Ces informations dont vont avoir besoin certaines fonctions pour fonctionner et
qu’on va passer à nos fonctions entre le couple de parenthèses sont appelées des
arguments ou des paramètres.
Pour rester très simple et très schématique ici, on parle de “paramètres” lorsqu’on
définit une fonction, c’est-à-dire lorsqu’on indique dans la définition de la
fonction que telle fonction a besoin d’une, de deux… informations pour

Page 64 sur 91
fonctionner et on parle “d’arguments” pour désigner les valeurs effectivement

passées à une fonction lorsqu’on l’utilise.
Illustrons cela immédiatement en reprenant et en modifiant notre

fonction bonjour() afin qu’elle affiche “Bonjour “ suivi du nom de quelqu’un qui va
lui être fourni ultérieurement. Pour réaliser cela, on va indiquer dans la définition
de la fonction que celle-ci a besoin d’un paramètre pour fonctionner.
On peut donner n’importe quel nom à ce paramètre dans la définition puisque

celui-ci sera dans tous les cas remplacé par la valeur effective passée lors de
l’appel à la fonction. Pour une meilleure lisibilité, il est cependant conseillé de
fournir des noms descriptifs et paramètres des fonctions. On peut par exemple
l’appeler prenom dans notre cas :
Expliquons ce code. On crée une nouvelle fonction bonjour() dont le rôle est
d’afficher “Bonjour” suivi du prénom de quelqu’un. Pour que cela fonctionne, il va
falloir lui passer un prénom lorsqu’on appelle notre fonction en argument de
celle-ci.
Dans la définition de la fonction, on va donc indiquer que notre fonction a besoin

d’un paramètre pour fonctionner. Ici, on choisit le mot “prenom” pour définir
notre paramètre. On aurait aussi bien pu choisir “toto”. Ensuite, dans le corps de
notre fonction, on utilise une fonction print() qui va afficher “Bonjour” suivi du
prénom qu’on aura indiqué lorsqu’on utilisera la fonction.
Ici, je vous rappelle que le mot qu’on utilise comme paramètre lors de la
définition de la fonction sera remplacé par la valeur passée en argument lors de
l’appel à la fonction. On va donc utiliser notre paramètre dans print() afin que
cette fonction affiche bien “Bonjour” suivi d’un prénom.
On utilise ensuite notre fonction plusieurs fois, en lui passant un prénom

différent à chaque fois en argument. La valeur passée va se substituer au
paramètre défini lors de la définition de la fonction.

Page 65 sur 91
Le code de notre fonction n’est cependant pas très optimisé ici : en effet, on utilise
de la concaténation dans print() or la concaténation ne va fonctionner que si la
valeur passée est bien une chaine de caractères. Si on passe un un chiffre en
argument de bonjour(), Python renverra une erreur.
Ici, il va être plus efficace de passer le texte et l’argument comme deux arguments
différents de print(). En effet, vous devez savoir que print() est capable d’accepter
un nombre infini d’arguments qu’elle affichera à la suite. Cela résout notre
problème de type de valeurs :

Page 66 sur 91
15. NOTIONS AVANCÉES SUR LES PARAMÈTRES DES FONCTIONS PYTHON
Dans cette leçon, nous allons étudier quelques concepts relativement avancés liés au nombre de
paramètres des fonctions en passant en revue différentes syntaxes qui vont nous permettre de
passer un nombre variable d’arguments à une fonction.
15.1. Créer des fonctions acceptant un nombre variable d’arguments
Dans la leçon précédente, nous avons défini ce qu’étaient des paramètres et des
arguments. Nous avons créé une fonction bonjour() qui avait besoin qu’on lui passe
un argument pour fonctionner comme ceci :
Cette définition impose qu’on passe un et un seul argument à notre fonction pour
qu’elle fonctionne : si on tente de l’appeler sans argument ou en lui passant
plusieurs arguments Python renverra une erreur.
Dans certaines situations, nous voudrons créer des fonctions plus flexibles qui
pourront accepter un nombre variable d’arguments. Cela peut être utile si on
souhaite créer une fonction de calcul de somme par exemple qui devra
additionner les différents arguments passés sans limite sur le nombre
d’arguments et sans qu’on sache à priori combien de valeurs vont être
additionnées.
En Python, il existe deux façons différentes de créer des fonctions qui acceptent
un nombre variable d’arguments. On peut :
 Définir des valeurs de paramètres par défaut lors de la définition d’une fonction ;
 Utiliser une syntaxe particulière permettant de passer un nombre arbitraire d’arguments.

Page 67 sur 91
Préciser des valeurs par défaut pour les paramètres d’une fonction
On va déjà pouvoir préciser des valeurs par défaut pour nos paramètres. Comme
leur nom l’indique, ces valeurs seront utilisées par défaut lors d’un appel à la
fonction si aucune valeur effective (si aucun argument) n’est passée à la place.
Utiliser des valeurs par défaut pour les paramètres de fonctions permet donc aux
utilisateurs d’appeler cette fonction en passant en omettant de passer les
arguments relatifs aux paramètres possédant des valeurs par défaut.
On va pouvoir définir des fonctions avec des paramètres sans valeur et des
paramètres avec des valeurs par défaut. Attention cependant : vous devez bien
comprendre qu’ici, si on omet de passer des valeurs lors de l’appel à la fonction,
Python n’a aucun moyen de savoir quel argument est manquant. Si 1, 2, etc.
arguments sont passés, ils correspondront de facto au premier, aux premier et
deuxième, etc. paramètres de la définition de fonction.
Pour cette raison, on placera toujours les paramètres sans valeur par défaut au
début et ceux avec valeurs par défaut à la fin afin que le arguments passés
remplacent en priorité les paramètres sans valeur.
Si on souhaite s’assurer que les valeurs passées à une fonction vont bien
correspondre à tel ou tel paramètre, on peut passer à nos fonctions des arguments
nommés. Un argument nommé est un argument qui contient le nom d’un
paramètre présent dans la définition de la fonction suivi de la valeur qu’on
souhaite passer comme ceci : argument = valeur.
On va pouvoir passer les arguments nommés dans n’importe quel ordre puisque
Python pourra faire le lien grâce au nom avec les arguments attendus par notre
fonction. Notez cependant qu’il faudra ici passer les arguments nommés en
dernier, après les arguments sans nom. Par ailleurs, aucun argument ne peut
recevoir de valeur plus d’une fois. Faites donc bien attention à ne pas passer une

Page 68 sur 91
valeur à un argument sans le nommer puis à repasser cette valeur en le nommant

par inattention.
Passer un nombre arbitraire d’arguments avec *args et **kwargs
La syntaxe *args (remplacez “args” par ce que vous voulez) permet d’indiquer lors
de la définition d’une fonction que notre fonction peut accepter un nombre
variable d’arguments. Ces arguments sont intégrés dans un tuple. On va pouvoir
préciser 0, 1 ou plusieurs paramètres classiques dans la définition de la fonction
avant la partie variable.
Ici, on utilise une boucle for pour itérer parmi les arguments : tant que des valeurs
sont trouvées, elles sont ajoutées à la valeur de s. Dès qu’on arrive à court
d’arguments, on print() le résultat.
De façon alternative, la syntaxe **kwargs (remplacez “kwargs” par ce que vous

voulez) permet également d’indiquer que notre fonction peut recevoir un nombre
variable d’arguments mais cette fois-ci les arguments devront être passés sous la
forme d’un dictionnaire Python.

Page 69 sur 91
Dans cette exemple, j’utilise la méthode Python items() dont le rôle est de
récupérer les différentes paires clefs : valeurs d’un dictionnaire. Nous reparlerons
des méthodes lorsque nous aborderons l’orienté objet. Pour le moment, vous
pouvez considérer qu’une méthode est l’équivalent d’une fonction.
15.2. Séparer des données pour les passer à une fonction
Les syntaxes *args et **kwargs peuvent être utilisées pour réaliser les opérations
inverse de celles présentés ci-dessus, à savoir séparer des données composites pour
passer les valeurs ou éléments de ces données un à un en arguments des
fonctions.
On, utilisera la syntaxe *args pour séparer les arguments présents dans une liste
ou un tuple et la syntaxe **kwargs pour séparer les arguments présents dans un
dictionnaire et fournir des arguments nommés à une fonction.

Page 70 sur 91
16. CONTRÔLE DES VALEURS DE RETOUR D’UNE FONCTION PYTHON
Dans cette leçon, nous allons voir comment faire pour que nos fonctions retournent explicitement
une valeur et comprendre l’intérêt de faire retourner une valeur à nos fonctions Python.
16.1. Présentation de l’instruction return et cas d’utilisation
Jusqu’à présent, nos fonctions n’ont fait qu’afficher leur résultat après qu’on les
ait appelées. En pratique, cette façon de procéder est rarement utilisée et ceci
pour deux raisons : d’une part, nous n’avons aucun contrôle sur le résultat affiché
puisque celui est affiché dès que la fonction a fini de s’exécuter et ensuite car nous
ne pouvons pas utiliser ce résultat pour effectuer de nouvelles opérations.
Or, en programmation, nous voudrons souvent récupérer le résultat d’une

fonction afin de l’utiliser dans le reste de notre script. Pour cela, il va falloir qu’on
demande à notre fonction de retourner (renvoyer) le résultat de ses opérations.
Nous allons pouvoir faire cela en Python grâce à l’instruction return.
Attention cependant : l’instruction return va terminer l’exécution d’une fonction,

ce qui signifie qu’on placera généralement cette instruction en fin de fonction
puisque le code suivant une instruction return dans une fonction ne sera jamais
lu ni exécuté.
16.2. Premier exemple d’utilisation de return en Python
Imaginons que nous soyons en train de créer un programme relativement

complexe qui effectue des séries de calculs intermédiaires pour finalement arriver
à un résultat final.
Notre programme va être composé de différentes fonctions qui vont se charger

d’effectuer ces différents calculs à la suite les unes des autres. Certaines fonctions
vont fonctionner différemment ou même ne pas s’exécuter du tout en fonction
du résultat renvoyé par la fonction précédente dans la chaine de fonctions.

Page 71 sur 91
Ce type de situations est très fréquent en programmation : on exécute une

première fonction qui renvoie un résultat et on injecte ce résultat dans la
fonction suivante et etc. On va pouvoir faire cela avec une instruction return.
Pour cela, créons par exemple une fonction très simple qui renvoie la différence
entre deux nombres.
Ici, on utilise return afin de demander à notre fonction de retourner son résultat.
On stocke ensuite ce résultat dans une variable x dont on pourra se resservir dans
la suite du script.
16.3. Utiliser return pour retourner plusieurs valeurs
Une fonction ne peut retourner qu’une donnée à la fois. Cependant, Python met à
notre disposition des types de données composites comme les listes ou les tuples
par exemple.
On va donc pouvoir utiliser return pour faire retourner “plusieurs valeurs” à la fois
à nos fonctions ou pour être tout à fait exact pour leur faire retourner une donnée
composite.
Pour cela, on va préciser les différentes valeurs que doit retourner return en les
séparant par des virgules. Les valeurs retournées seront retournées dans un tuple.

Page 72 sur 91
16.4. Les fonctions récursives
Nous avons vu dans les leçon précédente qu’une fonction pouvait exécuter une
autre fonction, par exemple dans le cas où on demande à une fonction d’exécuter
une fonction print() pour afficher une valeur.
Vous devez savoir qu’une fonction peut également s’appeler elle même dans son
exécution : c’est ce qu’on appelle la récursivité. Lorsqu’on définit une fonction
récursive, il faudra toujours faire bien attention à fournir une condition qui sera
fausse à un moment ou l’autre au risque que la fonction s’appelle à l’infini.
L’exemple de fonction récursive par excellence est la définition d’une fonction qui
calculerait une factorielle. La factorielle d’un nombre est le produit des nombres
entiers inférieurs ou égaux à celui-ci; la factorielle de 4 par exemple est égale à 4 *
3 * 2 * 1.
Créons immédiatement cette fonction :
Ici, la condition de sortie de notre fonction est atteinte dès que la valeur passée en
argument atteint ou est inférieure à 1. Expliquons comment fonctionne cette
fonction en détail. Si on passe une valeur inférieure ou égale à 1 à notre fonction
au départ, on retourne la valeur 1 et la fonction s’arrête.
Si on passe une valeur strictement supérieure à 1, on retourne cette valeur et on

appelle factorielle(n-1). Si n-1 représente toujours une valeur strictement
supérieure à 1, on retourne cette valeur et on appelle à nouveau notre fonction
avec une valeur diminuée de 1 et etc. Jusqu’à ce que la valeur passée
à factorielle() atteigne 1.

Page 73 sur 91
16.5. Un peu de vocabulaire : fonction vs procédure en Python
Par définition, toute fonction est censée renvoyer une valeur. Une fonction qui ne
renvoie pas de valeur n’est pas une fonction : on appelle cela en programmation
une procédure.
En Python, en fait, même les fonctions sans instruction return explicite renvoient
une valeur qui est None. Le valeur None est une valeur qui correspond justement à
l’absence de valeur. Cette valeur sert à indiquer “il n’y a pas de valeur”.
L’interpréteur Python l’ignore lorsque c’est la seule valeur qui est renvoyée mais
elle existe tout de même et c’est la raison pour laquelle on appelle les fonctions
qui ne possèdent pas de return explicite des fonctions en Python.

Page 74 sur 91
17. LA PORTÉE DES VARIABLES EN PYTHON
Dans cette leçon, nous allons découvrir un concept fondamental lié aux fonctions
et aux variables qui est celui de portée des variables. Nous allons comprendre les
conditions d’accès et d’utilisation des différentes variables dans un script.
17.1. Définition de la portée des variables en Python
En Python, nous pouvons déclarer des variables n’importe où dans notre script :
au début du script, à l’intérieur de boucles, au sein de nos fonctions, etc.
L’endroit où on définit une variable dans le script va déterminer l’endroit où la

variable va être accessible c’est-à-dire utilisable.
Le terme de “portée des variables” sert à désigner les différents espaces dans le
script dans lesquels une variable est accessible c’est-à-dire utilisable. En Python,
une variable peut avoir une portée locale ou une portée globale.
17.2. Variables globales et variables locales en Python
Les variables définies dans une fonction sont appelées variables locales. Elles ne
peuvent être utilisées que localement c’est-à-dire qu’à l’intérieur de la fonction
qui les a définies. Tenter d’appeler une variable locale depuis l’extérieur de la
fonction qui l’a définie provoquera une erreur.
Cela est dû au fait que chaque fois qu’une fonction est appelée, Python réserve
pour elle (dans la mémoire de l’ordinateur) un nouvel espace de noms (c’est-à-dire

Page 75 sur 91
une sorte de dossier virtuel). Les contenus des variables locales sont stockés dans
cet espace de noms qui est inaccessible depuis l’extérieur de la fonction.
Cet espace de noms est automatiquement détruit dès que la fonction a terminé
son travail, ce qui fait que les valeurs des variables sont réinitialisées à chaque
nouvel appel de fonction.
Les variables définies dans l’espace global du script, c’est-à-dire en dehors de toute
fonction sont appelées des variables globales. Ces variables sont accessibles (=
utilisables) à travers l’ensemble du script et accessible en lecture seulement à
l’intérieur des fonctions utilisées dans ce script.
Pour le dire très simplement : une fonction va pouvoir utiliser la valeur d’une
variable définie globalement mais ne va pas pouvoir modifier sa valeur c’est-à-
dire la redéfinir. En effet, toute variable définie dans une fonction est par
définition locale ce qui fait que si on essaie de redéfinir une variable globale à
l’intérieur d’une fonction on ne fera que créer une autre variable de même nom
que la variable globale qu’on souhaite redéfinir mais qui sera locale et bien
distincte de cette dernière.
17.3. Modifier une variable globale depuis une fonction
Dans certaines situations, il serait utile de pouvoir modifier la valeur d’une

variable globale depuis une fonction, notamment dans le cas où une fonction se
sert d’une variable globale et la manipule.
Cela est possible en Python. Pour faire cela, il suffit d’utiliser le mot
clef global devant le nom d’une variable globale utilisée localement afin d’indiquer

Page 76 sur 91
à Python qu’on souhaite bien modifier le contenu de la variable globale et non pas
créer une variable locale de même nom.

Page 77 sur 91
18. QUELQUES FONCTIONS PYTHON UTILES
Nous connaissons déjà bien les fonction print() et type() qui permettent respectivement
d’afficher des données ou de connaitre le type d’une donnée Python.
Python ne contient pas énormément de fonctions prédéfinies -seulement celles
qui s’avèrent le plus utiles- et la plupart d’entre elles sont donc très régulièrement
utilisées.
Vous trouverez dans la suite de cette leçon quelques définitions de fonctions qui
pourront vous servir par la suite.
18.1. Les fonctions de conversion
Python possède certaines fonctions qui nous permettent de modifier le type de

certaines données, c’est-à-dire de les “convertir”. Ces fonctions portent le nom du
type de donnée souhaitée :
 La fonction str() retourne une chaine de caractères à partir d’une donnée qu’on va lui
passer en argument ;
 La fonction int() retourne un entier à partir d’un nombre ou d’une chaine contenant un
nombre qu’on va lui passer en argument ;
 La fonction float() retourne un nombre décimal à partir d’un nombre ou d’une chaine
contenant un nombre qu’on va lui passer en argument ;
 La fonction complex() retourne un nombre complexe à partir d’un nombre ou d’une
chaine contenant un nombre qu’on va lui passer en argument ;
 La fonction bool() retourne un booléen à partir d’une donnée qu’on va lui passer en
argument ;
 La fonction list() retourne une liste à partir d’une donnée itérable (une donnée dont on
peut parcourir les valeurs) ;
 La fonction tuple() retourne un tuple à partir d’une donnée itérable ;
 La fonction dict() crée un dictionnaire à partir d’un ensemble de paires clef = “valeur” ;
 La fonction set() retourne un ensemble (set) à partir d’une donnée itérable.

Page 78 sur 91
18.2. Les fonctions mathématiques
Python possède également certaines fonctions qui vont nous permettre

d’effectuer des opérations mathématiques intéressantes, comme des calculs de
somme ou de recherches du plus grand ou du plus petit nombre dans une liste.
Nous allons ici étudier les fonctions range(), round(), sum(), min() et max().
La fonction range() renvoie une séquence de nombres. On peut lui passer jusqu’à 3
arguments mais 1 seul est obligatoire.
Si on ne passe qu’un argument à range(), cette fonction va renvoyer une séquence

de nombres commençant par 0 et en incrémentant de 1 à chaque fois jusqu’au
nombre spécifié en argument moins 1.
En lui passant 2 arguments, le premier argument servira de départ pour la

séquence et le deuxième indiquera la fin de la séquence (avec le nombre indiqué
exclu).
En lui passant trois arguments, le premier argument servira de départ pour la

séquence, le deuxième indiquera la fin de la séquence (avec le nombre indiqué
exclu) et le troisième indiquera le “pas”, c’est-à-dire l’écart entre chaque nombre
renvoyé.

Page 79 sur 91
La fonction round() permet d’arrondir un nombre spécifié en argument t à l’entier

le plus proche avec un degré de précision (un nombre de décimales)
éventuellement spécifié en deuxième argument.
Le nombre de décimales par défaut est 0, ce qui signifie que la fonction retournera
l’entier le plus proche.
La fonction sum() permet de calculer une somme. On peut lui passer une liste de
nombres en arguments par exemple. On peut également lui passer une valeur “de
départ” en deuxième argument qui sera ajoutée à la somme calculée.
La fonction max() retourne la plus grande valeur d’une donnée itérable, c’est-à-
dire d’une donnée dont on peut parcourir les différentes valeurs.
On peut lui passer autant d’arguments qu’on souhaite comparer de valeurs. Notez
qu’on peut également comparer des chaines même si max() est peu souvent
utilisée pour faire cela.
La fonction min(), au contraire, retourne la plus petite valeur d’une donnée

itérable. Elle s’utilise exactement comme max().

Page 80 sur 91

Page 81 sur 91
18.3. Autres fonctions Python natives utiles
Parmi les autres fonctions Python prédéfinies, j’aimerais vous en présenter

rapidement quelques unes qu’on va réutiliser dans la suite de ce cours.
La fonction len(), tout d’abord, renvoie la longueur ou le nombre de valeurs d’une

donnée de type séquence ou collection.
La fonction input() permet de dialoguer et d’échanger des données avec

l’utilisateur. On va pouvoir passer un message en argument de cette fonction.
Attention : il est de votre responsabilité de bien vérifier si les données envoyées
sont conformes à celles attendues pas la suite.
La fonction dir(), lorsqu’elle est utilisée sans argument, renvoie la liste des
variables et des fonctions (ou plus exactement des objets et des méthodes)
disponibles dans l’espace de portée courant. Nous étudierons ce que sont les objets
et méthodes par la suite.
Si on lui passe une donnée en argument, elle renverra la liste des méthodes
disponibles pour ce type de donnée.

Page 82 sur 91

Page 83 sur 91
19. LES MODULES ET PAQUETS PYTHON
Dans cette nouvelle partie, nous allons découvrir une autre facette du langage Python qui en fait
un langage à la fois très puissant, modulable et évolutif : l’utilisation de modules. Nous allons
notamment étudier le fonctionnement de quelques modules prédéfinis qu’il convient de savoir
manipuler.
19.1. Définition et cas d’utilisation des modules Python
On appelle “module” tout fichier constitué de code Python (c’est-à-dire tout

fichier avec l’extension .py) importé dans un autre fichier ou script.
Les modules permettent la séparation et donc une meilleure organisation du code.

En effet, il et courant dans un projet de découper son code en différents fichiers
qui vont contenir des parties cohérentes du programme final pour faciliter la
compréhension générale du code, la maintenance et le travail d’équipe si on
travaille à plusieurs sur le projet.
En Python, on peut distinguer trois grandes catégories de module en les classant

selon leur éditeur :
 Les modules standards qui ne font pas partie du langage en soi mais sont intégrés
automatiquement par Python ;
 Les modules développés par des développeurs externes qu’on va pouvoir utiliser ;
 Les modules qu’on va développer nous mêmes.
Dans tous les cas, la procédure à suivre pour utiliser un mode sera la même. Nous
allons commencer par décrire cette procédure puis nous étudierons dans la suite
de cette partie quelques modules standards qu’il convient de connaitre.
19.2. Importer un module
Un programme Python va généralement être composé d’un script principal qui va

importer différents modules (c’est-à-dire différents fichiers Python) pour pouvoir
les utiliser.

Page 84 sur 91
Pour importer un module, on utilise la syntaxe import nom-de-mon-module. Pour

utiliser les éléments du module dans notre script, il faudra préfixer le nom de ces
éléments par le nom du module et un point. Cela permet d’éviter les conflits dans
le cas où on aurait défini des éléments de même nom que ceux disponibles dans le
module.
Pour comprendre comment cela fonctionne en pratique, je vous invite à ouvrir

votre éditeur de texte et à créer un fichier qu’on va appeler “bonjour”. Notre
fichier va contenir une variable et une fonction comme ceci :
Ensuite, enregistrez le dans le dossier Python que vous devriez avoir créé au début
de ce cours et qui devrait se trouver sur votre bureau.
Dès que tout cela est fait, on peut retourner dans le terminal ou l’invite de
commande. Ne lancez pas l’interpréteur pour le moment et pensez bien à définir
le dossier Python comme dossier de référence pour la recherche de fichiers
Python si ça n’a pas été fait au début de ce cours.
Pour cela, vous pouvez utiliser la commande cd (pour “change directory”) suivie du
chemin du dossier qui doit être le dossier de référence (Desktop/Python pour Mac
par exemple).
On peut ensuite lancer l’interpréteur Python. Ici, il faut imaginer que notre
terminal / invite de commande représente le script principal de notre
programme. On va importer notre module dans ce script principal grâce à
l’instruction import bonjour.
Lorsque l’interprète rencontre une instruction import, il importe le module s’il est
présent dans le path (le chemin de recherche). Pour rappel, le path ou chemin de
recherche est une liste de répertoires dans lesquels l’interpréteur cherche avant
d’importer un module. Pour être tout à fait précis, lorsqu’on importe un module,
l’interpréteur Python le recherche dans différents répertoires selon l’ordre suivant
:

Page 85 sur 91
1. Le répertoire courant ;
2. Si le module est introuvable, Python recherche ensuite chaque répertoire listé dans la
variable shell PYTHONPATH ;
3. Si tout échoue, Python vérifie le chemin par défaut. Sous UNIX, ce chemin par défaut est
normalement /usr/local/lib/python/.
Dès que notre module est importé, on va pouvoir accéder tout simplement aux
variables et fonctions de notre module depuis notre script en préfixant le nom des
éléments du module par le nom du module et un point comme ceci :
19.3. Créer un alias de nom pour un module
On peut utiliser le mot clef as pour renommer un module ou plutôt pour créer un
alias de nom. Cela peut permettre d’obtenir des scripts plus courts et plus clairs
dans le cas où le nom du module est inutilement long ou s’il est peu descriptif.
Note : on ne peut importer un module qu’une fois dans un script. Si vous testez le
code ci-dessus et si vous aviez déjà importé le module précédemment, il faudra
que vous quittiez l’interpréteur et que vous le relanciez pour que tout fonctionne.
Pour quitter l’interpréteur, vous pouvez utiliser l’instruction quit().
19.4. Importer uniquement certains éléments d’un module
Parfois, nous n’aurons besoin que de certains éléments précis dans un module. On
va alors pouvoir se contenter d’importer ces éléments en particulier. Pou cela, on
va utiliser l’instruction from nom-du-module import un-element.

Page 86 sur 91
On va par exemple pouvoir choisir de n’importer que la variable nom ou que la

fonction disBonjour() depuis le module bonjour.py.
Dans le cas où on n’importe que certains éléments depuis un module, il ne faudra

pas ensuite préfixer le nom des éléments par le nom du module pour les utiliser
dans notre script principal.
19.5. Obtenir la liste des éléments d’un module
Souvent, on importera des modules standards ou créés par d’autres développeurs.

Dans ce cas là, il peut être intéressant d’obtenir rapidement la liste des éléments
du module afin de voir rapidement ce qui va pouvoir nous être utile.
Pour faire cela, on peut utiliser la fonction dir() qui renvoie la liste de toutes les
fonctions et variables d’un module.
Comme vous pouvez le voir, tout fichier Python possède par défaut des éléments
de configuration.
19.6. Les modules Python standards
Comme je vous l’ai dit au début de cette leçon, nous importerons bien souvent des
modules créés par d’autres développeurs ou des modules mis à notre disposition
par Python lui même.

Page 87 sur 91
En effet, il existe un grand nombre de modules préconçus et prêts à l’emploi qui

sont fournis d’office avec Python. Ces modules vont étendre le langage et nous
permettre de réaliser toutes sortes d’opérations notamment grâce aux fonctions
qu’ils nous fournissent.
Pour importer un module Python, nous allons à nouveau tout simplement utiliser
une instruction import comme si on importait l’un de nos modules.
Les modules Python standards à connaitre sont les suivants :
 Le module cgi (“Common Gateway Interface” ou “Interface de Passerelle Commune” en

français) fournit des éléments permettant à des programmes Python de s’exécuter sur des
serveurs HTTP ;
 Le module datetime fournit des classes pour manipuler de façon simple ou plus
complexe des dates et des heures ;
 Le module json permet l’encodage et le décodage de données au format JSON ;
 Le module math fournit un ensemble de fonctions permettant de réaliser des calculs
mathématiques complexes ;
 Le module os fournit une manière portable d’utiliser les fonctionnalités dépendantes du
système d’exploitation ;
 Le module pickle permet de sérialiser des objets Python ;
 Le module random implémente des générateurs de nombres pseudo-aléatoires pour
différentes distributions ;
 Le module re fournit des opérations sur les expressions rationnelles similaires à celles que
l’on trouve dans Perl ;
 Le module socket fournit un accès à l’interface sockets qui correspond à un ensemble
normalisé de fonctions de communication ;
 Le module sys fournit un accès à certaines variables système utilisées et maintenues par
l’interpréteur, et à des fonctions interagissant fortement avec ce dernier ;
 Les modules urllib.request et urllib.parse permettent d’ouvrir, de lire et d’analyser des
URLs.
Vous pouvez retrouver la liste complète des modules standards Python sur le site
officiel.
19.7. Les paquets Python
Un paquet est tout simplement un ensemble de plusieurs modules regroupés

entre eux. On va pouvoir importer des paquets de la même façon que des modules

Page 88 sur 91
et accéder à un module ou à un élément en particulier en utilisant la

syntaxe nom-paquet.nom-module.nom-element.

Page 89 sur 91
20. MODULES PYTHON STANDARDS MATH, RANDOM ET STATISTICS
Dans cette leçon, nous allons passer en revue rapidement les trois modules Python
standards math, random et statistics et découvrir leurs fonctionnalités les plus utilisées.
20.1. Le module math
Le module math nous fournit un accès à de nombreuses fonctions permettant de

réaliser des opérations mathématiques comme le calcul d’un sinus, cosinus, d’une
tangente, d’un logarithme ou d’une exponentielle.
Les fonctions les plus couramment utilisées sont les suivantes :
 Les fonctions ceil() et floor() renvoient l’arrondi du nombre passé en argument en

arrondissant respectivement à l’entier supérieur et inférieur ;
 La fonction fabs() renvoie la valeur absolu d’un nombre passé en argument ;
 La fonction isnan() renvoie True si le nombre passé en argument est NaN = Not a
Number (pas un nombre en français) ou False sinon ;
 La fonction exp() permet de calculer des exponentielles ;
 La fonction log() permet de calculer des logarithmes ;
 La fonction sqrt() permet de calculer la racine carrée d’un nombre ;
 Les fonctions cos(), sin() et tan() permettent de calculer des cosinus, sinus et tangentes et
renvoient des valeurs en radians.
Attention : les fonctions de ce module ne peuvent pas être utilisées avec des
nombres complexes. Pour cela, il faudra plutôt utiliser les fonctions du
module cmath.
Le module math définit également des constantes mathématiques utiles comme

pi ou le nombre de Neper, accessibles via math.pi et math.e.

Page 90 sur 91
Pour obtenir la liste complète des fonctions et constantes de ce module, je vous

invite à consulter la documentation.
20.2. Le module random
Le module random nous fournit des outils pour générer des nombres pseudo-
aléatoires de différentes façons.
La fonction random() est le plus utilisée du module. Elle génère un nombre à

virgule flottante aléatoire de façon uniforme dans la plage semi-ouverte [0.0, 1.0).
La fonction uniform() va elle générer un nombre à virgule flottante aléatoire

compris dans un intervalle. On va lui passer deux tombes en argument : le
premier nombre représente la borne basse de l’intervalle tandis que le second
représente la borne supérieure. Notez que cette fonction se base sur random().
Le module random est très riche et contient de nombreuses fonctions qui vont
nous permettre de générer des nombres pseudo aléatoires de différentes manières
et pour différentes situations. Je vous invite à les découvrir en détail dans
la documentation.

Page 91 sur 91
20.3. Le module statistics
Le module statistics nous fournit des outils nous permettant d’effectuer des
calculs de statistiques peu complexes, comme des calculs de moyenne, de médiane
ou de variance.
Ce module contient notamment les fonctions suivantes :
 La fonction mean() permet de calculer une moyenne ;

 La fonction median() permet de calculer une médiane ;
 La fonction variance() permet de calculer une variance ;
 La fonction stdev() permet de calculer un écart type.

Cours Programmation Python v1 2021

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Programmation Python v1 2021

Transféré par

Droits d'auteur :

Formats disponibles

PROGRAMMATION PYTHON

Version 1.0 - Novembre 2021

Python est un langage de programmation interprété, qui se veut simple à

1.1. Python, un langage de programmation

Schématiquement, on utilise des langages de programmation car il est plus facile

Le langage de programmation se charge de la conversion : il reçoit nos

Dr Jamâl-Dine DISSOU - 2021

1.2. Python, un langage interprété

Comment font les langages de programmation pour transformer nos instructions

Un interpréteur se distingue d’un compilateur par le fait que, pour exécuter un

L’interprétation repose sur l’exécution dynamique du programme par un autre

Ainsi, contrairement au compilateur, l’interpréteur exécute les instructions du

En revanche, les langages interprétés sont généralement plus simples à

Dr Jamâl-Dine DISSOU - 2021

En effet, un langage comme Python fonctionnera avec n’importe quel système

1.3. Python, un langage extensible et polyvalent

1.4. Un point sur les versions Python

Au contraire, une liste de modifications / ajouts sont faits au langage en arrière

Dr Jamâl-Dine DISSOU - 2021

Généralement, lorsqu’un langage évolue et que de nouvelles versions paraissent,

A l’inverse, le fait de proposer une comptabilité ascendante entre chaque version

Voulant modifier en profondeur leur langage et proposer une version beaucoup

Dr Jamâl-Dine DISSOU - 2021

2. L’ENVIRONNEMENT DE TRAVAIL PYTHON

2.1. Coder en Python : simple et gratuit

Pour coder en Python, un seul programme va être strictement obligatoire :

En pratique, cependant, nous voudrons souvent enregistrer nos différents scripts

2.2. L’interpréteur Python

L’interpréteur Python est disponible en téléchargement gratuit sur le site officiel

Dr Jamâl-Dine DISSOU - 2021

IDLE est un environnement de développement intégré spécialement pour Python

L’invite de commande se trouve dans le menu Démarrer de Windows sous le

Dr Jamâl-Dine DISSOU - 2021

2.3. L’éditeur de texte

Dr Jamâl-Dine DISSOU - 2021

Les IDE disposent de fonctionnalités supplémentaires comme des mécanismes

Dr Jamâl-Dine DISSOU - 2021

3. SYNTAXE DE BASE ET EXÉCUTION D’INSTRUCTIONS PYTHON

3.1. Créer un fichier Python

Dr Jamâl-Dine DISSOU - 2021

3.2. Exécuter un fichier Python

Dr Jamâl-Dine DISSOU - 2021

3.3. Exécuter du Python en tapant directement dans l’invite de commande ou

L’interpréteur Python peut être utilisé de manière interactive, c’est-à-dire qu’on

Pour utiliser l’interpréteur Python de cette manière, on va déjà devoir l’appeler

3.4. Syntaxe de base de Python : indentation, commentaires et print()

Dr Jamâl-Dine DISSOU - 2021

Les commentaires Python

On utilise généralement les commentaires pour documenter un code (pour soi ou

L’indentation correspond au fait de créer des retraits au niveau de certaines lignes

Généralement, une bonne indentation est censée représenter les dépendances au

Dr Jamâl-Dine DISSOU - 2021

Si vous avez l’habitude d’autres langages de programmation comme le PHP par

La fonction print() permet tout simplement d’afficher le message qu’on va lui

En effet, cette fonction va être très précieuse puisqu’elle va également nous

Dr Jamâl-Dine DISSOU - 2021

4. LES VARIABLES PYTHON

4.1. Qu’est-ce qu’une variable ?

Une variable, dans le domaine de la programmation informatique, est un

4.2. Comment déclarer une variable en Python ?

Python ne possède pas de syntaxe particulière pour créer ou “déclarer” une

Dr Jamâl-Dine DISSOU - 2021

 Le nom doit commencer par une lettre ou par un underscore ;

Notez déjà qu’on va également pouvoir effectuer des affectations multiples en