Programmation en Python

Anthony Labarre

Année académique 2017–2018

2
Table des matières

1 Introduction à Python 5
1.1 Particularités de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.3 Objets (non) modifiables . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.4 Garbage collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.5 Messages d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Utilisation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Environnements de développement recommandés . . . . . . . . . . . . . . . . 9
1.5 Conventions de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6 Configuration des éditeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6.1 Geany. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6.2 PyCharm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2 Les bases du langage 13

2.1 Variables et types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.2 Transtypage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.3 Variables et affectations . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.1 Opérations sur les nombres . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.2 Opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.3 Opérations sur les chaînes . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.4 Formes condensées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Branchements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.1 Version basique du if . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.2 Alternative au if: le else . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.3 Autres options: le mot clé elif . . . . . . . . . . . . . . . . . . . . . . 18

3 Structures itérables et boucles for 19

3.1 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Un itérable particulier: range . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.2 Manipulation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.3 Itérer sur des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3
TABLE DES MATIÈRES TABLE DES MATIÈRES

3.5 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.5.1 Modification de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5.2 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5.3 Méthodes des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.6 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.7 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.7.1 Déclaration et manipulation . . . . . . . . . . . . . . . . . . . . . . . 29
3.7.2 Itérer sur des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . 29
3.8 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4 Les fonctions 31
4.1 Fonctions sans paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.2 Fonction avec paramètre(s) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3 Renvoi de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.4 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.5 Compléments sur les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Programmation en Python 4
Chapitre 1. Introduction à Python

Chapitre 1

Introduction à Python

Sommaire
1.1 Particularités de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.3 Objets (non) modifiables . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.4 Garbage collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.5 Messages d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Utilisation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Environnements de développement recommandés . . . . . . . . . . . . . 9
1.5 Conventions de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6 Configuration des éditeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6.1 Geany. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.6.2 PyCharm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.1 Particularités de Python

Python est au départ un langage de script, qui a grandement évolué pour devenir un langage
orienté objet et polyvalent. On peut exécuter du code Python soit sous la forme de programme,
soit en tapant des lignes de code dans un interpréteur. Il est également possible de compiler les
programmes que l’on écrit. Voici quelques particularités de ce langage, qui vous permettront de
le situer par rapport aux autres langages que vous connaissez.

1.1.1 Indentation

Dans les autres langages, l’indentation (le fait de décaler le début des lignes de code) que l’on
rencontre est recommandée pour des raisons de lisibilité; en Python, elle est essentielle car elle
délimite les blocs d’instructions et joue le rôle des accolades que l’on rencontre entre autres en
C/C++ et Java. Voici par exemple un programme écrit en C affichant les nombres de 1 à 20 en
précisant lesquels sont divisibles par 3.

Programmation en Python 5
 Chapitre 1. Introduction à Python

1 #include <stdio.h>
2

3 int main(int argc, char **argv) {

4 for(int i=1; i<21; ++i) {
5 printf("%d", i);
6 if(i % 3 == 0) {
7 printf(" (multiple de 3)");
8 }
9 printf("\n");
10 }
11 }

En guise de comparaison, voici un programme en Python qui fait exactement la même chose:
1 def main():
2 for i in range(1, 21):
3 print(i, end='')
4 if not i % 3:
5 print(' (multiple de 3)', end='')
6 print()
7

8 if __name__ == '__main__':
9 main()

La première ligne d’un bloc est son entête et se termine par un “:”. On en retrouve déjà trois
exemples ci-dessus, sur lesquels on reviendra plus tard:
1 def main():
2 ...

1 for i in range(1, 21):

2 ...

1 if not i % 3:
2 ...

Les blocs se présentent donc comme suit:

1 entete du bloc:
2 instruction 1 du bloc
3 instruction 2 du bloc
4 ...
5 instruction hors bloc

Attention: Python interdit le mélange de tabulations et d’espaces pour l’indentation! Configurez

donc votre éditeur pour qu’il remplace toutes les tabulations par des espaces.

Programmation en Python 6
Chapitre 1. Introduction à Python

1.1.2 Types

Chaque variable en Python possède un type qui est pris en compte lors des opérations. Ce type
est déclaré explicitement ou implicitement dans la partie droite de l’expression déclarant la
variable: autrement dit, Python déduit lui-même le type de l’expression.
1 # ceci est un commentaire
2 n = 23 # n est entier
3 x = 3.14 # x est reel
4 s = "bonjour" # s est une chaine de caracteres

Contrairement au C par exemple, on peut tout à fait changer le type d’une variable dans
l’exécution d’un programme (mais ce n’est pas conseillé, sauf pour le passage d’un type de
nombres à un autre):
1 x = 3 + 5 # x est entier
2 x = x / 2 # x devient reel
3 x = [4, -1] # permis mais deconseille: x devient une liste

1.1.3 Objets (non) modifiables

Python met deux catégories d’objets à notre disposition: des objets modifiables et des objets
non modifiables. On verra plus loin que cette distinction a son importance, notamment lors des
copies de variables et des appels de fonctions.

1.1.4 Garbage collector

Comme en Java, il existe un garbage collector, qui se charge de détruire les variables inutil(isé)es.
L’utilisateur n’a donc pas à se préoccuper de supprimer des variables. En cas de besoin, on peut
aussi décider de les détruire soi-même avec l’instruction , mais c’est rarement nécessaire.

1.1.5 Messages d’erreurs

Les messages d’erreurs en Python sont généralement très explicites, et nous indiquent précisé-
ment à quelle ligne il y a un problème. Voici quelques exemples pour se faire une idée):
1 >>> x = 37 / 0
2 Traceback (most recent call last):
3 File "<stdin>", line 1, in <module>
4 ZeroDivisionError: division by zero
5 >>> y = "bonjour" - 5
6 Traceback (most recent call last):
7 File "<stdin>", line 1, in <module>
8 TypeError: unsupported operand type(s) for -: 'str' and 'int
'
9 >>> import module_inexistant

Programmation en Python 7
 Chapitre 1. Introduction à Python

10 Traceback (most recent call last):

11 File "<stdin>", line 1, in <module>
12 ImportError: No module named 'module_inexistant'

1.2 Installation de Python

On utilisera dans ce cours la version 3 de Python. Les instructions spécifiques à suivre dépendent
de votre système d’exploitation (s’il n’est pas repris dans la liste ci-dessous, allez sur http:
//[Link] et suivez les instructions correspondantes):
— Sous Ubuntu / Debian: ouvrez un terminal et tapez:
1 $ sudo apt-get install python3

— Sous Windows: téléchargez le programme d’installation sur [Link] et

suivez le programme d’installation mais ajoutez python à la variable PATH!

F IGURE 1.1 – Option à activer lors de l’installation de Python sous Windows.

Sans cela, vous ne pourrez pas taper python dans le terminal;

Programmation en Python 8
Chapitre 1. Introduction à Python

1.3 Utilisation de Python

Il y a deux manières d’utiliser Python: soit en lançant l’interpréteur, soit en lançant un programme
qu’on a écrit. Dans le mode interpréteur, il nous suffit d’ouvrir un terminal et de taper python3
(ou python selon votre installation 1 ) pour qu’un interpréteur s’ouvre comme ci-dessous:
1 $ python3
2 Python 3.5.3 (default, Jan 19 2017, 14:11:04)
3 [GCC 6.3.0 20170118] on linux
4 Type "help", "copyright", "credits" or "license" for
more information.
5 >>>

Les trois chevrons (>>>) indiquent que l’interpréteur attend une commande; on peut alors
taper ce qu’on veut comme code Python, et voir immédiatement le résultat. Il s’agit d’un mode
interactif, et les exemples du cours qui utiliseront cette notation indiqueront que le code est
exécuté dans l’interpréteur. Pour sortir de l’interpréteur, on appuie sur Ctrl+D, ou on tape
exit().
Parfois, les exemples de code montrés dans l’interpréteur comporteront des points de suspension
(. . .) en début de ligne:
1 >>> if 1 < 2 and 5 / 2 == 2.5:
2 ... print("Python sait compter et calculer")
3 ...
4 Python sait compter et calculer

Ceci indique simplement que Python a compris que les lignes qui suivent l’entête d’un bloc font
partie de ce bloc; il ne s’agit pas de quelque chose que vous devez vous-même écrire, et on ne le
fera pas hors de l’interpréteur.
L’interpréteur est particulièrement utile quand on veut tester rapidement du code, car il n’est
pas nécessaire d’écrire un programme entier puis de le lancer pour obtenir un résultat. Si en
revanche, on a écrit un programme nommé [Link] que l’on désire exécuter, il
nous suffit de taper dans le terminal:
1 $ python3 [Link]

Le programme s’exécutera alors, et on récupérera le terminal quand il se terminera.

1.4 Environnements de développement recommandés

PyCharm est l’un des environnements les plus complets, multi-plateformes et disposant d’une
version gratuite. Il est disponible ici: [Link]
D’autres éditeurs ou environnements existent, dont une sélection non exhaustive est donnée
ci-dessous:
1. Dans le reste du document, on suppose que ce sera bien python3 .

Programmation en Python 9
 Chapitre 1. Introduction à Python

— Geany: [Link]
— PyCharm:
— Notepad+: [Link]
— Kate: [Link]
— SublimeText: [Link]
— ...
Quel que soit votre choix, il est important que l’éditeur de texte que vous utilisez propose la
coloration syntaxique. En outre, il est essentiel de le configurer, si ce n’est déjà fait, pour qu’il
remplace les espaces par des tabulations, sans quoi vous risquez de voir le message suivant
quand vous exécutez un programme où vous mélangez les deux:
1 $ python3 [Link]
2 File "[Link]", line 3
3 print("voila")
4 ^
5 TabError: inconsistent use of tabs and spaces in indentation

1.5 Conventions de style

Python accorde une liberté relative pour nommer les variables, les fonctions et les modules,
mais il est recommandé de suivre quelques règles. Tant qu’à se plier à des conventions, utilisons
celles qui sont officiellement recommandées par PEP8, qu’on se contentera de résumer ici sans
les justifier 2 :
— l’indentation se fait à l’aide d’espaces, et non de tabulations: chaque niveau d’indentation
correspond à 4 espaces;
— l’encodage du fichier doit être UTF-8 (Unicode);
— les variables locales et les noms de fonctions doivent être en minuscules et disponibles
en ASCII; si plusieurs mots sont nécessaires, on les sépare par des underscores.
Pour vérifier si votre programme satisfait à ces exigences, tapez
1 $ pep8 [Link]

dans un terminal. Si rien ne s’affiche, c’est que vous avez suivi toutes les recommandations
correctement; sinon, les problèmes seront signalés.

1.6 Configuration des éditeurs

1.6.1 Geany.

— Edit→Preferences (ou Ctrl+Alt+P)→Editor→Indentation: mettez “Width” à 4 et cochez

“Spaces”;
2. Voir [Link] pour plus de détails.

Programmation en Python 10
Chapitre 1. Introduction à Python

— en ayant ouvert un fichier .py: Build→Set Build Commands: remplacez toutes les
occurences de python par python3;

1.6.2 PyCharm.

Aucune configuration n’est nécessaire.

Programmation en Python 11
 Chapitre 1. Introduction à Python

Programmation en Python 12
Chapitre 2. Les bases du langage

Chapitre 2

Les bases du langage

Sommaire
2.1 Variables et types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.2 Transtypage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.3 Variables et affectations . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.1 Opérations sur les nombres . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.2 Opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.3 Opérations sur les chaînes . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.4 Formes condensées . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 Branchements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.1 Version basique du if . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.2 Alternative au if: le else . . . . . . . . . . . . . . . . . . . . . . 17
2.3.3 Autres options: le mot clé elif . . . . . . . . . . . . . . . . . . . . . 18

2.1 Variables et types

2.1.1 Types de base

Les valeurs et les variables qu’on manipule en Python possèdent un type, qui détermine les
opérations autorisées ainsi que leur comportement. Parmi les types les plus fréquents, on retrouve
les suivants:

Type En Python Exemples

entier int 12, -4, 123545, . . .
réel float 3.14159, -1.5, 12., 4.56e12, . . .
booléen bool True (vrai) ou False (faux)
indéfini, rien None None
chaîne de caractères str 'bonjour', 'SHNU', . . .

Programmation en Python 13
 Chapitre 2. Les bases du langage

Le type None est particulier (il correspond au null du C/C++) et permet de représenter des
variables n’ayant aucun type. On verra plus loin des situations dans lesquelles son utilisation est
essentielle.

2.1.2 Transtypage

La fonction type()permet de connaître le type de son paramètre:

1 >>> type(3.14)
2 <class 'float'>
3 >>> type(True)
4 <class 'bool'>
5 >>> type("bonjour")
6 <class 'str'>

Il arrive souvent qu’on ait une variable qui ne soit pas du “bon” type. Le transtypage consiste à
convertir une variable d’un type vers un autre. Par exemple, la fonction input()nous permet
de récupérer des données entrées par l’utilisateur sous la forme d’une chaîne de caractères. Si
l’on veut obtenir un nombre, on doit transtyper cette entrée:
1 >>> n = input("Entrez un nombre: ")
2 35
3 >>> print("Voici ce nombre multiplie par 2:", int(n) * 2)
4 70

Toutes les conversions ne sont pas permises, mais elles sont accessibles grâce à des fonctions de
conversions portant le nom du type cible. En pratique, on utilise surtout:
— str qui fonctionne tout le temps;
— int et float appliqués à une chaîne de caractères qui correspond à un nombre;
— Attention: int('3') fonctionne, mais pas int('3.5')!
— int appliqué à un float pour tronquer les décimales;
— bool qui donne False si son paramètre équivaut à 0, True sinon.
Voici quelques exemples d’utilisation du transtypage avec les résultats correspondants:

int(4.5)→ 4 int(-4.5)→ -4 int('0345')→ 345

int('SHNU')→ erreur float(4)→ 4. float('4.5')→ 4.5
str(4)→ '4' str(True)→ 'True' str(-4.5)→ '-4.5'
bool(4)→ True bool(0)→ False bool('SHNU') → True

2.1.3 Variables et affectations

Une variable est un nom qui référence une valeur en mémoire. Elle a le même type que la valeur
qu’elle référence. L’affectation d’une variable consiste à lier un nom à une valeur:
1 x = 3
2 y = 'SHNU'

Programmation en Python 14
Chapitre 2. Les bases du langage

3 z = x + 2

On peut affecter à nouveau une même variable, et on perd alors le lien avec l’ancienne valeur.
Il y a certaines règles de nommage à respecter pour les variables:
— le caractère ‘underscore” _ est considéré comme une lettre;
— on n’utilise jamais d’accent, de cédille, . . . ou d’espace;
— les noms commencent par une lettre majuscule ou minuscule, puis sont composés de
lettres et de nombres:
— les mots réservés de Python (voir suite) ainsi que les noms de fonctions prédéfinies sont
interdits.
Les mots suivants sont réservés pour le langage, et on ne peut donc pas les utiliser pour nom-
mer nos variables: False, None , True, and, as, assert, break, class, continue,
def, del, elif, else, except, finally, for, from, global, if, import, in, is,
lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield. Plu-
tôt que de retenir cette liste par cœur, soyez attentifs à ce qu’affiche votre éditeur: si le nom de
variable que vous êtes en train d’écrire est en gras ou en couleur, c’est qu’il s’agit d’un mot
réservé.

2.2 Opérations

2.2.1 Opérations sur les nombres

Toutes les opérations usuelles que vous connaissez déjà sur les nombres sont disponibles. Le
type du résultat dépendra des types d’entrée: comme le montre le tableau ci-dessous, sauf dans
le cas d’une addition, c’est le type le plus général qui l’emporte.

+, −, ∗, ∗∗ int float
int int float
float float float

L’opération ** correspond à la puissance: x ** y calcule xy . La division (/) donne toujours

un float; si l’on veut tronquer la partie décimale pour obtenir un entier, on peut transtyper
avec int ou plus simplement utiliser // qui nous donne le quotient de la division entière.

1 >>> 3 / 2
2 1.5
3 >>> 3 // 2
4 1

Le reste de la division entière est x % y, qui se dit “x modulo y”. Les opérations suivent les
règles de priorités usuelles, et on peut utiliser des parenthèses, comme dans (4 + 2)* 1.5.

Programmation en Python 15
 Chapitre 2. Les bases du langage

2.2.2 Opérations logiques

Les opérations logiques portent sur les valeurs booléennes et sont disponibles via les mots-clés
suivants:
— and: le ET logique, x and y vaut True seulement quand x et y valent True,
— or: le OU logique, x or y vaut False seulement quand x et y valent False,
— not: la négation logique, not True donne False et not False donne True.
Voici pour rappel les tables de vérité correspondantes:

p q p and q p or q not p
False False False False True
False True False True True
True False False True False
True True True True False

On sera souvent confronté aux opérations sur les booléens, car les comparaisons produisent des
booléens comme résultats; étant données deux variables x et y, on peut demander:
— si leurs valeurs sont égales: x == y;
— si leurs valeurs sont différentes: x != y;
— quelle valeur est la plus grande, avec les opérateurs <, <=, >, >=.

2.2.3 Opérations sur les chaînes

Certains des opérateurs précédents marchent également sur les chaînes de caractères: + conca-
tène deux chaînes, et une chaîne multipliée par un entier n concatène cette chaîne avec elle-même
n − 1 fois. Les opérateurs de comparaison utilise l’ordre lexicographique, autrement dit celui
du dictionnaire.
1 >>> "bon" + "jour"
2 "bonjour"
3 >>> "shnu" * 3
4 "shnushnushnu"
5 >>> "bonjour" <= "au revoir"
6 False
7 >>> "chaine" != "CHAINE"
8 True

2.2.4 Formes condensées

Python permet également d’utiliser des expressions condensées pour les affectations. On peut
ainsi écrire:
— x += y au lieu de x = x + y;
— x *= y au lieu de x = x * y;

Programmation en Python 16
Chapitre 2. Les bases du langage

— x /= y au lieu de x = x / y;
— ...

2.3 Branchements conditionnels

2.3.1 Version basique du if

Comme dans bien d’autres langages, le mot-clé if permet de n’exécuter du code que sous
certaines conditions. Dans sa forme la plus simple, on déclare un bloc if comme suit:

1 # debut
2 if expression: non
début expression vraie? suite
3 # instruction 1 du if
4 # instruction 2 du if oui
5 # ...
6 # suite bloc if

Dans ce qui précède, expression est une expression qui renvoie un booléen, et qui est donc
évaluée à True ou False. Les instructions du bloc du if sont effectuées uniquement si
l’expression est évaluée à True; dans tous les cas, le programme reprend à l’instruction après
if.

1 >>> if 1 < 2 and 5 / 2 == 2.5:

2 ... print("Python sait compter et calculer")
3 ...
4 Python sait compter et calculer

Les conditions sont évaluées de gauche à droite, et Python n’évalue que celles qui sont néces-
saires. Par exemple:

— dans le test if 2 < 1 and ..., ce qui suit le and n’est jamais évalué car 2 < 1
est False et le résultat du and ne pourra donc jamais valoir True;
— dans le test if 2 > 1 or ..., ce qui suit le and n’est jamais évalué car 2 > 1 est
True et le résultat du or vaudra donc True, peu importe ce qui suit le or.

Il est également possible de spécifier ce qu’il faut faire quand la condition n’est pas satisfaite,
avec else, ou quand des conditions alternatives peuvent être satisfaites, avec elif.

2.3.2 Alternative au if: le else

La première variation avec un else se déclare comme suit:

Programmation en Python 17
 Chapitre 2. Les bases du langage

début
1 # debut
2 if expression:
3 # instruction 1 du if
expression vraie?
4 # ...
5 else: non
oui
6 # instruction 1 du
else bloc if bloc else
7 # ...
8 # suite
suite
Les instructions du bloc du if sont effectuées uniquement si l’expression est évaluée à True.
Les instructions du bloc du else sont effectuées uniquement si l’expression est évaluée à
False. Dans tous les cas, le programme continue à l’instruction après if/ else.

2.3.3 Autres options: le mot clé elif

La seconde variation avec un ou plusieurs elif se déclare comme suit:

début
1 # debut non
expression1 vraie? expression2 vraie?
2 if expression1:
3 # bloc du if
4 elif expression2: oui oui non
5 # bloc du elif
6 else:
bloc if bloc elif bloc else
7 # bloc du else
8 # suite

suite
Le fonctionnement est le suivant:
— les instructions du bloc du if sont effectuées uniquement si expression1 vaut
True;
— les instructions du bloc du elif sont effectuées uniquement si expression1 vaut
False et expression2 vaut True;
— les instructions du bloc du else sont effectuées uniquement si expression1 vaut
False et expression2 vaut False.
On peut utiliser plusieurs elif; les conditions sont évaluées dans l’ordre où elles apparaissent,
et seules les instructions du premier bloc dont la condition vaut True seront exécutées.
On n’est jamais obligé d’utiliser elif et else, mais si on décide de les utiliser:
— on doit suivre l’ordre if . . . elif . . . else (toujours en dernier);
— on ne peut pas utiliser elif ni else sans les associer à un if précédent.

Programmation en Python 18
Chapitre 3. Structures itérables et boucles for

Chapitre 3

Structures itérables et boucles for

Sommaire
3.1 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Un itérable particulier: range . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.2 Manipulation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3.3 Itérer sur des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.5 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.5.1 Modification de listes . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5.2 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5.3 Méthodes des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.6 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.7 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.7.1 Déclaration et manipulation . . . . . . . . . . . . . . . . . . . . . . 29
3.7.2 Itérer sur des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . 29
3.8 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Une structure itérable est une structure qui contient plusieurs valeurs avec:

— une valeur initiale;

— une notion de valeur suivante.

Cela ne veut pas nécessairement dire que la structure est ordonnée (cf. plus tard), mais simple-
ment que Python sait comment parcourir exactement une fois tous les éléments de la structure
donnée dans un certain ordre.

Les chaînes de caractères sont un exemple simple de structure itérable qu’on a déjà rencontré.
En effet:

— le premier élément de la structure est le premier caractère du texte (le plus à gauche);
— la valeur suivante (si elle existe) est le caractère à droite du caractère qu’on vient de lire.

Programmation en Python 19
 Chapitre 3. Structures itérables et boucles for

3.1 Boucles for

Python propose deux mécanismes de boucles: les boucles for et les boucles while, qui nous
permettent toutes deux de répéter des instructions un certain nombre de fois. On commencera
par couvrir les boucles for, car elles s’utilisent exclusivement avec des itérables et sont plus
intuitives: elles ressemblent en effet au ∀ des mathématiques.
La syntaxe du for est la suivante:
1 for element in iterable:
2 # instruction 1 du for
3 # instruction 2 du for
4 # ...
5 # suite du programme

Schématiquement, l’action du for peut se représenter comme suit:

non
iterable vide? element ← 1er element de iterable instructions du for

oui
element ← élément suivant ∃? élément suivant
oui
non
suite

Les boucles for n’ont d’intérêt que si on dispose d’itérables à parcourir. Jusqu’à présent, on
n’a rencontré que les chaînes de caractères comme structure itérable, qui nous permettent déjà
de montrer comment marchent les boucles for sur du texte:
1 >>> for lettre in "bonjour":
2 ... print(lettre)
3 ...
4 b
5 o
6 n
7 j
8 o
9 u
10 r

Remarquons que l’on n’a pas expliqué à Python par quelle valeur il fallait commencer ou
comment passer à la valeur suivante: c’est le type de l’itérable manipulé qui détermine automati-
quement ces informations.
La variable utilisée dans la boucle for est une copie de la valeur manipulée. Ainsi, une boucle
au format for element in iterable ne modifiera pas ce qui se trouve dans l’itérable,

Programmation en Python 20
Chapitre 3. Structures itérables et boucles for

puisqu’on manipule des copies de ses éléments. On verra plus tard comment modifier les
itérables modifiables manipulés.

3.2 Un itérable particulier: range

Les intervalles constituent un autre type de structure itérable intéressante que l’on rencontre très
souvent quand on utilise des for.
Les intervalles s’obtiennent à l’aide d’un appel à la fonction range(). Il existe trois manières
de l’utiliser:

1. range(n), avec n ∈ N, renvoie l’intervalle des entiers de 0 à n − 1;

2. range(a, b), avec a, b ∈ N, renvoie l’intervalle des entiers de a à b − 1;
3. range(a, b, c), avec avec a, b, c ∈ N, renvoie l’intervalle des entiers a, a + c,
a + 2c, . . ., jusque b − 1 ou jusqu’au dernier nombre de la forme a + kc inférieur ou égal
à b − 1.

Quelques exemples d’utilisation des boucles for avec des range:

1 >>> for i in range(5):
2 ... print(i)
3 ...
4 0
5 1
6 2
7 3
8 4
9 >>> for i in range(1, 10, 3):
10 ... print(i)
11 ...
12 1
13 4
14 7

La dernière forme est particulièrement utile quand on veut parcourir des nombres de manière
décroissante. En effet, range(a, b) donne un intervalle vide si a > b, puisqu’on ne peut pas
atteindre b en augmentant a de 1. Il faut donc expliquer à Python que l’on veut atteindre b en
ajoutant −1 aux éléments successivement obtenus.
1 >>> for i in range(5, 0, -1):
2 ... print(i)
3 ...
4 5
5 4
6 3
7 2
8 1

Programmation en Python 21
 Chapitre 3. Structures itérables et boucles for

3.3 Chaînes

3.3.1 Déclaration

Les chaînes de caractères se déclarent soit à l’aide d’apostrophes, soit à l’aide de guillemets.
1 >>> x = 'cette declaration marche'
2 >>> y = "et celle-ci aussi"

Si on déclare une chaîne qui contient des guillemets et des apostrophes, on doit utiliser les
caractères spéciaux '\'' et '\"':
1 >>> s = 'il a dit : "a l\'abordage !"'

On peut également déclarer des chaînes sur plusieurs lignes en utilisant des triples apostrophes
ou des triples guillemets:
1 s = '''Ceci est une
2 chaine sur
3 plusieurs lignes.'''

Les sauts de lignes seront encodés par le caractère \n. D’autres caractères spéciaux utiles sont
présentés ci-dessous:
— '\'': apostrophe
— '\"': guillemet
— '\n': saut de ligne
— '\t': tabulation
— '\\': backslash
— '\b': efface le caractère précédent

3.3.2 Manipulation de chaînes

Pour connaître la taille d’une chaîne, on utilise la fonction len(chaine), qui nous renvoie le
nombre de caractères qu’elle contient. Si l’on veut accéder aux éléments d’une chaîne, qui sont
des lettres, on peut le faire à l’aide de l’opérateur []. Attention, les indices d’une chaîne de
longueur n commencent à 0 (et non à 1) et se terminent en n − 1 (et non en n)! De plus, seuls
des indices entiers sont autorisés.
1 >>> texte = 'ma chaine'
2 >>> len(texte)
3 9
4 >>> texte[6]
5 'i'
6 >>> texte[9]
7 Traceback (most recent call last):
8 File "<stdin>", line 1, in <module>
9 IndexError: string index out of range
10 >>> texte[8.5]

Programmation en Python 22
Chapitre 3. Structures itérables et boucles for

11 Traceback (most recent call last):

12 File "<stdin>", line 1, in <module>
13 TypeError: string indices must be integers

Les chaînes ne sont pas modifiables. Si x contient une valeur de type str et que vous voulez la
changer, il faut faire une nouvelle affectation de x:
1 >>> x = 'toto'
2 >>> x[0] = 'p'
3 Traceback (most recent call last):
4 File "<stdin>", line 1, in <module>
5 TypeError: 'str' object does not support item assignment
6 >>> x = 'poto'

Une manière de contourner ce problème est d’utiliser une liste de caractères plutôt qu’une chaîne
(voir plus loin).
L’opérateur + permet de concaténer (ou de “coller”) deux chaînes. De même, multiplier une
chaîne par un entier n concatène cette chaîne avec elle-même n − 1 fois:
1 >>> 'bon' + 'jour'
2 'bonjour'
3 >>> 'shnu' * 3
4 'shnushnushnu'

Bien d’autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la
notation [Link](). Un appel à dir(str) dans l’interpréteur Python en donne la liste;
on verra les plus utiles d’entre elles dans les exercices.

3.3.3 Itérer sur des chaînes

Comme on connaît la longueur d’une chaîne s grâce à len(s), on peut en déduire les positions
valides à l’aide de range(len(s)) et donc itérer sur les positions de la chaîne comme suit:
1 >>> texte = "mon texte"
2 >>> for i in range(len(texte)):
3 ... print(texte[i])
4 ...
5 m
6 o
7 n
8 t
9 e
10 x
11 t
12 e

Programmation en Python 23
 Chapitre 3. Structures itérables et boucles for

Dans cet exemple, on se rend compte qu’il n’est jamais nécessaire de connaître la position des
éléments qu’on affiche. On pourrait donc réécrire cette boucle de manière plus simple en itérant
directement sur les éléments plutôt que sur les positions:
1 >>> texte = "mon texte"
2 >>> for lettre in texte:
3 ... print(texte)
4 ...
5 m
6 o
7 n
8 t
9 e
10 x
11 t
12 e

3.4 Tuples
Les tuples sont des itérables non-modifiables donnant plus de liberté que les chaînes. En effet, les
chaînes de caractères ne peuvent contenir que du texte: les tuples nous permettent de mélanger
différents types. On les déclare à l’aide de parenthèses:
1 >>> x = (4, 3, 1) # cree un tuple avec 3 entiers
2 >>> x = 4, 3, 1 # meme resultat
3 >>> y = (4,) # tuple avec un seul element
4 >>> z = ('trois', -5, True)

Pour créer un tuple avec un seul élément, il faut utiliser une virgule, sinon on obtient un entier.
Ce qu’on a vu pour les chaînes reste valable pour les tuples: les opérateurs [], in et + ainsi
que la fonction len() s’utilisent exactement de la même manière. Tout comme les chaînes, les
tuples ne sont pas modifiables, et toute tentative d’affectation provoquera donc une erreur.
1 >>> mon_tuple = (4, 3, 1) # cree un tuple avec 3 entiers
2 >>> mon_tuple[0] = 4
3 Traceback (most recent call last):
4 File "<stdin>", line 1, in <module>
5 TypeError: 'tuple' object does not support item assignment

3.5 Listes
Les listes sont des tuples modifiables. On les initialise à l’aide de crochets plutôt que de
parenthèses:
1 >>> liste_1 = list() # liste vide
2 >>> liste_2 = [] # autre liste vide

Programmation en Python 24
Chapitre 3. Structures itérables et boucles for

3 >>> liste_3 = [1, 2.0, '3']

4 >>> liste_4 = list(range(1, 11)) # les entiers de 1 a 10

Ce qu’on a vu pour les chaînes et les tuples reste valable pour les listes: les opérateurs [], in et
+ ainsi que la fonction len() s’utilisent exactement de la même manière.

3.5.1 Modification de listes

On peut à présent utiliser les crochets pour modifier les listes:

1 >>> liste_3 = [1, 2.0, '3']
2 >>> for i in range(len(liste_3)):
3 ... print("position", i, ": element =", liste_3[i])
4 ...
5 position 0 : element = 1
6 position 1 : element = 2.0
7 position 2 : element = 3
8 >>> liste_3[0] = -5
9 >>> liste_3
10 [-5, 2.0, '3']

On a déjà vu comment utiliser les boucles for pour parcourir des itérables, en utilisant soit les
positions, soit les éléments. Malheureusement, il n’est pas possible de modifier directement les
éléments d’une liste:
1 >>> liste = [1, 2, 3]
2 >>> for element in liste:
3 ... element = 1
4 ...
5 >>> liste
6 [1, 2, 3] # aucun changement

On est obligé de recourir aux positions de la liste pour modifier ses éléments:
1 >>> liste = [1, 2, 3]
2 >>> for i in range(len(liste)):
3 ... liste[i] = 1
4 ...
5 >>> liste
6 [1, 1, 1]

3.5.2 Copie de listes

Attention, le fait que les listes sont modifiables a un impact important sur leur manipulation. En
effet, les objets non-modifiables pouvaient être copiés et manipulés séparément sans impacts
mutuels:

Programmation en Python 25
 Chapitre 3. Structures itérables et boucles for

1 >>> x = 4
2 >>> y = x # copie la valeur de x dans y
3 >>> x = 2 # ne modifie pas y
4 >>> x, y
5 (2, 4)

Ceci n’est plus vrai pour les listes:

1 >>> lst1 = [1, 2]
2 >>> lst2 = lst1 # associe les deux noms au meme objet!
3 >>> lst2[0] = 4 # modifie lst2[0] ET lst1[0]
4 >>> lst1, lst2
5 ([4, 2], [4, 2])

Si l’on veut éviter ce comportement, on appellera la fonction list() pour réaliser la copie:
1 >>> lst1 = [1, 2]
2 >>> lst2 = list(lst1) # copie le contenu de lst1 dans lst2
3 >>> lst2[0] = 4 # modifie seulement lst2[0]
4 >>> lst1, lst2
5 ([4, 2], [4, 2])

On verra que ce “piège” existe pour tous les objets modifiables.

3.5.3 Méthodes des listes

La plupart des manipulations intéressantes sur les listes sont disponibles sous la forme de
méthodes. Les méthodes des listes qui vous serviront le plus sont:

1. les ajouts:
— [Link](x): ajoute la valeur de x à la fin de lst;
— [Link](lst2): ajoute tous les éléments de lst2 à la fin de lst;
— [Link](i, elem): ajoute elem juste avant la position i;
1 >>> liste = list(range(3)) # liste == [0, 1, 2]
2 >>> [Link]([3, 4]) # liste == [0, 1, 2, 3,
4]
3 >>> [Link](5) # liste == [0, 1, 2, 3,
4, 5]
4 >>> [Link](0, 2) # liste == [2, 0, 1, 2,
3, 4, 5]

2. les suppressions:
— [Link](): supprime le dernier élément de lst et renvoie sa valeur;
— [Link](i): supprime le i-ème élément de lst et renvoie sa valeur;
— [Link](x): supprime la première occurrence de x dans la liste si elle le
contient (sinon, provoque une erreur);

Programmation en Python 26
Chapitre 3. Structures itérables et boucles for

1 >>> # suite de l'exemple precedent

2 >>> [Link]()
3 5
4 >>> [Link](0)
5 2
6 >>> [Link](3) # liste == [0, 1, 2, 4]

3. diverses autres méthodes:

— [Link](x): donne le nombre d’occurrences de x dans la liste;
— [Link](x): donne la position de la première occurrence de x dans la liste si
elle contient cet élément (sinon, provoque une erreur);
— [Link](): trie la liste de manière croissante si tous ses éléments sont compa-
rables (sinon, provoque une erreur).

Les listes donnent l’impression qu’on peut oublier les chaînes et les tuples, car elles présentent
le double avantage d’être modifiables et de pouvoir mélanger les types. Cependant, on verra
bientôt des situations dans lesquelles on ne peut pas utiliser les listes.

3.6 Ensembles
La structure set (‘ensemble” en anglais) permet de gérer efficacement un ensemble de données.
Comme pour les listes et les tuples, on peut y mélanger les types. Par contre, comme on manipule
des ensembles:

1. chaque élément ne peut y être qu’une seule fois;

2. il n’y a pas d’ordre.

Le mécanisme utilisé pour que cette structure soit efficace impose aux éléments d’un set d’être
non modifiables. Mais les set eux-mêmes sont modifiables tout comme les listes.
Les set se déclarent comme les listes, mais avec des accolades:
1 >>> S = {3, 1, 4, 6, 2}

Ou à l’aide de la fonction set(iterable), aussi utile pour le transtypage:

1 >>> S = set([3, 1, 4, 6, 2])
2 >>> ensemble_vide = set() # ou {}

Les manipulations ensemblistes habituelles en mathématique sur deux ensembles sont dispo-
nibles via les opérations suivantes:

Opération Opérateur Méthode 1 Méthode 2

s∪t s | t [Link](t) [Link](t)
s∩t s & t [Link](t) s.intersection_update(t)
s\t s - t [Link](t) s.difference_update(t)
s∆t s ^ t s.symmetric_difference(t) s.symmetric_difference_update(t)

Programmation en Python 27
 Chapitre 3. Structures itérables et boucles for

Les méthodes de la colonne “Méthode 1” ainsi que les opérateurs présentés ne modifient pas
les ensembles manipulés. Si l’on veut les modifier, on utilisera les méthodes de la colonne
“Méthode 2” (par exemple: [Link](t)donne le même résultat que s = [Link](t)).
Ces méthodes ne marchent que si l’on manipule deux ensembles. Si l’on veut manipuler un
ensemble set un seul élément x:
— [Link](x) ajoute x à s;
— [Link](x) retire x de s si s le contient — sinon, elle provoque une erreur;
— [Link](x) retire x de s sans erreur si s ne le contient pas.
— enfin, [Link]() (sans paramètre) retire et renvoie un élément aléatoire de s s’il n’est
pas vide — sinon, elle provoque une erreur.
Les opérations in et len() fonctionnent encore sur les ensembles; par contre, l’opérateur + ne
marche plus, ni l’opérateur [] puisque l’absence d’ordre implique l’absence de positions.
Enfin, les comparaisons ensemblistes sont disponibles via les opérateurs suivants:

Opération Opérateur
s=t s == t
s 6= t s != t
s⊂t s < t
s⊆t s <= t

Il existe également une structure permettant de représenter des ensembles non-modifiables: il

s’agit de frozenset, qui est surtout utile quand on veut représenter des collections d’en-
sembles. En effet, ceci échoue car les ensembles sont modifiables:
1 # sous-ensembles de {1, 2, 3} de taille 2
2 >>> S = set([set([1, 2]), set([1, 3]), set([2, 3])])

On doit donc écrire:

1 # sous-ensembles de {1, 2, 3} de taille 2
2 >>> S = set([frozenset([1, 2]), frozenset([1, 3]),
3 frozenset([2, 3])])

Les commentaires faits sur l’affectation des listes s’appliquent également aux ensembles, puis-
qu’il s’agit d’objets modifiables: il faut donc être prudent lors des affectations.

3.7 Dictionnaires

Les dictionnaires permettent d’associer une valeur à une clé. On peut les voir d’une cer-
taine manière comme des listes dont les indices peuvent être des entiers ou n’importe quoi
d’autre, pourvu qu’il s’agisse d’un type non-modifiable. Les valeurs, par contre, peuvent être
modifiables.

Programmation en Python 28
Chapitre 3. Structures itérables et boucles for

3.7.1 Déclaration et manipulation

On peut déclarer les dictionnaires comme suit:

1 >>> mon_dico = dict() # dictionnaire vide
2 >>> notes_etudiants = {"Jean": 15, "Marie": 16}

On peut modifier les valeurs des clés existantes, et rajouter une association entre une nouvelle
clé et une nouvelle valeur simplement en les affectant comme si la clé existait déjà:
1 >>> notes_etudiants["Jean"] = 0 # Jean a triche
2 >>> notes_etudiants["Pierre"] = 14 # on vient de corriger
une autre copie
3 >>> notes_etudiants["Marc"] += 1 # echoue: Marc n'existe
pas dans le carnet
4 Traceback (most recent call last):
5 File "<stdin>", line 1, in <module>
6 KeyError: 'Marc'

Les clés, les valeurs et les associations sont disponibles à l’aide des trois méthodes suivantes:
1 >>> notes_etudiants.keys() # ou print(notes_etudiants)
2 dict_keys(['Jean', 'Pierre', 'Marie'])
3 >>> notes_etudiants.values()
4 dict_values([0, 14, 16])
5 >>> notes_etudiants.items()
6 dict_items([('Jean', 0), ('Pierre', 14), ('Marie', 16)])

Les itérables renvoyés sont d’un type un peu particulier; si l’on veut les convertir vers des types
connus, on peut toujours recourir au transtypage.
Les seuls opérateurs qui fonctionnent sur les dictionnaires sont ==, != et in. Attention, x in
dictionnaire vérifie si x appartient aux clés! Si l’on veut savoir si x appartient aux valeurs
du dictionnaire, on utilisera la forme x in [Link]().
Python 3 nous autorise à créer des dictionnaires vides avec {}. Cette notation est déconseillée
car elle est source de confusion: en effet, 1 est un ensemble contenant 1, tandis que {} n’est
pas un ensemble vide mais un dictionnaire vide. C’est pourquoi le test ensemble == {} ne
marchera pas pour vérifier si un ensemble donné est vide.
Les commentaires faits sur l’affectation des listes s’appliquent également aux dictionnaires et aux
ensembles, puisqu’il s’agit d’objets modifiables: il faut donc être prudent lors des affectations.

3.7.2 Itérer sur des dictionnaires

On peut itérer sur des dictionnaires de plusieurs manières:

1 >>> for nom in notes_etudiants.keys():
2 ... print(nom)
3 ...

Programmation en Python 29
 Chapitre 3. Structures itérables et boucles for

4 Jean
5 Pierre
6 Marie
7 >>> for nom in notes_etudiants.keys():
8 ... print(nom, ":", notes_etudiants[nom])
9 ...
10 Jean : 0
11 Pierre : 14
12 Marie : 16
13 >>> # la meme chose en plus lisible:
14 >>> for nom, note in notes_etudiants.items():
15 ... print(nom, ":", note)
16 ...
17 Jean : 0
18 Pierre : 14
19 Marie : 16

3.8 La boucle while

Il y a des situations où l’on a besoin d’une boucle, mais où:
— on ne dispose pas d’itérable à parcourir,
— ou on ne sait pas combien d’itérations on veut effectuer,
— ou encore, l’arrêt de la boucle dépend d’une condition plus complexe que ce qu’on a vu
avec les for.
Dans toutes ces situations, on utilisera une boucle while. La structure de cette boucle se
présente comme suit:
1 while condition:
non
2 # instruction 1 condition vraie? suite
3 # instruction 2
oui
4 # ...
5 # suite instructions

Le for s’arrête à la fin de l’itérable; dans le cas des boucles while, c’est à vous de vous
assurer que la boucle se termine! Si jamais vous exécutez à partir du terminal un programme qui
ne se termine pas, vous pouvez l’arrêter en appuyant sur Ctrl+C dans le terminal.

Programmation en Python 30
Chapitre 4. Les fonctions

Chapitre 4

Les fonctions

Sommaire
4.1 Fonctions sans paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.2 Fonction avec paramètre(s) . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3 Renvoi de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.4 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.5 Compléments sur les fonctions . . . . . . . . . . . . . . . . . . . . . . . . 34

Une fonction est un bloc d’instructions réutilisable. Leur usage est essentiel en programmation,
car notre but est d’avoir un programme clair, concis et lisible, ce qui nous permet de le maintenir
et de le modifier beaucoup plus facilement, et de réutiliser certaines de ses parties dans d’autres
programmes.

4.1 Fonctions sans paramètres

La syntaxe pour définir une fonction est la suivante:
1 def nom_fonction():
2 # instruction 1 de la fonction
3 # instruction 2 de la fonction
4 # ...
5 # instruction n de la fonction

Lors de la définition d’une fonction, le code n’est pas exécuté; il ne sera exécuté que lors
de l’appel de cette fonction, ce qu’on peut faire à tout moment dans le programme avec la
commande nom_fonction(). Le code suivant définit une fonction et illustre ce qui se passe
quand on l’appelle:
1 def appel():
2 print('-' * 5, 'appel', '-' * 5)
3

5 if __name__ == "__main__":
6 print('bonjour')

Programmation en Python 31
 Chapitre 4. Les fonctions

7 appel()
8 n = int(input('nombre = '))
9 for i in range(n):
10 appel()

Chaque fois qu’on utilise l’instruction appel(), le programme interrompt le flot normal
d’instructions pour aller effectuer les instructions d’appel(). Une fois les instructions de la
fonction appel() effectuées, le programme reprend là où il en était.

4.2 Fonction avec paramètre(s)

On a parfois envie que le comportement de la fonction change selon les appels. Pour cela, on
peut préciser à Python qu’elle doit posséder un ou plusieurs : il s’agit de noms de variables
auxquelles on devra affecter des valeurs lors de l’appel de la fonction.
1 def affiche(message):
2 print('*' * (len(message) + 4))
3 print('* ' + message + ' *')
4 print('*' * (len(message) + 4))
5

7 if __name__ == "__main__":
8 affiche('bonjour')
9 texte = input("Entrez un message:")
10 affiche(texte)

Ces paramètres sont nommés entre parenthèses dans la définition de la fonction. Lorsque
l’on appelle la fonction, il faut passer les paramètres (le bon nombre et dans l’ordre!) entre
parenthèses.

4.3 Renvoi de valeurs

On appelle souvent une fonction en vue de réaliser des calculs et d’obtenir un résultat. Ce résultat
doit être communiqué d’une manière ou d’une autre au code appelant la fonction: soit par une
modification des paramètres, soit par un de valeurs.
Ce renvoi de valeur s’implémente à l’aide de l’instruction . Elle interrompt l’exécution de la
fonction, et renvoie la valeur spécifiée en paramètre.
1 def calcul(a, b, c):
2 return a + b ** 2 + c ** 3
3 print(bonjour) # ne sera jamais execute!

Dans le code qui précède, l’affichage ne sera jamais exécuté car le nous fait sortir de la fonction
avant qu’on ne puisse l’atteindre. Ici, la valeur renvoyée est un nombre, mais l’on peut renvoyer

Programmation en Python 32
Chapitre 4. Les fonctions

un résultat de n’importe quel type, que l’on peut ensuite récupérer dans une variable ou utiliser
directement dans des calculs:
1 >>> y = calcul(1, 3.14, -5)
2 >>> print(y - 5)
3 -119.1404
4 >>> z = calcul(1, 2, 3) + calcul(4, 5, 6)

Qu’on le veuille ou non, en Python, toutes les fonctions renvoient une valeur; si l’on ne met pas
de return dans une fonction, Python insère un return None à notre place.

4.4 Portée des variables

Comme dans bien d’autres langages, les variables en Python n’existent pas toujours dans tout le
programme. La règle est la suivante:

1. une variable déclarée dans une fonction n’existe que dans cette fonction;
2. une variable déclarée dans un module n’existe que dans ce module.

Le schéma suivant permet d’y voir plus clair:

1 # des variables ici
2

3 def fonction_1(parametres_1):
4 # variables de la fonction 1
5

7 def fonction_2(parametres_2):
8 # variables de la fonction 2
9

10

11 if __name__ = '__main__':
12 # et des variables la

portée du programme

portée de la fonction 1

portée de la fonction 2

Programmation en Python 33
 Chapitre 4. Les fonctions

Le programme et ses fonctions définissent chacun des portées; une variable définie dans une
portée n’est accessible que dans celles que cette portée contient; ici:

1. les fonctions connaissent les variables du programme;

2. le programme n’a pas accès aux variables des fonctions;
3. fonction_1 ignore les variables de fonction_2 et vice versa.

Plus généralement, on fait une distinction entre les variables globales, qui existent dans tout
le programme manipulé et sont accessibles au moins en lecture, et les variables locales, qui
n’existent que dans la définition d’une fonction (ou d’une classe, ou d’une méthode) et ne sont
donc pas accessibles en dehors. Les paramètres de la définition d’une fonction, ainsi que les
variables déclarées dans sa définition, sont des variables locales propres à la fonction; elles
n’existeront donc que pendant l’exécution de la fonction, ne seront pas accessibles ailleurs, et
n’existent plus après cet appel.

4.5 Compléments sur les fonctions

Les paramètres modifiables et non-modifiables portent bien leurs noms: dans l’exemple ci-
dessous, l’appel à la fonction ne modifie pas son paramètre puisqu’il est non-modifiable:
1 def f(x):
2 x = x + 1
3

5 if __name__ == "__main__":
6 n = 3
7 f(n)
8 print(n)

Par contre, la fonction dans l’appel ci-dessous modifie la liste passée en paramètre, puisque les
listes sont modifiables:
1 def ajoute(L, x):
2 [Link](x) # on modifie L en ajoutant x
3

5 if __name__ == "__main__":
6 lst = [4, 5]
7 ajoute(lst, 7) # L prend la valeur lst
8 print(lst) # affiche [4,5,7]

Cela ne vaut que pour les paramètres modifiables; les variables affectées dans la fonction restent
locales. Ainsi, dans le code suivant, la liste est modifiée par le premier ; mais après l’affectation
de la ligne 3, on manipule un objet qui n’a plus de rapport avec le paramètre passé à la fonction:
1 def f(L, x):
2 [Link](x)
3 L = list(range(3))

Programmation en Python 34
Chapitre 4. Les fonctions

4 [Link](x)
5

7 if __name__ == "__main__":
8 lst = [4, 5]
9 f(lst, 7)
10 print(lst)

Il est utile dans ce cas de se référer à une visualisation sur PythonTutor pour mieux comprendre
ce qui se passe.

Programmation en Python 35