Partie 1 : Introduction à Python

Objectifs :
 Ce qu'est exactement Python ;
 Comment installer Python ;
 Comprendre la syntaxe et les mécanismes de base de ce langage.

A. Qu'est-ce que Python ?

I. Qu'est ce qu’un langage de programmation ?
La machine est faite pour exécuter les ordres dictés par l’Homme, ces ordres sont
écrits par ce dernier sous forme d’une suite d’instructions selon la syntaxe du
langage utilisé. Ce langage bien facile à comprendre par nous est appelé langage de
programmation, et la suite d’instructions est appelée Programme (Il existe un grand
nombre de langages de programmation et Python en fait partie).
L’ordinateur se fonde aussi sur un langage pour communiquer avec l’utilisateur ou
avec lui-même. Ce langage basé sur un code binaire (0 et 1) est appelé langage
machine.
Ainsi, avant son exécution, le programme qui contient les instructions qui décrivent à
l'ordinateur ce qu'il faut faire, doit être traduit en langage machine (binaire = suite de
0 et 1) compréhensible par la machine.

Le programmeur « n'a qu'à » écrire des lignes de code dans le langage qu'il a choisi,
les étapes suivantes sontautomatisées pour permettre à l'ordinateur de les décoder.

II. Le Langage PYTHON

1- Création :
Python est un langage de programmation, dont la première version est sortie en
1991. Créé par Guido van Rossum, il a voyagé du Macintosh de son créateur
jusqu'à sevoir associer une organisation à but non lucratif particulièrement dévouée,
la Python Software Foundation, créée en 2001. Ce langage a été baptisé ainsi en
hommage à la troupe de comiques les «Monty Python»

2- Caractéristiques :
Python est un langage de programmation facile, pédagogique, interprété, universel,
gratuit puissant.

a) Python est un langage facile et Pédagogique : Comparé à plusieurs langages

de programmation actuellement disponibles, Python est de loin le plus facile à
étudier. Son beau code plaie aux yeux et conduit à des programmes à la fois très
compacts et très lisibles. Aussi, la syntaxe de Python est très simple et obéit à moins
de règles par rapport à d'autres langages. Les centres de formations, les grandes
écoles et les universités l’utilisent pour apprendre la programmation aux élèves et
aux étudiants.

1
 b) Python est un langage Interprété : à l'image des langages compilés (PHP,
Pascal …) un programme Python ne nécessite pas d'étape de compilation en
langage machine pour fonctionner. Le code est interprété à l'exécution. Python
présente néanmoins une caractéristique intéressante : comme en Java, le code
Python est compilé en bytecode (format intermédiaire) avant lancement, ce qui
optimise ses performances.

c) Python est un langage Portable : A la différence des langages compilés qui

utilisent des compilateurs différents selon le système utilisé (certaines instructions
ne sont pas compatibles, voire se comportent différemment d’un système à l’autre),
le fait d’être un langage interprété, on ne devrait avoir à effectuer aucun changement
dans le code d’un programme Python pour fonctionner aussi bien sous Windows
que sous Linux ou MacOS, et pour le passer d'un système à l'autre.

d) Python est un langage Gratuit (open source): Python est un langage qu’on
peut installer sans acheter une licence et qu’on peut utiliser sans restriction dans des
projets commerciaux.

e) Python est un langage Puissant : Python est un langage puissant et riche en

possibilités et plusieurs milliers de packages sont disponibles dans tous les
domaines. Dès l'instant où il est installé sur l’ordinateur, le programmeur dispose de
nombreuses fonctionnalités intégrées au langage. Ainsi, il existe ce qu'on appelle
desbibliothèques qui aident le développeur à travailler sur des projets particuliers.
Plusieurs bibliothèques peuvent ainsi êtreinstallées pour, par exemple, développer
des interfaces graphiques en Python.

III. Installation et lancement de Python

1. L’installation de Python :
L'installation de Python est facile. Quel que soit le
systèmed'exploitation, on peut se rendre sur le site
officiel de Python pour télécharger la dernière
version de ce langage
Sous Windows par exemple, il suffit de choisir la
version qui convient au processeur du PC (32 bits
ou 64 bits) et procéder à son téléchargement. Puis
une fois enregistré, on exécute le fichier
d'installation et on suit les étapes.
Une fois l'installation terminée, on peut se rendre
dans le menuDémarrer, Python devrait apparaître
dans cette liste. Nous verrons bientôt comment le
lancer.

2. Lancement de Python :

Pour lancer Python et accéder à sa ligne de commande, on peut passer par le menu
Démarrer de Windows pour choisir l’option < Python > .

2
On peut également passer par la ligne de commande Windows ; il suffit d’aller dans
le menu Démarrer, puis cliquer sur Exécuter. Dans la fenêtre qui s'affiche, taper
simplement « python » et la ligne de commande Python devrait s'afficher à nouveau.

Pour fermer l'interpréteur de commandes Python, vous pouvez tapez « exit() » puis
appuyer sur la touche Entrée.

3. L'éditeur de programmes (ou éditeur de scripts) de Python :.

Le programme (aussi appelé script) devra être enregistré dans un fichier texte
d'extension .py pour qu'il soit reconnu comme un programme python. On peut écrire
ce programme dans un simple éditeur de texte (NotePad++ par exemple), comme
on peut installer des éditeurs spécifiques tels que pycharm, PyScripter, Pyzo,
Atom ..etc.

Sous Windows, le programme est enregistré dans un fichier nommé

monprogramme.py

4. Mode interactif et mode script

Il y a deux modes d'utilisation de Python. Dans le mode interactif, aussi appelé

mode console, l'interpréteur permet d'encoder les instructions une à une. Aussitôt
une instruction encodée, il suffit d'appuyer sur la touche ENTER pour que
l'interpréteur l'exécute.
Le mode interactif est très pratique pour rapidement tester des instructions et
directement voir leurs résultats.

Exemple :

>>> print('Hello World!')

Hello World!

Il existe également le mode script où on doit avoir préalablement écrit toutes les
instructions de programme dans un fichier texte, et l'avoir enregistré sur l’ordinateur.
On utilise généralement l'extension de fichier .py pour des fichiers contenant du
code Python. Une fois cela fait, l'interpréteur va lire ce fichier et exécuter son
contenu, instruction par instruction, comme si on les a tapées l'une après l'autre
dans le mode interactif. Les résultats intermédiaires des différentes instructions ne
sont par contre pas affichés; seuls les affichages explicites (avec la fonction print,
par exemple) se produisent.

5. Calculatrice Python

On peut utiliser l'interpréteur Python en mode interactif comme une calculatrice. En

effet, si on y tape une expression mathématique, cette dernière sera évaluée et son
résultat affiché comme résultat intermédiaire. Rappelez-vous que cela ne fonctionne
pas avec le mode script. Voici, par exemple, une succession d'instructions encodées
en mode interactif, ainsi que les résultats produits :
3
 >>> 42
42
>>> 2 * 12
24
>>> 2 ** 10
1024
>>> ((19.99 * 1.21) - 5) / 4
4.796975

Python propose sept opérateurs arithmétiques :

Notation
Description
Addition +
Soustraction -
Multiplication *
Division /
Exponentiation **
Division entière //
Reste de la division entière %

IV. Structure d'un programme en Python.

La structure et la syntaxe en Python ne sont pas très compliquées, cependant il est
nécessaire de toujours suivre les règles de base !
- Python ne nécessite pas de déclaration de type ; une variable est directement
affectable par l'opérateur "=".
- Comme Python est un langage interprété, la lecture d'un fichier se fait de haut en
bas. Il faut que les déclarations de fonctions, de variables et de classes se fassent
avant leur première utilisation.
- Il est possible de mettre plusieurs instructions sur la même ligne, si elles sont
séparées par un point-virgule.
- Un bloc doit forcément contenir une instruction, un « else »: sans rien générera
une erreur.
- Les instructions peuvent s’étendre sur plusieurs lignes si elles se trouvent dans
une paire syntaxique, par exemple une paire de crochets. Une instruction peut
aussi s’étendre sur plusieurs lignes si elle finit par un antislash.
- Un bloc de code en Python, par exemple une fonction, ne s'ouvre et ne se ferme
pas avec un caractère (comme {} en C). En Python seul l'indentation de
l'instruction indique à quel niveau elle se trouve. On doit donc être très rigoureux
sur ce point très important et faire bien attention à garder toujours la même
indentation pour un bloc (en général 1 TAB).

4
Utilisation des Commentaires

Lorsqu'on écrit un programme, il est parfois utile d'y ajouter des informations textuelles
à destination des êtres humains. Ce genre d'information est appelé commentaire et on
en l’ajoute dans un code source à l'aide du caractère #. Tout ce qui suit ce caractère,
jusque la fin de la ligne, sera ignoré par l'interpréteur Python.

Il est aussi possible dans un fichier de marquer un commentaire avec des guillemets,
(ceci permet un commentaire sur plusieurs lignes """....""").

Le but d'un bon commentaire est d'apporter une information additionnelle au code. Il
peut s'agir d'informations liées au problème résolu par le programme ou d'informations
sur le programme (auteurs, version, etc.).

Exemple :

# Ceci est un commentaire et ne sera pas pris en considération par Python

B. Les variables et type de donnée en Python

Les variables sont l'un des concepts qui se retrouvent dans la majorité (et même, en
l'occurrence, la totalité) des langages de programmation. Autant dire que sans
variable, on ne peut pas programmer !

I. Les variables en Python

1. C'est quoi, une variable ?
La mémoire de l’ordinateur peut être considérée comme une grosse armoire avec
plein de casiers, chaque casier représente une variable, cette variable est
caractérisé par un nom (identifiant), un contenu et le type de ce contenu.
Une variable peut donc contenir une donnée de programme, stockée dans
l’ordinateur. C'est un code alphanumérique que va être lié à une donnée de
programme, afin de pouvoir l'utiliser à plusieurs reprises et faire des calculs un peu
plus intéressants avec. Une variable permet aussi de stocker les résultats des
traitements pour des utilisations ultérieures.

2. Comment est utilisée une variable en Python ?

En Python, pour donner une valeur à une variable, il suffit d'écrire
nom_de_la_variable = valeur

Exemple :
A=5 Permet d’affecter la valeur 5 à la variable nommée A
B=2 Permet d’affecter la valeur 2 à la variable nommée B
S=A+B Permet de ranger la somme des deux variables (7) dans la variable nommée S

Le nom d’une variable doit respecter quelques règles de syntaxe incontournables :

a. Le nom de la variable ne peut être composé que de lettres, majuscules ou

minuscules, de chiffres et du symbole souligné «_».
5
b. Le nom de la variable ne peut pas commencer par un chiffre.
c. Le langage Python est sensible à la casse, ce qui signifie que des lettres
majuscules et minuscules ne constituent pas la même variable (la variable AGE est
différente de aGe, elle-même différente de age).
d. Certains mots-clés de Python sont réservés, c'est-à-dire qu’on ne peut pas créer
des variables portant ce nom (Exemple : or, not, and, false,…).

L'utilisation d'une variable est donc assez immédiate. Deux types d'accès peuvent être
réalisés :
 Pour affecter une valeur à une variable, c'est-à-dire l'initialiser ou modifier sa
valeur, on utilise l'opérateur d'affectation (=). À gauche de l'opérateur on retrouve
le nom de la variable et à droite la valeur qu'on souhaite lui affecter.
 Pour accéder au contenu d'une variable, il suffit d'utiliser son nom.

3. Initialisation de variable :
Avant de pouvoir accéder au contenu d'une variable, il faut qu'elle soit initialisée,
c'est-à-dire qu'elle doit posséder une valeur. Si vous tentez d'utiliser une variable
non initialisée, l'exécution du programme va s'arrêter et l'interpréteur Python va
produire une erreur d'exécution. Voyons cela avec l'exemple de programme
suivant :
height = 178
print('Sa taille est :')
print(heigth)

Le programmeur a fait une malencontreuse faute de frappe à la troisième

instruction, et lors de son exécution, l'interpréteur s'arrête et produit une erreur :

Sa taille est :
Traceback (most recent call last):
File "program.py", line 3, in <module>
print(heigth)
NameError: name 'heigth' is not defined

L'avant dernière ligne reprend l'instruction qui a causé l'erreur d'exécution (à

savoir print(heigth) dans notre cas). La dernière ligne fournit une explication sur
la cause de l'erreur (celle qui commence par NameError). Dans cet exemple,
elle indique que le nom heigth n'est pas défini, c'est-à-dire qu'il ne correspond
pas à une variable initialisée.

4. Modification de variable

Une fois une variable initialisée, on peut donc modifier sa valeur en utilisant de
nouveau l'opérateur d'affectation (=). La valeur actuelle de la variable est
remplacée par la nouvelle valeur qu'on lui affecte. Dans l'exemple suivant, on
initialise une variable à la valeur 12 et on remplace ensuite sa valeur par 99 :
data = 12
data = 99
print(data)

Le résultat de l'exécution sera 99 (il n’y a plus de trace de 12).

6
 5. Affectation composée

Ce que l'on doit parfois faire, c'est mettre à jour une variable par rapport à la
valeur qu'elle possède actuellement. Par exemple, si on veut augmenter la valeur
d'une variable data de 1, on doit écrire :

data = data + 1

Pour simplifier cette instruction, Python propose l'opérateur += qui fait l'addition
suivie de l'affectation en une fois. L'exemple précédent se réécrit donc comme
suit :

data += 1

Un tel opérateur permet de réaliser une affectation composée, c'est-à-dire une

opération directement suivie d'une affectation. On peut notamment l'utiliser avec
les sept opérateurs arithmétiques vus précédemment.

II. Les types de données en Python ?

Pour définir les opérations autorisées sur une donnée, Python doit associe à chacune
un type. Dans cette partie de cours nous allons parler de types dits simples (Nombre,
chaine de caractères … ), des chapitres entiers seront consacrés aux types plus
complexes (Tableaux, Listes par exemple ).

1. Les nombres entiers :

Python différencie les entiers des nombres à virgule flottante, et cela surtout pour une
question de place en mémoire et aussi parce que pour un ordinateur, les opérations
que l'on effectue sur des nombres à virgule ne sont pas les mêmes que celles sur les
entiers, et cette distinction reste encore d'actualité de nos jours.

Le type entier se nomme int en Python (qui correspond à l'anglais « integer », c'est-à-
dire entier). La forme d'un entier est un nombre sans virgule.

2. Les nombres flottants :

Les flottants sont les nombres à virgule. Ils se nomment float en Python (ce qui signifie
« flottant » en anglais).
La syntaxe d'un nombre flottant est celle d'un nombre à virgule (la virgule est
remplacée par un point). Si ce nombre n'a pas de partie flottante mais qu’on veut qu'il
soit considéré par le système comme un flottant, on peut lui ajouter une partie flottante
de 0 (exemple 52.0).

3. Les chaînes de caractères

Les types de données disponibles en Python ne sont pas limités aux seuls nombres,
bien loin de là. Le dernier type « simple » que nous verrons dans ce chapitre est la
chaîne de caractères. Ce type de donnée permet de stocker une série de lettres,
pourquoi pas une phrase.

On peut écrire une chaîne de caractères de différentes façons :

7
 -Entre guillemets ("ceci est une chaîne de caractères") ;
-Entre apostrophes ('ceci est une chaîne de caractères') ;
-Entre triples guillemets ("""ceci est une chaîne de caractères""" ).

On peut, à l'instar des nombres (et de tous les types de données) stocker une chaîne
de caractères dans une variable : (ma_chaine = "Bonjour, la foule !")
Si on utilise les délimiteurs simples (le guillemet ou l'apostrophe) pour encadrer une
chaîne de caractères, il se pose le problème des guillemets ou apostrophes que peut
contenir la dite chaîne. Par exemple, si on tape chaine = 'J'aime le Python!', on
obtienne le message suivant :
SyntaxError: invalid syntax

Ceci est dû au fait que l'apostrophe de « J'aime » est considérée par Python comme la
fin de la chaîne et qu'il ne sait pas quoi faire de tout ce qui se trouve au-delà.
Pour pallier ce problème, il faut échapper les apostrophes se trouvant au cœur de la
chaîne. On insère ainsi un caractère antislash « \ » avant les apostrophes contenues
dans le message :
chaine = 'J\'aime le Python!'

On doit également échapper les guillemets si on utilise les guillemets comme

délimiteurs :

chaine2 = "\"Le seul individu formé, c'est celui qui a appris comment
apprendre (...)\" (Karl Rogers, 1976)"

Le caractère d'échappement « \ » est utilisé pour créer d'autres signes très utiles. Ainsi,
« \n » symbolise un saut de ligne
("essai\nsur\nplusieurs\nlignes"). Pour écrire un véritable anti-slash dans une
chaîne, il faut l'échapper lui-même (et donc écrire « \\ »).

Remarque : d’autres type seront vus plus loin (liste, Tuple, Ensemble et dictionnaire)

C. Entrée/Sortie en Python – input/print

Pour pouvoir communiquer avec l’extérieur, un programme doit employer des fonctions
dites d’entrée/sortie. Il s’agit des fonctions prédéfinies print et input.

1. Fonction print

La fonction print permet d'afficher une donnée, peu importe son type. En réalité, la
fonction affiche une représentation de la donnée sous forme d'une chaine de
caractères. En plus, elle ajoute automatiquement un retour à la ligne, ainsi, deux
appels successifs à la fonction print résulteront en l'affichage de deux lignes.

La forme générale de la fonction print permet d'afficher un nombre quelconque de

valeurs, que l'on doit séparer par des virgules. Par défaut, les différentes valeurs seront
séparées par une espace (lorsqu'il désigne le caractère d'espacement blanc, le nom
espace est féminin).

8
L'exemple suivant affiche la phrase «Né en 1990 j'ai 20 ans.» :

annee = 2020
naissance = 1990
age = annee - naissance
print('Né en', annee, "j'ai", age, 'ans.')

On remarque que l'alternance entre guillemets simples et doubles pour délimiter les
chaines de caractères, contrainte par le fait que la deuxième chaine de caractères
contient un guillemet simple. On aurait également pu utiliser des guillemets doubles
partout, évidemment.

Par défaut, la fonction print ajoute donc un retour à la ligne après ce qu'elle doit
afficher, et elle sépare les différentes valeurs à afficher avec une espace. On peut
changer cette configuration par défaut à l'aide des paramètres nommés end et sep.
Avec ces derniers, on peut spécifier les chaines de caractères à afficher
respectivement après le contenu et entre les valeurs.

L'exemple suivant modifie ces deux valeurs par défaut :

day = 4
month = 8
year = 1990

print('Né le :', end=' ')

print(day, month, year, sep='/')

Le premier appel à la fonction print va donc afficher la chaine de caractères «Né le :»

et terminera par une espace, au lieu d'un retour à la ligne. Le second appel affichera la
valeur des trois variables, mais en les séparant par le caractère / au lieu d'une espace :
Né le : 4/8/1990

Sortie formatée :
Au lieu de fournir plusieurs valeurs à la fonction print, on aurait également pu
construire la chaine de caractères en utilisant la concaténation. Dans ce cas, il faudra
convertir toutes les valeurs concaténées en chaines de caractères pour que cela
fonctionne. L'exemple précédent peut se réécrire comme suit :

print('Né en ' + str(naissance) + " j'ai " + str(age) + ' ans.')

str (string) : est une fonction prédéfinie (de langage) qui permet la conversion en
chaine de caractères.

2. Fonction input
Alors que la fonction print permet à un programme de produire une sortie, on va
pouvoir lire une entrée grâce à la fonction input. Cette fonction, une fois appelée,
arrête l'exécution du programme et attend que l'utilisateur saisisse un texte. Ce dernier
est ensuite rapatrié et peut, par exemple, être stocké dans une variable. Voici un
programme qui vous demande votre prénom, puis vous souhaite la bienvenue :

9
prenom = input('Quel est ton prénom ? ')
print('Bonjour', prenom, 'et bienvenue !')

L'exécution de ce programme pourrait, par exemple, produire le résultat suivant,

sachant que le mot «Anouar» a été saisi par l'utilisateur :
Quel est ton prénom ? Sébastien
Bonjour Anouar et bienvenue !

La fonction input renvoie toujours le texte saisi par l'utilisateur sous forme d'une chaine
de caractères. Il faudra donc éventuellement prévoir une conversion, si on veut que
l'utilisateur saisisse autre chose, comme un nombre entier, par exemple.

La suite du programme d'exemple demande à l'utilisateur quelle est son année de

naissance, puis calcule et affiche son âge :

s = input('Quel est ton année de naissance ? ')

annee = 2020
naissance = int(s)
print('Tu as', annee - naissance, 'ans.')

Par contre, si l'utilisateur ne saisit pas un nombre, une erreur se produira lors de
l'exécution comme on peut le voir ci-dessous, où l'utilisateur a saisi le texte «deux-
mille» :

Quel est ton année de naissance ? deux-mille

Traceback (most recent call last):
File "program.py", line 4, in <module>
naissance = int(s)
ValueError: invalid literal for int() with base 10: 'deux-mille'

NB : On verra plus loin durant cette formation comment gérer ce type d'erreur et
pouvoir, par exemple, afficher un message à l'utilisateur.

D.Structures de données
I. Les listes en Python
1. Définition

Une liste est une structure de données qui contient une série de valeurs. Python
autorise la construction de liste contenant des valeurs de types différents (par exemple
entier et chaîne de caractères), ce qui leur confère une grande flexibilité. Une liste est
déclarée par une série de valeurs (les guillemets, simples ou doubles, s'il s'agit de
chaînes de caractères) séparées par des virgules, et le tout encadré par
des crochets.

Exemples :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> tailles = [5, 2.5, 1.75, 0.15]
10
>>> mixte = ['girafe', 5, 'souris', 0.15]
>>> animaux
['girafe', 'tigre', 'singe', 'souris']
>>> tailles
[5, 2.5, 1.75, 0.15]
>>> mixte
['girafe', 5, 'souris', 0.15]

2. Utilisation
Un des gros avantages d'une liste est que l’on peut appeler ses éléments par leur
position. Ce numéro est appelé indice (ou index) de la liste.

liste : ['girafe', 'tigre', 'singe', 'souris']

indice : 0 1 2 3

Les indices d'une liste de n éléments commence à 0 et se termine à n-1.

Par conséquent, dans l’exemple précèdent, si on appelle l'élément d'indice 4 de la
liste, Python renverra un message d'erreur :
>>> animaux[4]
Traceback (innermost last):
File "<stdin>", line 1, in ?
IndexError: list index out of range

3. Opération sur les listes

Tout comme les chaînes de caractères, les listes supportent l'opérateur + de
concaténation, ainsi que l'opérateur * pour la duplication :
>>> ani1 = ['girafe', 'tigre']
>>> ani2 = ['singe', 'souris']
>>> ani1 + ani2
['girafe', 'tigre', 'singe', 'souris']
>>> ani1 * 3
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']

La méthode .append() est utilisée lorsqu’on souhaite ajouter un seul élément à la fin
d'une liste.
1 >>> a = [15, -5]
2 >>> a.append(13)
3 >>> a
4 [15, -5, 13]
5 >>> a.append(-3)
6 >>> a
7 [15, -5, 13, -3]

4. Indiçage négatif

La liste peut également être indexée avec des nombres négatifs selon le modèle
suivant :

11
1 liste : ['girafe', 'tigre', 'singe', 'souris']
2 indice positif : 0 1 2 3
3 indice négatif : -4 -3 -2 -1
ou encore :
1 liste : ['A','B','C','D','E','F']
2 indice positif : 0 1 2 3 4 5
3 indice négatif : -6 -5 -4 -3 - 2 -1

Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage est
qu’on peut accéder au dernier élément d'une liste à l'aide de l'indice -1 sans pour
autant connaître la longueur de cette liste. L'avant-dernier élément a lui l'indice -2,
l'avant-avant dernier l'indice -3, etc.
Pour accéder au premier élément de la liste avec un indice négatif, il faut par contre
connaître le bon indice, donc on utilise l’indice 0.
5. Tranches
Un autre avantage des listes est la possibilité de sélectionner une partie d'une liste en
utilisant un indiçage construit sur le modèle [m:n+1] pour récupérer tous les éléments,
du émième au énième (de l'élément m inclus à l'élément n+1 exclu). On dit alors
qu'on récupère une tranche de la liste, par exemple :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> animaux[0:2]
['girafe', 'tigre']
>>> animaux[0:3]
['girafe', 'tigre', 'singe']
>>> animaux[0:]
['girafe', 'tigre', 'singe', 'souris']
>>> animaux[:]
['girafe', 'tigre', 'singe', 'souris']
>>> animaux[1:]
['tigre', 'singe', 'souris']
>>> animaux[1:-1]
['tigre', 'singe']

NB : lorsqu’aucun indice n'est indiqué à gauche ou à droite du symbole deux-points,

Python prend par défaut tous les éléments depuis le début ou tous les éléments jusqu'à
la fin respectivement.

On peut aussi préciser le pas en ajoutant un symbole deux-points supplémentaire et en

indiquant le pas par un entier.
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> animaux[0:3:2]
['girafe', 'singe']
>>> x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
12
>>> x[::2]
[0, 2, 4, 6, 8]
>>> x[::3]
[0, 3, 6, 9]
>>> x[1:6:3]
[1, 4]

L'accès au contenu d'une liste fonctionne alors sur le modèle liste[début:fin:pas].

6. La fonction len()
L'instruction len() permet de connaître la longueur d'une liste, c'est-à-dire le nombre
d'éléments que contient la liste.

Exemple :

1 >>> animaux = ['girafe', 'tigre', 'singe', 'souris']

2 >>> len(animaux)
34
4 >>> len([1, 2, 3, 4, 5, 6, 7, 8])
58

7. Les fonctions range() et list()

L'instruction range() est une fonction spéciale en Python qui génère des nombres
entiers compris dans un intervalle. Lorsqu'elle est utilisée en combinaison avec la
fonction list(), on obtient une liste d'entiers.
Exemple :
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La commande list(range(10)) a généré une liste contenant tous les nombres entiers de
0 inclus à 10 exclu.

Dans l'exemple ci-dessus, la fonction range() a pris un argument, mais elle peut
également prendre deux ou trois arguments, voyez plutôt :
>>> list(range(0, 5))
[0, 1, 2, 3, 4]
>>> list(range(15, 20))
[15, 16, 17, 18, 19]
>>> list(range(0, 1000, 200))
[0, 200, 400, 600, 800]
>>> list(range(2, -2, -1))
[2, 1, 0, -1]

L'instruction range() fonctionne sur le modèle range([début,] fin[, pas]). Les

arguments entre crochets sont optionnels. Pour obtenir une liste de nombres entiers, il
faut l'utiliser systématiquement avec la fonction list().

Enfin, on prend garde aux arguments optionnels par défaut

(0 pour début et 1 pour pas) :
13
>>> list(range(10,0))
[]

Ici la liste est vide car Python a pris la valeur du pas par défaut qui est de 1. Ainsi, si
on commence à 10 et qu'on avance par pas de 1, on ne pourra jamais atteindre 0.
Python génère ainsi une liste vide. Pour éviter ça, il faudrait, par exemple, préciser un
pas de -1 pour obtenir une liste d'entiers décroissants :
>>> list(range(10,0,-1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

8. Les listes de listes

Il est possible de construire des listes de listes. Cette fonctionnalité peut parfois être
très pratique.
Exemple :
>>> enclos1 = ['girafe', 4]
>>> enclos2 = ['tigre', 2]
>>> enclos3 = ['singe', 5]
>>> zoo = [enclos1, enclos2, enclos3]
>>> zoo
[['girafe', 4], ['tigre', 2], ['singe', 5]]

Dans cet exemple, chaque sous-liste contient une catégorie d'animal et le nombre
d'animaux pour chaque catégorie.
Pour accéder à un élément de la liste, on utilise l'indiçage habituel :
>>> zoo[1]
['tigre', 2]

Pour accéder à un élément de la sous-liste, on utilise un double indiçage :

>>> zoo[1][0]
'tigre'
>>> zoo[1][1]
2

9. méthodes supplémentaires des objets de type liste :

Dans cette partie nous allons reprendre plus en détail quelques points déjà décrits
précédemment et introduit également de nouvelles notions.
Voici ainsi toutes les méthodes des objets de type liste :

list.append(x) : Ajoute un élément à la fin de la liste. Équivalent à a[len(a):] = [x].

list.extend(iterable) : Étend la liste en y ajoutant tous les éléments de l'itérable.

Équivalent à a[len(a):] = iterable.

list.insert(i, x) : Insère un élément à la position indiquée. Le premier argument est la

position de l'élément courant avant lequel l'insertion doit s'effectuer, donc a.insert(0, x)
insère l'élément en tête de la liste et a.insert(len(a), x) est équivalent à a.append(x).

14
list.remove(x) : Supprime de la liste le premier élément dont la valeur est égale à x.
Une exception ValueError est levée s'il n'existe aucun élément avec cette valeur.

list.pop([i]) : Enlève de la liste l'élément situé à la position indiquée et le renvoie en

valeur de retour. Si aucune position n'est spécifiée, a.pop() enlève et renvoie le dernier
élément de la liste (les crochets autour du i dans la signature de la méthode indiquent
que ce paramètre est facultatif et non qu’on doit placer des crochets dans le code !

list.clear() : Supprime tous les éléments de la liste. Équivalent à del a[:].

list.index(x[, start[, end]]) : Renvoie la position du premier élément de la liste dont la

valeur égale x (en commençant à compter les positions à partir de zéro). Une
exception ValueError est levée si aucun élément n'est trouvé.

Les arguments optionnels start et end sont utilisés pour limiter la recherche à une
sous-séquence particulière. L'indice renvoyé est calculé relativement au début de la
séquence complète et non relativement à start.

list.count(x) : Renvoie le nombre d'éléments ayant la valeur x dans la liste.

list.sort(key=None, reverse=False) : Ordonne les éléments dans la liste (les

arguments peuvent personnaliser l'ordonnancement, voir sorted() pour leur
explication).

list.reverse() : Inverse l'ordre des éléments dans la liste.

list.copy() : Renvoie une copie superficielle de la liste. Équivalent à a[:].

L'exemple suivant utilise la plupart des méthodes des listes :

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi',

'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4) # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple',
'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple',
'orange', 'grape']
>>> fruits.sort()
>>> fruits
15
 ['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi',
'orange', 'pear']
>>> fruits.pop()
'pear'

Remarque :

Comme on peut le remarquer dans l’exemple :

- les méthodes telles que insert, remove ou sort, qui ne font que modifier la liste,
n'affichent pas de valeur de retour (elles renvoient None) .

- Toutes les données ne peuvent pas être ordonnées ou comparées. Par exemple,
[None, 'hello', 10] ne sera pas ordonné parce que les entiers ne peuvent pas être
comparés aux chaînes de caractères et None ne peut pas être comparé à
d'autres types. En outre, il existe certains types qui n'ont pas de relation d'ordre
définie. Par exemple, 3+4j < 5+7j n'est pas une comparaison valide.

10. Utilisation des listes comme des piles

Les méthodes des listes rendent très facile leur utilisation comme des piles, où le
dernier élément ajouté est le premier récupéré (« dernier entré, premier sorti » ou LIFO
pour last-in, first-out en anglais). Pour ajouter un élément sur la pile, utilisez la méthode
append(). Pour récupérer l'objet au sommet de la pile, utilisez la méthode pop() sans
indicateur de position.

Exemple :

>>> stack = [3, 4, 5]

>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

11. Utilisation des listes comme des files

Il est également possible d'utiliser une liste comme une file, où le premier élément
ajouté est le premier récupéré (« premier entré, premier sorti » ou FIFO pour first-in,
first-out) ; toutefois, les listes ne sont pas très efficaces pour réaliser ce type de
traitement. Alors que les ajouts et suppressions en fin de liste sont rapides, les

16
opérations d'insertions ou de retraits en début de liste sont lentes (car tous les autres
éléments doivent être décalés d'une position).

Ainsi, pour implémenter une file, on utilise la classe collections.deque qui a été
conçue pour réaliser rapidement les opérations d'ajouts et de retraits aux deux
extrémités.

Exemple :
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

II. L'instruction del

Il existe un moyen de retirer un élément d'une liste à partir de sa position au lieu de sa
valeur : l'instruction del. Cette instruction diffère de la méthode pop() qui, elle, renvoie
une valeur.
L'instruction del peut également être utilisée pour supprimer des tranches d'une liste
ou la vider complètement (ce que nous avions fait auparavant en affectant une liste
vide à la tranche).

Exemple :
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

III. Tuples et séquences

Nous avons vu que les listes et les chaînes de caractères ont beaucoup de propriétés
en commun, comme l'indiçage et les opérations sur des tranches. Ce sont deux
exemples de séquences (voir Types séquentiels — list, tuple, range). Comme Python
est un langage en constante évolution, d'autres types de séquences y seront peut-être
ajoutés. Il existe également un autre type standard de séquence : le tuple (ou n-uplet,
dénomination que nous utiliserons dans la suite de cette documentation).

Un n-uplet consiste en différentes valeurs séparées par des virgules.

17
Exemple :
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

Les n-uplets sont toujours affichés entre parenthèses, de façon à ce que des n-uplets
imbriqués soient interprétés correctement ; ils peuvent être saisis avec ou sans
parenthèses, même si celles-ci sont souvent nécessaires (notamment lorsqu'un n-
uplet fait partie d'une expression plus longue). Il n'est pas possible d'affecter de valeur
à un élément d'un n-uplet ; par contre, il est possible de créer des n-uplets contenant
des objets muables, comme des listes.

Si les n-uplets peuvent sembler similaires aux listes, ils sont souvent utilisés dans des
cas différents et pour des raisons différentes. Les n-uplets sont immuables et
contiennent souvent des séquences hétérogènes d'éléments qui sont accédés par «
dissociation » (unpacking en anglais) ou par indice (ou même par attributs dans le cas
des namedtuples). Les listes sont souvent muables et contiennent des éléments
généralement homogènes qui sont accédés par itération sur la liste.

Un problème spécifique est la construction de n-uplets ne contenant aucun ou un seul

élément : la syntaxe a quelques tournures spécifiques pour s'en accommoder. Les n-
uplets vides sont construits par une paire de parenthèses vides ; un n-uplet avec un
seul élément est construit en faisant suivre la valeur par une virgule (il n'est pas
suffisant de placer cette valeur entre parenthèses). Pas très joli, mais efficace.

Exemple :
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

18
L'instruction t = 12345, 54321, 'hello !' est un exemple d'un d'agrégation de n-
uplet (tuple packing en anglais) : les valeurs 12345, 54321 et hello ! sont agrégées
ensemble dans un n-uplet. L'opération inverse est aussi possible :

>>> x, y, z = t

IV. Ensembles

Python fournit également un type de donnée pour les ensembles. Un ensemble est
une collection non ordonnée sans élément dupliqué.
Les ensembles savent également effectuer les opérations mathématiques telles que
les unions, intersections, différences et différences symétriques.

Des accolades ou la fonction set() peuvent être utilisés pour créer des ensembles.
Pour créer un ensemble vide, {} ne fonctionne pas, cela crée un dictionnaire vide. On
utilise plutôt set().

Démonstration :

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange',

'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words

...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

V. Dictionnaires

Un autre type de donnée très utile, natif dans Python, est le dictionnaire . Ces
dictionnaires sont parfois présents dans d'autres langages sous le nom de « mémoires
associatives » ou de « tableaux associatifs ». À la différence des séquences, qui
sont indexées par des nombres, les dictionnaires sont indexés par des clés, qui
peuvent être de n'importe quel type immuable ; les chaînes de caractères et les
19
nombres peuvent toujours être des clés. Des n-uplets peuvent être utilisés comme
clés s'ils ne contiennent que des chaînes, des nombres ou des n-uplets ; si un n-uplet
contient un objet muable, de façon directe ou indirecte, il ne peut pas être utilisé
comme une clé. On ne peut pas utiliser des listes comme clés, car les listes peuvent
être modifiées en place en utilisant des affectations par position, par tranches ou via
des méthodes comme append() ou extend().
Le plus simple est de considérer les dictionnaires comme des ensembles de paires clé:
valeur, les clés devant être uniques (au sein d'un dictionnaire). Une paire d'accolades
crée un dictionnaire vide : {}. Placer une liste de paires clé:valeur séparées par des
virgules à l'intérieur des accolades ajoute les valeurs correspondantes au dictionnaire ;
c'est également de cette façon que les dictionnaires sont affichés.
Les opérations classiques sur un dictionnaire consistent à stocker une valeur pour une
clé et à extraire la valeur correspondant à une clé. Il est également possible de
supprimer une paire clé-valeur avec del. Si on stocke une valeur pour une clé qui est
déjà utilisée, l'ancienne valeur associée à cette clé est perdue. Si op tente d'extraire
une valeur associée à une clé qui n'existe pas, une exception est levée.
Exécuter list(d) sur un dictionnaire d renvoie une liste de toutes les clés utilisées dans
le dictionnaire, dans l'ordre d'insertion (si on veut qu'elles soient ordonnées, on utilise
sorted(d)). Pour tester si une clé est dans le dictionnaire, on utilise le mot-clé in.
Exemple utilisant un dictionnaire :
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

Le constructeur dict() fabrique un dictionnaire directement à partir d'une liste de paires

clé-valeur stockées sous la forme de n-uplets :
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}

20
 E. Les tests en Python – if … else
1. Définition :
Les tests permettent d’exécuter des instructions différentes selon la valeur d’une
condition logique. Ils sont un élément essentiel à tout langage informatique car ils
permettent à l'ordinateur de prendre des décisions. Pour cela, Python utilise
l'instruction if selon la syntaxe suivante :
if condition1 : #Si la condition1 est vraie
instruction1
instruction2
...
else : #Sinon, c'est-à-dire, si la condition1 est fausse
instruction3
instruction4
...
Exemple :
>>> x = input()
>>> y = input()
>>> if x == y:
... print("Les deux valeurs sont égales ")
... else :
print("Les deux valeurs sont différentes !")

La clause else est facultative. Ainsi, lorsque la condition condition1 est fausse et qu’il
n’y a aucune instruction à exécuter dans ce cas, cette clause est inutile.

Exemple:
>>> x = 2
>>> if x == 2:
... print("Le test est vrai !")
Le test est vrai !

S’il est nécessaire d’enchaîner plusieurs tests d’affilée, il est possible de condenser
l’écriture avec le mot-clé elif :
if condition1 :
instruction1
elif condition2 : # Le mot clé elif est une contraction de « else if »
instruction2
elif condition3 :
instruction3
else :
instruction4
instructionN

Explication :
Si la condition1 est vérifiée, l’ordinateur passe par l’instruction1 puis instructionN
Sinon, si la condition2 est vérifiée, l’ordinateur passe par l’instruction2 puis instructionN
Sinon, si la condition3 est vérifiée, l’ordinateur passe par l’instruction3 puis instructionN
Sinon (c'est-à-dire si aucune des conditions est vérifiée, l’ordinateur passe par
l’instruction4 puis instructionN.

21
 2. Operateurs utilisées dans les tests :

a) Les opérateurs de comparaison :

<, > inférieur, supérieur

<=, >= inférieur ou égal, supérieur ou égal

==, != égal, différent

is, not is x is y vérifie que x et y sont égaux, not is, différents, l’opérateur is est
différent de l’opérateur ==, il est expliqué au paragraphe Copie

in, not in appartient, n’appartient pas

b) Les opérateurs de comparaison :

not négation

and et logique

or ou logique
3. Ecriture condensée :
Il existe deux écritures condensées de tests :

- La première consiste à écrire un test et l’unique instruction qui en dépend sur une
seule ligne :
if condition : instruction1
else : instruction2

- Le second cas d’écriture condensée concerne les comparaisons enchaînées.

Le test :
if 3 < x and x < 5 : instruction
peut être condensé par :
if 3 < x < 5 : instruction.
Il est ainsi possible de juxtaposer autant de comparaisons que nécessaire :
if 3 < x < y < 5 : instruction.

F. Les Boucles en Python

En programmation, on est souvent amené à répéter plusieurs fois une instruction.
Incontournables à tout langage de programmation, les boucles vont aider à réaliser
cette tâche de manière compacte et efficace.
Ils existent deux types de boucles :

- Boucle bornée
Quand on sait combien de fois doit avoir lieu la répétition, on utilise généralement une
boucle for.

- Boucle non bornée

Si on ne connait pas à l’avance le nombre de répétitions, on choisit une boucle while.
22
 1. La Boucle for :

La boucle "for" est la séquence d'itération en Python, elle permet de traverser les
éléments de tout objets qui répond aux opérations d'indiçage de séquence. Elle
est donc spécialisée dans le parcours d'une séquence de plusieurs données (les
listes, les tuples et d'autres objets issus de classes).
Nous n'avons pas encore vu ces séquences assez particulières mais très
répandues. Toutefois, il en existe un type que nous avons rencontré : les
chaînes de caractères qui sont des séquences de caractères.

La boucle "for" commence par une ligne d'en-tête qui spécifie une cible
d'affectation, ainsi qu'un objet qui sera itérer.

for <cible> in <objet> :

<instructions>
else :
<instructions>

Exemple :
chaine = "Bonjour"
for lettre in chaine:
print(lettre)

Résultat après l’exécution :

B
o
n
j
o
u
r

Utilisation de la fonction range()

Python possède la fonction range() que nous avons rencontrée précédemment
dans le chapitre 4 sur les Listes et qui est aussi bien commode pour faire une
boucle sur une liste d'entiers de manière automatique :
>>> for i in range(4):
... print(i)
...
0
1
2
3

Dans cet exemple, nous pouvons faire plusieurs remarques importantes :

23
Contrairement à la création de liste avec list(range(4)), la fonction range() peut
être utilisée telle quelle dans une boucle. Il n'est pas nécessaire de taper for i in
list(range(4)): même si cela fonctionnerait également.

Comment cela est-ce possible ? Et bien range() est une fonction qui a été
spécialement conçue pour cela, c'est-à-dire que l'on peut itérer directement
dessus. Pour Python, il s'agit d'un nouveau type, par exemple dans l'instruction x
= range(3) la variable x est de type range (tout comme on avait les
types int, float, str ou list) à utiliser spécialement avec les boucles.

L'instruction list(range(4)) se contente de transformer un objet de type range en

un objet de type list. Il n'y aucun intérêt à utiliser dans une boucle la
construction for i in list(range(4)):. C'est même contre-productif. En
effet, range() se contente de stocker l'entier actuel, le pas pour passer à l'entier
suivant, et le dernier entier à parcourir, ce qui revient à stocker seulement 3
nombres entiers et ce quelle que soit la longueur de la séquence, même avec
un range(1000000). Si on utilisait list(range(1000000)), Python construirait
d'abord une liste de 1 million d'éléments dans la mémoire puis itérerait dessus,
d'où une énorme perte de temps !

Itération sur les indices

On va parcourir la liste « animaux » par une itération sur ses indices :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> for i in range(4):
... print(animaux[i])
...
girafe
tigre
singe
souris

La variable i prendra les valeurs successives 0, 1, 2 et 3 et on accèdera à

chaque élément de la liste animaux par son indice (i.e. animaux[i]). On note à
nouveau le nom i de la variable d'itération car on itère sur les indices.

Quand utiliser l'une ou l'autre des 2 méthodes ? La plus efficace est celle qui
réalise les itérations directement sur les éléments :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> for animal in animaux:
... print(animal)
...
girafe
tigre
singe
souris

24
Toutefois, il se peut qu'au cours d'une boucle on aura besoin des indices, auquel
cas on doit itérer sur les indices :
>>> animaux = ['girafe', 'tigre', 'singe', 'souris']
>>> for i in range(len(animaux)):
... print("L'animal {} est un(e) {}".format(i,
animaux[i]))
...
L'animal 0 est un(e) girafe
L'animal 1 est un(e) tigre
L'animal 2 est un(e) singe
L'animal 3 est un(e) souris

Python possède toutefois la fonction enumerate() qui permet d'itérer sur les
indices et les éléments eux-mêmes.
>>> animaux = ['girafe','tigre','singe','souris']
>>> for i, animal in enumerate(animaux):
... print("L'animal {} est un(e) {}".format(i, animal))
...
L'animal 0 est un(e) girafe
L'animal 1 est un(e) tigre
L'animal 2 est un(e) singe
L'animal 3 est un(e) souris

2. La Boucle while (tant que):

L'instruction Python "while" est la construction d'itération la plus générale. "while"

exécute de manière répétitive le bloc indenté tant que le test de condition est réalisé.

"while" consiste en une ligne d'en-tête avec une expression de test, suivie d'un bloc
d’instructions.

while <test> :
<instructions>

Exemple :

x = 1
while x < 10:
print("x a pour valeur", x)
x = x * 2
print("Fin")
25
Apres l’exécution ce programme affiche :

x a pour valeur 1
x a pour valeur 2
x a pour valeur 4
x a pour valeur 8
Fin

Le mot-clé while signifie tant que en anglais. Le corps de la boucle (c’est-à-dire le bloc
d’instructions indentées) sera répété tant que la condition est vraie.
Dans l’exemple ci-dessus, x sera multiplié par 2 tant que sa valeur reste inférieure à
10.
Remarque : Si la condition est fausse au départ, le corps de la boucle n’est jamais
exécuté. Si la condition reste toujours vraie, alors le corps de la boucle est répété
indéfiniment.

Les instructions break et continue, et la clause else dans les boucles :

Il est important de voir ces instructions en même temps que les boucles.
La clause "else" exécute le bloc si la boucle se termine normalement.
Ces deux instructions, "break", et "continue", servent à gérer la continuité d'une
boucle suivant les actions qui se passent à l'intérieur.
- L'instruction "break" a pour but de sortir de la boucle instantanément et de passer à la
suite de programme.

Exemple :

while 1: # 1 est toujours vrai -> boucle infinie

lettre = input("Tapez 'Q' pour quitter : ")
if lettre == "Q":
print("Fin de la boucle")
break

L'instruction "break" annule le passage dans la boucle "else".

- "continue" saute au début de la boucle la plus imbriquée.

Exemple :

i = 1
while i < 20: # Tant que i est inférieure à 20
if i % 3 == 0:
i += 4 # On ajoute 4 à i
print("On incrémente i de 4. i est maintenant égale à", i)
continue # On retourne au while sans exécuter la suite
print("La variable i =", i)
i += 1 # Dans le cas classique on ajoute juste 1 à i

26
 G. Les fonctions et les procédures en Python

I. Principe et généralités

Une fonction (procédure) est une suite ou bloc d'instructions que l'on peut appeler
avec son nom à tout moment dans un programme.
En programmation, l’utilisation de ces blocs d’instructions est très utiles pour réaliser
plusieurs fois la même opération au sein d'un programme sans être obligé de répéter
les mêmes séries d’instructions.
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.

Exemple de fonctions prédéfinies du langage Python : print(), len(), int(), range(),…

Fonctionnement schématique :

Pour effectuer une tâche (2), la fonction reçoit éventuellement à son appel des
arguments (1) et renvoie éventuellement quelque chose (3).
Chaque fonction effectue en général une tâche unique et précise. Si cela se
complique, il est plus judicieux d'écrire plusieurs fonctions (qui peuvent
éventuellement s'appeler les unes après les autres).

Exemple :
Considérons la fonction len() appelée de la manière suivante :

1 >>> len([0, 1, 2])

2 3

1. Appelle len() en lui passant une liste en argument (ici la liste [0, 1, 2]) ;
2. la fonction calcule la longueur de cette liste ;
3. elle renvoie l’entier 3 correspondant à cette longueur.

En plus des fonctions connues par le langage Python, le programmeur peut créer ses
propres fonctions pour rendre son code plus lisible et plus clair en le fractionnant en
blocs logiques.

27
II. Création de fonctions

1- Définir une fonction :

Il s’agit de déclarer la fonction avant de l’utiliser. De manière générale, la syntaxe
d’une déclaration de fonctions est la suivante :

def <nom_fonction>(<paramètres>): # En-tête de la fonction

<instruction1>
<instruction2> # Corps de la fonction (traitement à effectuer)
...
return <valeur> # spécification de la valeur que doit retourner la fonction

Exemple :

>>> def carre(x):

... return x*x
...
>>> carre(2)
4
>>>

L'instruction return signifie qu'on va renvoyer la valeur de x*x, pour pouvoir la

récupérer ensuite dans le programme appelant (la valeur 4 dans l’exemple). Cette
instruction arrête le déroulement de la fonction, le code situé après le return ne
s'exécutera pas.

Remarque :

- La syntaxe de def utilisant les ’:’ comme les boucles for, while ainsi que les
tests if.
- De même que pour les boucles et les tests, l’indentation du corps de la fonction
est obligatoire.
- Un bloc d’instructions peut être créé pour exécuter une tache qui ne nécessite
pas de renvoyer une valeur. En Python, et pour garder la notion de fonction,
même ces genres de blocs sans instruction return explicite renvoient une valeur
qui est None. Cette valeur ignorée par l’interpréteur du langage sert à indiquer
qu’il n’y a pas de valeur.
- L’exécuteur sort de la fonction dès qu’il rencontre une instruction return (les
instructions suivant un return ne sont pas exécutées).
- Les fonctions sont capables de renvoyer plusieurs valeurs à la fois :

>>> def carre-et-cube(x):

... return [x**2,x**3]
...
>>> carre-et-cube(2)
[4, 8]
>>>

28
 2- Passage d’arguments
Un argument est une donnée ou valeur de programme à passer dans une fonction à
l’aide d’un paramètre.
Ainsi, une fonction peut être crée avec ou sans paramètres et cela selon qu’on veut y
passer d’arguments ou non.
Les paramètres d’une fonction et arguments à passer sont séparés par des virgules.

Exemple :
def compteur_complet(start, stop, step):
i = start
while i < stop:
print(i)
i = i + step

compteur_complet(1, 7, 2)

Cette fonction utilise 3 paramètres (start, stop, step) pour passer 3 arguments (1, 7, 2).
Elle affichera 1, 3 et 5 qui correspondent à l’exécution de la ligne print (i), mais ne
retournera que la valeur None ignorée par l’interpréteur Python.

Remarque :
Il est possible de passer un ou plusieurs argument(s) de manière facultative et de leur
attribuer une valeur par défaut. Dans ce cas, le ou les arguments facultatifs doivent
être situés à droite càd : def fct(x,y,z=1): et non pas def fct(z=1,x,y):
def table(nb, max=10):

def table(nb, max=10):

i = 0
while i < max:
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1

Il suffit de rajouter =10 après max. À présent, on peut appeler la fonction de deux
façons : soit en précisant le numéro de la table et le nombre maximum d'affichages,
soit en ne précisant que le numéro de la table (table(7)). Dans ce dernier cas, max
vaudra 10 par défaut.

Exemple :
Soit le code python suivant :

def fonc(a=1, b=2, c=3, d=4, e=5):

print("a =", a, "b =", b, "c =", c, "d =", d, "e =", e)

On a de nombreuses façons d'appeler cette fonction :

- fonc() Résultat : a = 1 b = 2 c = 3 d = 4 e = 5
- fonc(4) Résultat : a = 4 b = 2 c = 3 d = 4 e = 5
- fonc(b=8, d=5) Résultat : a = 1 b = 8 c = 3 d = 5 e = 5
- fonc(b=35, c=48, a=4, e=9) Résultat : a = 4 b = 35 c = 48 d = 4 e = 9

29
Ainsi, si on veut changer la valeur d'un paramètre, on tape son nom, suivi d'un signe
égal puis d'une valeur .Peu importent les paramètres qu’on précise, peu importe l'ordre
d'appel des paramètres.

3- Portée des variables (Variables locales, variables globales)

Lorsqu’une fonction est appelée, Python réserve pour elle (dans la mémoire de
l’ordinateur) un espace de noms. Cet espace de noms local à la fonction est à
distinguer de l’espace de noms global où se trouvaient les variables du programme
principal. Dans l’espace de noms local, on aura des variables qui ne sont accessibles
qu’au sein de la fonction. C’est par exemple le cas des
variables start, stop, step et i dans l’exemple précédent.
A chaque fois que des variables sont définies à l’intérieur du corps d’une fonction, ces
variables ne sont accessibles qu’à la fonction elle-même. On dit que ces variables sont
des variables locales à la fonction. Une variable locale peut avoir le même nom
qu’une variable de l’espace de noms global mais elle reste néanmoins indépendante.
Les contenus des variables locales sont stockés dans l’espace de noms local qui est
inaccessible depuis l’extérieur de la fonction.
Les variables définies à l’extérieur d’une fonction sont des variables globales. Leur
contenu est « visible » de l’intérieur d’une fonction, mais la fonction ne peut pas le
modifier.
Exemple :
def test():
b = 5
print(a, b)

a = 2
b = 7
test()
print(a, b)
Affichage après exécution :
2 5
2 7

On peut définir une fonction qui soit capable de modifier une variable globale. Pour
atteindre ce résultat, il suffira d’utiliser l’instruction global. Cette instruction permet
d’indiquer - à l’intérieur de la définition d’une fonction - quelles sont les variables à
traiter globalement.
On va ici créer une fonction qui a accès à la variable globale b.
def test():
global b
b = 5
print(a, b)
a = 2
b = 7
test()
print(a, b)

30
 Affichage après exécution :
2 5
2 5

Si on passe une liste en argument, elle est tout autant modifiable au sein de la fonction:
>>> def mafonction(x):
... x[1] = -15
...
>>> y = [1,2,3]
>>> mafonction(y)
>>> y
[1, -15, 3]
>>>

4- Les fonctions récursives

Comme l’ont montré des exemples précédents, une fonction peut 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.
On doit 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.
Cette fonction sera comme suit :

def factorielle(n) :
if n<=1 :
return 1
else :
return n * factorielle(n-1)
factorielle(4)
24
Factorielle(0)
1

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 la fonction avec une valeur
diminuée de 1 et etc. Jusqu’à ce que la valeur passée à factorielle() atteigne 1.

31
 H. Les modules (sys et ren) en Python
I. Définition

Les modules sont des programmes Python qui contiennent des fonctions ayant toutes
un rapport entre elles. Il s’agit du code pré-écrit (appelés aussi bibliothèque ou
librairie) que le programmeur peut utiliser à son compte pour son propre programme.
Ce code est composé ainsi de fonctions qui vont lui faciliter la vie en tant que
développeur.
Il existe un grand nombre de modules disponibles avec Python sans qu'il soit
nécessaire d'installer des bibliothèques supplémentaires (Par exemple le module
math qui contient, comme son nom l'indique, des fonctions mathématiques).

Parmi les librairies les plus connues on retrouve aussi : Numpy, Pandas, Matplotlib,
Scikitlearn, datetime, et d’autres.

Ainsi, si l'on veut travailler avec les fonctionnalités prévues par le module, il n'y a qu'à
importer le module et utiliser ensuite toutes les fonctions et variables prévues.

II. Importation de modules

L’importation d’un module peut se faire selon l’une des deux syntaxes suivantes :

1- : import nom_du_module

Cette instruction va importer toute la librairie d’un coup dans le code et on peut
commencer à l’utiliser.
L’utilisation de cette méthode permet donc d’importer tout une série de fonctions
organisées par «thèmes» (par exemple, les fonctions gérant les nombres
aléatoires avec random et les fonctions mathématiques avec math).

Exemple :

1 >>> import random

2 >>> random . randint (0, 10)
3 4

- Ligne 1 : l’instruction import importe le module random et donne accès à

toutes les fonctions du ce module sans que rien ne se passe à l’apparence.
Pour appeler une fonction du module ainsi importé, il suffit de taper le nom du
module suivi d'un point « . » puis du nom de la fonction.

- Ligne 2 : on a choisi d’utiliser la fonction randint(0, 10) du module random.

Cette fonction renvoie un nombre entier tiré aléatoirement entre 0 inclus et 10
inclus.

32
 2- : from nom_du_module import nom_de_la_fonction

Cette fois ci , en utilisant cette syntaxe, seule la fonction dont le nom

nom_de_la_fonction est importée . Cette méthode est utilisée pour certaines
librairies qui sont assez lourdes et si on n’aura pas besoin d’utiliser qu’une partie
de celles-ci.

Exemple :

1 >>> from random import randint

2 >>> randint (0, 10)
3 7

Comme on peut le remarquer dans cet exemple, il est inutile de répéter le nom
du module dans ce cas, seul le nom de la fonction en question est requis.

Remarque :
On peut appeler toutes les variables et fonctions d'un module en tapant « * » à la
place du nom de la fonction à importer.

Exemple :

1 >>> from random import *

2 >>> x = [1, 2, 3, 4]
3 >>> shuffle (x)
4 >>> x
5 [2, 3, 1, 4]
6 >>> shuffle (x)
7 >>> x
8 [4, 2, 1, 3]
9 >>> randint (0 ,50)
10 46
11 >>> uniform (0 ,2.5)
12 0.64943174760727951

L’instruction from random import * importe toutes les fonctions du module

random. On peut ainsi utiliser toutes ses fonctions directement, comme par
exemple shuffle() qui permute une liste aléatoirement.

III. Création de modules utilisateurs

En plus des modules prédéfinis, le développeur peut mettre ses programmes en boite
ou plutôt en fichier créant ainsi ses propres modules. Il s’agit d’utiliser le mécanisme
qui permet la sauvegarde des programmes Python pour être exécutés ultérieurement
en réutilisant les fonctions que contiennent sans avoir à les rédiger ou même les
copier !
Dans cette partie de cours nous verrons aussi comment créer des packages pour
regrouper nos modules ayant un rapport entre eux.

33
 1- Création d'un module :
En Python, la création d'un module est très simple. Il suffit d'écrire un ensemble de
fonctions (et/ou de constantes) dans un fichier, puis d'enregistrer ce dernier avec une
extension .py (comme n'importe quel script Python).

Exemple : Création un module simple sous le nom message.py :

"""Module inutile qui affiche des messages :-)."""

DATE = 01012020
def bonjour(nom):
"""Dit Bonjour."""
return "Bonjour " + nom
def ciao(nom):
"""Dit Ciao."""
return "Ciao " + nom
def hello(nom):
"""Dit Hello."""
return "Hello " + nom

2- Utilisation de module utilisateur :

Pour appeler une fonction ou une variable d’un module crée, il faut que le nom fichier
soit dans le répertoire courant (dans lequel on travaille) ou bien dans un répertoire listé
par la variable d'environnement PYTHONPATH de système d'exploitation. Ensuite, il
suffit d'importer le module et toutes ses fonctions (et constantes) seront alors
accessibles.

Le chargement du module se fait avec la commande import Nom_fichier.

Même que le fichier est bien enregistré avec une extension .py on ne la précise pas
lorsqu'on importe le module. Ensuite, on peut utiliser les fonctions comme avec un
module classique.
Le chargement de module message.py, se fera alors comme suit :

>>> import message

>>> message.hello("Joe")
'Hello Joe'
>>> message.ciao("Bill")
'Ciao Bill'
>>> message.bonjour("Monsieur")
'Bonjour Monsieur'
>>> message.DATE
01012020

IV. Exemple d’utilisation de quelques modules Python

Comme il est impossible d’évoquer tous les modules Python, à cause de leur
grand nombre, on ne présentera ici que quelques-uns parmi les plus
incontournables (C’est-à-dire ceux que l’on utilise couramment). Aussi nous
allons voir leur utilisation parmi d’autres en pratique (selon l’orientation du
stagiaire).

34
1- Les fonctions systèmes (sys):
Le module sys contient les fonctions nécessaires pour interagir avec Python et
récupérer des informations sur le système.
Exemples :
- Sys.platform : affiche la description du système d'exploitation
- Sys.version : affiche la version de python et du compilateur C
- Sys.hexversion : affiche la version exprimée en hexadécimal
- Sys.copyright : affiche le copyright
- Sys.path : renvoie une liste des chemins d'accès de python
(/usr/lib/python2.5...)
- Sys.exit() : pour quitter le programme (ou le shell)

2- Les nombres aléatoires (random) :

Dans son module random, Python propose toute une série de fonctions
permettant de générer des nombres aléatoires qui suivent différentes
distributions mathématiques.
Le module random contient les fonctions telles que : random() et randint().

Exemple :

>>> import random

>>> random
<module 'random' from 'C:\Python27\lib\random.pyc'>

>>> from random import random, randint

>>> random
<built-in method random of Random object at 0x03690268>

>>> random()
0.8871712328944913

3- Les modules mathématiques (math et numpy) :

Le module math (Bibliothèque standard) fourni les principales fonctions et constantes
mathématiques (cos(), sin(), tan() exp() …etc) .
Pour accéder à des objets mathématiques plus puissants, on pourra utiliser la
bibliothèque numpy.

35