Cours de Programmation Python (2022 - 2023)

2022/2023
INITIATION PROGRAMMATION PYTHON

CLASSES DE LICENCE 1
UP INFORMATIQUE
ÉCOLE SUPÉRIEURE AFRICAINE DES TIC (ESATIC)
Abidjan, COTE D’IVOIRE
PROGRAMMATION PYTHON (Initiation)
Table des matières
I. Présentation brève du langage Python ............................................................................................. 4
1. C'est quoi Python ?......................................................................................................................... 4
2. Conseils pour installer et configurer Python ............................................................................... 4
3. Vérifier l’installation de Python .................................................................................................... 4
4. Introduction au shell ...................................................................................................................... 5
5. Les opérateurs................................................................................................................................. 5
II. Variables : déclaration et affectation, type, nommage, opération… ......................................... 6
1. Définition d’une variable ............................................................................................................... 6
2. Les types de variables..................................................................................................................... 6
3. Nommage......................................................................................................................................... 7
4. Opérations ....................................................................................................................................... 7
i. Opérations sur les types numériques ........................................................................................ 7
ii. Opérations sur les chaînes de caractères .................................................................................. 8
iii. Opérations illicites .................................................................................................................. 8
iv. La fonction type() .................................................................................................................... 9
v. Conversion de types.................................................................................................................... 9
vi. Note sur la division de deux nombres entiers....................................................................... 9
vii. Note sur le vocabulaire et la syntaxe..................................................................................... 9
viii. Minimum et maximum......................................................................................................... 10
III. Les instructions ............................................................................................................................. 11
1. Instructions simples : ................................................................................................................... 11
2. Instructions complexes :............................................................................................................... 11
3. Affichage........................................................................................................................................ 11
i. La fonction print() ..................................................................................................................... 11
ii. Écriture formatée ..................................................................................................................... 12
IV. Les listes......................................................................................................................................... 14
1. Définition ....................................................................................................................................... 14
2. Utilisation ...................................................................................................................................... 14
3. Opération sur les listes ................................................................................................................. 14
4. Indiçage négatif............................................................................................................................. 15
5. Tranches ........................................................................................................................................ 16
1
6. Fonction len() ................................................................................................................................ 16
7. Les fonctions range() et list()........................................................................................................ 17
8. Listes de listes................................................................................................................................ 17
9. Minimum, maximum et somme d'une liste¶ .............................................................................. 18
V. Tuples et Dictionnaires .................................................................................................................... 19
1. Tuples ............................................................................................................................................ 19
i. Définition ................................................................................................................................... 19
ii. Affectation multiple et le nom de variable _ .......................................................................... 20
2. Dictionnaires ................................................................................................................................. 20
i. Définition ................................................................................................................................... 20
ii. Itération sur les clés pour obtenir les valeurs ........................................................................ 21
iii. Méthodes .keys() et .values() ................................................................................................ 21
iv. Existence d'une clé ou d'une valeur .................................................................................... 21
v. Méthode .get() ........................................................................................................................... 22
VI. Tests ............................................................................................................................................... 23
1. Définition ....................................................................................................................................... 23
2. Tests à plusieurs cas ..................................................................................................................... 23
3. Importance de l'indentation ........................................................................................................ 24
4. Tests multiples .............................................................................................................................. 25
5. Instructions break et continue...................................................................................................... 26
VII. Boucles et comparaisons .............................................................................................................. 27
1. Boucles for ..................................................................................................................................... 27
i. Principe...................................................................................................................................... 27
ii. Fonction range() ........................................................................................................................ 28
iii. Itération sur les indices ou les éléments .............................................................................. 28
2. Boucles while ................................................................................................................................. 29
VIII. Les fichiers ................................................................................................................................ 31
1. Lecture dans un fichier ................................................................................................................ 31
i. Méthode .readlines() ................................................................................................................. 31
ii. Méthode .read() ......................................................................................................................... 33
iii. Méthode .readline() ............................................................................................................... 33
iv. Itération directe sur le fichier .............................................................................................. 33
v. Écriture dans un fichier ........................................................................................................... 33
vi. Ouvrir deux fichiers avec l'instruction with ...................................................................... 34
2
IX. Les modules ................................................................................................................................... 36
1. Définition ....................................................................................................................................... 36
2. Importation de modules ............................................................................................................... 36
3. Quelques modules courants ......................................................................................................... 37
X. Les fonctions ..................................................................................................................................... 38
1. Principes et généralités................................................................................................................. 38
2. Définition ....................................................................................................................................... 38
3. Passage d'arguments .................................................................................................................... 39
4. Renvoi de résultats ....................................................................................................................... 40
5. Arguments positionnels et arguments par nom ......................................................................... 40
6. Variables locales et variables globales ........................................................................................ 42
3
I. Présentation brève du langage Python
1. C'est quoi Python ?
Le langage de programmation Python a été créé en 1989 par Guido van Rossum, aux Pays-Bas.
Le nom Python vient d'un hommage à la série télévisée Monty Python's Flying Circus dont G. van
Rossum est fan. La première version publique de ce langage a été publiée en 1991.
La dernière version de Python est la version 3.x. Plus précisément, la version 3.10.1 a été publiée
en décembre 2021. La version 2 de Python est obsolète et cesse d'être maintenue depuis le 1er
janvier 2020.
La Python Software Foundation est l'association qui organise le développement de Python et
anime la communauté de développeurs et d'utilisateurs.
Ce langage de programmation présente de nombreuses caractéristiques intéressantes :
• Il est multiplateforme. C'est-à-dire qu'il fonctionne sur de nombreux systèmes
d'exploitation : Windows, Mac OS X, Linux, Android, iOS, depuis les mini-ordinateurs
Raspberry Pi jusqu'aux supercalculateurs.
• Il est gratuit. Vous pouvez l'installer sur autant d'ordinateurs que vous voulez (même sur
votre téléphone !).
• C'est un langage de haut niveau. Il demande relativement peu de connaissance sur le
fonctionnement d'un ordinateur pour être utilisé.
• C'est un langage interprété. Un script Python n'a pas besoin d'être compilé pour être
exécuté, contrairement à des langages comme le C ou le C++.
• Il est orienté objet. C'est-à-dire qu'il est possible de concevoir en Python des entités qui
miment celles du monde réel (une cellule, une protéine, un atome, etc.) avec un certain
nombre de règles de fonctionnement et d'interactions.
• Il est relativement simple à prendre en main.
• Enfin, il est très utilisé en bio-informatique et plus généralement en analyse de données.
Toutes ces caractéristiques font que Python est désormais enseigné dans de nombreuses
formations, depuis l'enseignement secondaire jusqu'à l'enseignement supérieur.
2. Conseils pour installer et configurer Python
Que votre machine soit sous Windows, Mac OS X ou Linux, vous pouvez y installer gratuitement
Python. Sous Mac et Linux, Python est déjà installé, ce qui n’est pas le cas pour Windows.
Visitez l'adresse https://docs.python.org ou autre, pour télécharger et installer correctement
Python sur votre ordinateur.
Pour écrire des codes en Python, vous pouvez utiliser son environnement de développement (IDLE
ou Shell), disponible après l’installation de Python. Mais vous pouvez aussi et surtout utiliser un
éditeur de codes tels que notepad++, Pycharm, Pyzo sous Windows ou d'autres éditeurs comme
Atom, Visual Studio Code, Sublime Text, emacs, vim, geany...
3. Vérifier l’installation de Python

Pour voir si Python est correctement installé et fonctionne parfaitement, ouvrez l’interpréteur des
commandes et commencez par tester un script dans l’écran d’IDLE qui ressemble à une invite de
commandes avec (>>>). Le triple chevron >>> est l'invite de commande (prompt en anglais) de
l'interpréteur Python. Ceci indique que Python attend une commande que vous devez saisir au
4
clavier. Tapez par exemple l'instruction : print("Hello world!")puis validez cette commande
en appuyant sur la touche Entrée.
Python a exécuté la commande directement et a affiché le texte Hello world! Il attend ensuite
votre prochaine instruction en affichant l'invite de l'interpréteur Python (>>>). En résumé, voici
ce qui a dû apparaître sur votre écran :
>>> print("Hello world!")
Hello world!
Servons-nous de l'interpréteur comme d'une calculatrice :

>>> 1+1
2
>>> 6*3
18
4. Introduction au shell
Un shell est un interpréteur de commandes interactif permettant d'interagir avec l'ordinateur. On
utilisera le shell pour lancer l'interpréteur Python.
En fonction du système d'exploitation nous devons approfondir la notion de shell, en consultant
les pages Wikipedia :
• du shell Unix fonctionnant sous Mac OS X et Linux ;
• du shell PowerShell fonctionnant sous Windows.
Un shell possède toujours une invite de commande, c'est-à-dire un message qui s'affiche avant
l'endroit où on entre des commandes.
5. Les opérateurs
Afin de pouvoir effectuer des opérations sur des données, on utilise des opérateurs : +, -, *, /, //,
%, **, <, >, ==, <=, >=, !=, and, or, not (… etc)
NB : L'action d'un opérateur dépend du type des données utilisées.
Tableau 1: Quelques opérateurs destinés aux nombres entiers ou flottants
+ Addition de nombres
- Soustraction de nombres
* Multiplication
** Élévation à la puissance
/ Division décimale
// Quotient d'une division entière
% Reste d'une division entière
Tableau 2:Opérateurs destinés aux caractères
+ Concaténation de deux chaînes de caractères
* Répétition d'une chaîne de caractères (chaîne * entier)
5
II. Variables : déclaration et affectation, type, nommage, opération…
1. Définition d’une variable
Une variable est une zone de la mémoire de l'ordinateur dans laquelle une valeur est stockée. Aux
yeux du programmeur, cette variable est définie par un nom, alors que pour l'ordinateur, il s'agit
en fait d'une adresse, c'est-à-dire d'une zone particulière de la mémoire.
En Python, la déclaration d'une variable et son initialisation (c'est-à-dire la première valeur que
l'on va y stocker) se font en même temps. Pour comprendre tout cela, testez les instructions
suivantes après avoir lancé l'interpréteur :
>>> x = 2 #Ligne 1
>>> x #Ligne 2
2 #Ligne 3
Ligne 1 : Dans cet exemple, nous avons déclaré, puis initialisé la variable x avec la valeur 2. Notez
bien qu'en réalité, il s'est passé plusieurs choses :
• Python a « deviné » que la variable était un entier. On dit que Python est un langage au
typage dynamique.
• Python a alloué (réservé) l'espace en mémoire pour y accueillir un entier. Chaque type de
variable prend plus ou moins d'espace en mémoire. Python a aussi fait en sorte qu'on puisse
retrouver la variable sous le nom x.
• Enfin, Python a assigné la valeur 2 à la variable x.
Lignes 2 et 3 : L'interpréteur nous a permis de connaître le contenu de la variable juste en tapant

son nom. Retenez ceci car c'est une spécificité de l'interpréteur Python, très pratique pour
chasser (debugger) les erreurs dans un programme.
De la même façon, le symbole <- (en algorithmique) est utilisé pour rendre l'affectation d'une
variable plus explicite, par exemple x <- 2, l'opérateur d'affectation = (en Python) s'utilise dans
un certain sens. Par exemple, l'instruction x = 2 signifie qu'on attribue la valeur située à droite de
l'opérateur = (ici, 2) à la variable située à gauche (ici, x).
Enfin, dans l'instruction x = y - 3, l'opération y - 3 est d'abord évaluée et ensuite le résultat

de cette opération est affecté à la variable x.
2. Les types de variables

Le type d'une variable correspond à la nature de celle-ci. Les trois principaux types dont nous
aurons besoin dans un premier temps sont les entiers (integer ou int), les nombres décimaux que
nous appellerons floats et les chaînes de caractères (string ou str). Bien sûr, il existe de nombreux
autres types (tels que, les booléens, les nombres complexes, etc.).
>>> y = 3.14
>>> a = "bonjour"
>>> b = 'salut'
>>> c = """girafe"""
>>> d = '''lion'''
>>> y
3.14
>>> a
'bonjour'
>>> b
6
'salut'
>>> c
'girafe'
>>> d
'lion'
3. Nommage
Le nom des variables en Python peut être constitué de lettres minuscules (a à z), de lettres
majuscules (A à Z), de nombres (0 à 9) ou du caractère souligné (_). Vous ne pouvez pas utiliser
d'espace dans un nom de variable.
Par ailleurs, un nom de variable ne doit pas débuter par un chiffre et il n'est pas recommandé de le
faire débuter par le caractère _ (sauf cas très particuliers). De plus, il faut absolument éviter
d'utiliser un mot « réservé » par Python comme nom de variable.
Tableau 3: Mots réservés en Python
Print in and or if del for is raise assert
elif from lambda return break else global not try class
except while continue exec import pass yield def finally
Enfin, Python est sensible à la casse, ce qui signifie que les variables TesT, test ou TEST sont
différentes.
4. Opérations
i. Opérations sur les types numériques
Les quatre opérations arithmétiques de base se font de manière simple sur les types numériques
(nombres entiers et floats) :
>>> x = 45
>>> x + 2
47
>>> x - 2
43
>>> x * 3
135
>>> y = 2.5
>>> x - y
42.5
>>> (x * 10) + y
452.5
Remarque : si vous mélangez les types entiers et floats, le résultat est renvoyé comme un float (car
ce type est plus général). Par ailleurs, l'utilisation de parenthèses permet de gérer les priorités.
L'opérateur / effectue une division qui renvoie systématiquement un float, contrairement aux
opérateurs +, - et *.
>>> 3 / 4
0.75
>>> 2.5 / 2
1.25
L'opérateur puissance utilise les symboles ** :

>>> 2**3
8
>>> 2**4
7
16
Pour obtenir le quotient et le reste d'une division entière, on utilise respectivement les symboles
// et modulo % :
>>> 5 // 4
1
>>> 5 % 4
1
>>> 8 // 4
2
>>> 8 % 4
0
Les symboles +, -, *, /, **, // et % sont appelés opérateurs simples, car ils réalisent des opérations
sur les variables. Il existe cependant, des opérateurs « combinés » qui effectuent une opération
et une affectation en une seule étape :
>>> i = 1
>>> i += 1
>>> i
2
>>> i += 2
>>> i
4
L'opérateur += effectue une addition puis affecte le résultat à la même variable. Cette opération
s'appelle une « incrémentation ». Ainsi, les opérateurs -=, *= et /= se comportent de manière
similaire pour la soustraction, la multiplication et la division.
ii. Opérations sur les chaînes de caractères

Pour les chaînes de caractères, deux opérations sont possibles, l'addition et la multiplication :
>>> chaine = "Salut"
>>> chaine
'Salut'
>>> chaine + " Python"
'Salut Python'
>>> chaine * 3
'SalutSalutSalut'
L'opérateur d'addition + concatène (assemble) deux chaînes de caractères, tant disque l'opérateur
de multiplication * entre un nombre entier et une chaîne de caractères duplique (répète) plusieurs
fois une chaîne de caractères.
iii. Opérations illicites

Une opération illicite produit toujours un message d'erreur come dans les cas suivants :
>>> "toto" * 1.3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'float'
>>> "toto" + 2
TypeError: can only concatenate str (not "int") to str
NB : Python vous donne des informations dans son message d'erreur. Dans le second exemple, il
indique que vous devez utiliser une variable de type str c'est-à-dire une chaîne de caractères et pas
un int, c'est-à-dire un entier.
8
iv. La fonction type()
La fonction type()ramène le type de la variable reçu en argument.
>>> x = 2
>>> type(x)
<class 'int'>
>>> y = 2.0
>>> type(y)
<class 'float'>
>>> z = '2'
>>> type(z)
<class 'str'>
Pour Python, la valeur 2 (nombre entier) est différente de 2.0 (float) et est aussi différente de '2'
(chaîne de caractères).
v. Conversion de types
En programmation, on est souvent amené à convertir les types, c'est-à-dire passer d'un type
numérique à une chaîne de caractères ou vice-versa. En Python, rien de plus simple avec les
fonctions int(), float() et str(). Exemples :
>>> i = 3
>>> str(i)
'3'
>>> i = '456'
>>> int(i)
456
>>> float(i)
456.0
>>> i = '3.1416'
>>> float(i)
3.1416
Toute conversion d'une variable d'un type en un autre est appelé casting en anglais, il se peut que
vous croisiez ce terme si vous consultez d'autres ressources.
vi. Note sur la division de deux nombres entiers

Notez bien qu'en Python 3, la division de deux nombres entiers renvoie par défaut un float :
>>> x = 3 / 4
>>> x
0.75
>>> type(x)
<class 'float'>
vii. Note sur le vocabulaire et la syntaxe

La notion de variable est commune à tous les langages de programmation. Toutefois, pour un
langage de programmation dit "orienté objet" tel que Python, il se peut que le mot objet soit
employé pour désigner une variable.
La notion de fonction a été plusieurs fois utilisée, notamment avec print(),type(), int(),
float() et str(). On reconnaît qu'il s'agit d'une fonction car son nom est suivi de parenthèses.
Une fonction est une sorte de boîte à qui on passe un (ou plusieurs) argument(s), qui effectue une
action et qui peut renvoyer un résultat ou plus généralement un objet. En Python, la syntaxe
générale est fonction().
9
viii. Minimum et maximum
Python propose les fonctions min() et max() qui renvoient respectivement le minimum et le
maximum de plusieurs entiers et / ou floats :
>>> min(1, -2, 4)
-2
>>> pi = 3.14
>>> e = 2.71
>>> max(e, pi)
3.14
>>> max(1, 2.4, -6)
2.4
Les fonctions min() et max() sont des exemples de fonction prenant plusieurs arguments. En
Python, quand une fonction prend plusieurs arguments, on doit les séparer par une virgule.
10
III. Les instructions
On distingue les instructions simples et les instructions complexes (composées).
1. Instructions simples :
L’invite de commande >>> signifie que Python est prêt à exécuter une commande.
En python, une instruction simple est formée d’une seule ligne :
>>> 2+3
>>> 35 / 5
>>> 10 * 3
>>> "Bonjour" * 4
>>> pi=3.1415
>>> R=3
>>> # Ceci est un commentaire en python
Les instructions de base

ECRIRE ("Hello Word") print() >>> print("Hello World !")
ECRIRE ("L'aire d'un disque de >>> print("L'aire d'un disque de
rayon",R,"cm est égale à", pi*R**2,"cm²") rayon",R,"cm est égale à",
pi*R**2,"cm²")
ECRIRE (“Bonjour“, prenom)
>>> print(“Bonjour“, prenom)
ECRIRE("Quel est votre prénom SVP ?") input() >>> prenom=input("Quel est votre
LIRE(prenom) prénoms ?\n")
AFFECTATION (y  10) = Y = 10
2. Instructions complexes :
En python, la structuration des blocs d’instructions se fait grâce à l’indentation (décalage visuel
avec des espaces) : les lignes consécutives qui ont la même indentation appartiennent au même
bloc ; une ligne ayant une indentation moindre (ou fin du programme) termine le bloc
d’instructions constitué par les lignes qui la précèdent.
Une instruction composée est formée d’une instruction d’introduction terminée par le caractère
deux-points (:), suivi par un bloc d’instructions simples (ou elles-mêmes structurées) indentées par
rapport à cette instruction d’introduction.
Instruction d’introduction :
Instruction 1
…
Instruction n
Autre instruction
Les principales instructions composées sont l’instruction conditionnelle if (SI en algorithmique),

l’instruction for (POUR en algorithmique), et l’instruction de boucle conditionnelle while
(TANTQUE en algorithmique).
3. Affichage
i. La fonction print()
La fonction print() affiche l’argument qu’on lui passe entre les parenthèses et effectue un retour à
la ligne par défaut. Si toutefois, on ne veut pas afficher ce retour à la ligne, on peut utiliser
l'argument par "mot-clé" end :
11
>>> print("Hello world!")
Hello world!
>>> print("Hello world!", end="")
Hello world!>>>
Dans la portion de code suivante, le caractère « ; » sert à séparer plusieurs instructions Python sur
une même ligne :
>>> print("Hello") ; print("Joe")
Hello
Joe
>>> print("Hello", end="") ; print("Joe")
HelloJoe
>>> print("Hello", end=" ") ; print("Joe")
Hello Joe
La fonction print() peut également afficher le contenu d'une variable quel que soit son type.
>>> var = 3
>>> print(var)
3
Il est également possible d'afficher le contenu de plusieurs variables (quel que soit leur type) en
les séparant par des virgules :
>>> x = 32
>>> nom = "Jules"
>>> print(nom, "a", x, "ans")
Jules a 32 ans
Python a écrit une phrase complète en remplaçant les variables x et nom par leur contenu. Vous
remarquerez que pour afficher plusieurs éléments de texte sur une seule ligne, nous avons utilisé
le séparateur « , » entre les différents éléments. Python a également ajouté un espace à chaque
fois que l'on utilisait le séparateur « , ». On peut modifier ce comportement en passant à la fonction
print() l'argument par mot-clé sep :
>>> x = 32
>>> nom = "John"
>>> print(nom, "a", x, "ans", sep="")
Johna32ans
>>> print(nom, "a", x, "ans", sep="-")
John-a-32-ans
Pour afficher deux chaînes de caractères l'une à côté de l'autre, sans espace, on peut soit les
concaténer, soit utiliser l'argument par mot-clé sep avec une chaîne de caractères vide :
>>> ani1 = "chat"
>>> ani2 = "souris"
>>> print(ani1, ani2)
chat souris
>>> print(ani1 + ani2)
chatsouris
>>> print(ani1, ani2, sep="")
chatsouris
ii. Écriture formatée

L'écriture formatée est un mécanisme permettant d'afficher des variables avec un certain format,
par exemple justifiées à gauche ou à droite, ou encore avec un certain nombre de décimales pour
les floats.
>>> x = 32
12
>>> nom = "John"
>>> print(f"{nom} a {x} ans")#ou encore# print("{} a {}".format(nom,x))
John a 32 ans
Il suffit de passer un nom de variable au sein de chaque couple d'accolades et Python les remplace
par leur contenu ! Première remarque, la syntaxe apparait plus lisible que l'équivalent vu ci-avant
print(nom, "a", x, "ans"). Bien sûr, il ne faut pas omettre le f avant le premier guillemet,
sinon Python prendra cela pour une chaîne de caractères normale et ne mettra pas en place ce
mécanisme de remplacement :
>>> print("{nom} a {x} ans")
{nom} a {x} ans
13
IV. Les listes
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 en même temps (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 (n'oubliez pas 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.
Quelques exemples :
>>> animaux = ["girafe", "tigre", "singe", "souris"]
>>> tailles = [5, 2.5, 1.75, 0.15]
>>> 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]
Lorsque l'on affiche une liste, Python la restitue telle qu'elle a été saisie.
2. Utilisation
Un des gros avantages d'une liste est que vous pouvez 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
Soyez très attentif au fait que les indices d'une liste de n éléments commencent à 0 et se terminent
à n-1. Exemple:
>>> animaux[0]
'girafe'
>>> animaux[1]
'tigre'
>>> animaux[3]
'souris'
Par conséquent, si on appelle l'élément d'indice 4 de notre 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
>>> ani1 * 3
['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre']
14
Vous pouvez aussi utiliser la méthode .append() lorsque vous souhaitez ajouter un seul élément
à la fin d'une liste.
Création d’une liste vide :
>>> a = []
>>> a
[]
puis lui ajouter deux éléments, l'un après l'autre, d'abord avec la concaténation :
>>> a = a + [15]
>>> a
[15]
>>> a = a + [-5]
>>> a
[15, -5]
puis avec la méthode .append() :

>>> a.append(13)
>>> a
[15, -5, 13]
>>> a.append(-3)
>>> a
[15, -5, 13, -3]
Dans l'exemple ci-dessus, nous ajoutons des éléments à une liste en utilisant l'opérateur de
concaténation + ou la méthode .append(). Nous vous conseillons dans ce cas précis d'utiliser la
méthode .append() dont la syntaxe est plus élégante.
4. Indiçage négatif
La liste peut également être indexée avec des nombres négatifs selon le modèle suivant :
liste : ["girafe", "tigre", "singe", "souris"]
indice positif : 0 1 2 3
indice négatif : -4 -3 -2 -1
ou encore :
liste : ["A", "B", "C", "D", "E", "F"]
indice positif : 0 1 2 3 4 5
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.
>>> animaux[-1]
'souris'
>>> animaux[-2]
'singe'
Pour accéder au premier élément de la liste avec un indice négatif, il faut par contre connaître le
bon indice :
>>> animaux[-4]
'girafe'
Dans ce cas, on utilise plutôt animaux[0].
15
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[0:2]
['girafe', 'tigre']
>>> animaux[0:3]
['girafe', 'tigre', 'singe']
>>> animaux[0:]
>>> animaux[:]
>>> 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[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]
>>> x[::2]
[0, 2, 4, 6, 8]
>>> x[::3]
[0, 3, 6, 9]
>>> x[1:6:3]
[1, 4]
Finalement, on se rend compte que l'accès au contenu d'une liste fonctionne sur le modèle
liste[début:fin:pas].
6. Fonction len()
L'instruction len() vous permet de connaître la longueur d'une liste, c'est-à-dire le nombre
d'éléments que contient la liste.
Exemple d'utilisation :
>>> len(animaux)
4
>>> len([1, 2, 3, 4, 5, 6, 7, 8])
8
16
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. Par 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. Ici, la fonction range() a pris un argument, mais elle peut également prendre deux ou
trois arguments, comme suit :
>>> 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, prenez garde aux arguments optionnels par défaut (0 pour début et 1 pour pas) :
>>> 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. Listes de listes
Pour finir, sachez qu'il est tout à fait possible de construire des listes de listes. Cette fonctionnalité
peut parfois être très pratique. Par 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'
17
>>> zoo[1][1]
2
On verra un peu plus loin qu'il existe en Python des dictionnaires qui sont également très pratiques
pour stocker de l'information structurée. On verra aussi qu'il existe un module nommé NumPy qui
permet de créer des listes ou des tableaux de nombres (vecteurs et matrices) et de les manipuler.
9. Minimum, maximum et somme d'une liste¶

Les fonctions min(), max() et sum() renvoient respectivement le minimum, le maximum et la
somme d'une liste passée en argument.
>>> liste = list(range(10))
>>> liste
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sum(liste)
45
>>> min(liste)
0
>>> max(liste)
9
Même si en théorie ces fonctions peuvent prendre en argument une liste de strings, on les utilisera
la plupart du temps avec des types numériques (liste d'entiers et / ou de floats).
Attention ! Ne pas mélanger entiers et floats d'une part avec une liste d'autre part, car cela renvoie
une erreur :
>>> min(liste, 3, 4)
TypeError: '<' not supported between instances of 'int' and 'list'
Soit on passe plusieurs entiers et / ou floats en argument, soit on passe une liste unique.
18
V. Tuples et Dictionnaires
1. Tuples
i. Définition
Les tuples (« n-uplets » en français) sont des objets séquentiels correspondant aux listes (itérables,
ordonnés et indexables) mais ils sont toutefois non modifiables. L'intérêt des tuples par rapport
aux listes réside dans leur immutabilité. Cela, accélère considérablement la manière dont Python
accède à chaque élément et ils prennent moins de place en mémoire. Par ailleurs, on ne risque pas
de modifier un de ses éléments par mégarde.
Pratiquement, on utilise les parenthèses au lieu des crochets pour les créer :
>>> t = (1, 2, 3)
>>> t
(1, 2, 3)
>>> type(t)
<class 'tuple'>
>>> t[2]
3
>>> t[0:2]
(1, 2)
>>> t[2] = 15
TypeError: 'tuple' object does not support item assignment
L'affectation et l'indiçage fonctionnent comme avec les listes. Mais si on essaie de modifier un des
éléments du tuple (ligne 10), Python renvoie un message d'erreur. Si vous voulez ajouter un
élément (ou le modifier), vous devez créer un nouveau tuple :
>>> t = (1, 2, 3)
>>> t
(1, 2, 3)
>>> id(t)
139971081704464
>>> t = t + (2,)
>>> t
(1, 2, 3, 2)
>>> id(t)
139971081700368
La fonction id() montre que le tuple créé en ligne 6 est bien différent de celui créé en ligne 4 bien
qu'ils aient le même nom. Comme on a vu plus haut, ceci est dû à l'opérateur d'affectation utilisé
en ligne 6 (t = t + (2,)) qui crée un nouvel objet distinct de celui de la ligne 1. Cet exemple
montre que les tuples sont peu adaptés lorsqu'on a besoin d'ajouter, retirer, modifier des
éléments. La création d'un nouveau tuple à chaque étape s'avère lourde et il n'y a aucune méthode
pour faire cela puisque les tuples sont non modifiables. Pour ce genre de tâche, les listes sont
clairement mieux adaptées.
Remarque : Pour créer un tuple d'un seul élément comme ci-dessus, utilisez une syntaxe avec une
virgule (element,), pour éviter une ambiguïté avec une simple expression. Par exemple (2)
équivaut à l'entier 2, (2,) est un tuple avec l'élément 2.
Autre particularité des tuples, il est possible de les créer sans les parenthèses, dès lors que ceci ne
pose pas d'ambiguïté avec une autre expression :
>>> t = (1, 2, 3)
>>> t
19
(1, 2, 3)
>>> t = 1, 2, 3
>>> t
(1, 2, 3)
Toutefois, afin d'éviter les confusions, nous vous conseillons d'utiliser systématiquement les
parenthèses lorsque vous débutez.
Les opérateurs + et * fonctionnent comme pour les listes (concaténation et duplication) :
>>> (1, 2) + (3, 4)
(1, 2, 3, 4)
>>> (1, 2) * 4
(1, 2, 1, 2, 1, 2, 1, 2)
Enfin, on peut utiliser la fonction tuple(sequence) qui fonctionne exactement comme la fonction
list(), c'est-à-dire qu'elle prend en argument un objet de type container et renvoie le tuple
correspondant (opération de casting) :
>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple("ATGCCGCGAT")
('A', 'T', 'G', 'C', 'C', 'G', 'C', 'G', 'A', 'T')
ii. Affectation multiple et le nom de variable _

L'affectation multiple est un mécanisme très puissant et important en Python. Pour rappel, il permet
d'effectuer sur une même ligne plusieurs affectations en même temps, par exemple : x, y, z =
1, 2, 3. Cette syntaxe correspond à un tuple de chaque côté de l'opérateur =. Notez qu'il serait
possible de le faire également avec les listes : [x, y, z] = [1, 2, 3]. Toutefois, cette syntaxe
est alourdie par la présence des crochets. On préfèrera donc la première syntaxe avec les tuples
sans parenthèse.
2. Dictionnaires
i. Définition
Les dictionnaires se révèlent très pratiques lorsqu’on doit manipuler des structures complexes à
décrire et que les listes présentent leurs limites. Les dictionnaires sont des collections non
ordonnées d'objets (ceci est vrai jusqu'à la version 3.6 de Python). Il ne s'agit pas d'objets
séquentiels comme les listes ou chaînes de caractères, mais plutôt d'objets dits de correspondance
(mapping objects) ou tableaux associatifs. En effet, on accède aux valeurs d'un dictionnaire par
des clés. Exemple :
>>> ani1 = {}
>>> ani1["nom"] = "girafe"
>>> ani1["taille"] = 5.0
>>> ani1["poids"] = 1100
>>> ani1
{'nom': 'girafe', 'taille': 5.0, 'poids': 1100}
En premier, on définit un dictionnaire vide avec les accolades {} (tout comme on peut le faire pour
les listes avec []). Ensuite, on remplit le dictionnaire avec différentes clés ("nom", "taille",
"poids") auxquelles on affecte des valeurs ("girafe", 5.0, 1100).
On peut aussi initialiser toutes les clés et les valeurs d'un dictionnaire en une seule opération :
>>> ani2 = {"nom": "singe", "poids": 70, "taille": 1.75}
20
Mais rien ne nous empêche d'ajouter une clé et une valeur supplémentaire :
>>> ani2["age"] = 15
Pour récupérer la valeur associée à une clé donnée, il suffit d'utiliser la syntaxe suivante
dictionnaire["cle"]. Par exemple :
>>> ani1["taille"]
5.0
L'un des avantages des dictionnaires, est pouvoir retrouver des éléments par des noms (clés) plutôt
que par des indices. Les humains retiennent mieux les noms que les chiffres. Ainsi, l'usage des
dictionnaires rend en général le code plus lisible. Par exemple, si nous souhaitions stocker les
coordonnées d'un point dans l'espace : coors = [0, 1, 2] pour la version liste, coors = {"x":
0, "y": 1, "z": 2} pour la version dictionnaire. Un lecteur comprendra tout de suite que
coors["z"] contient la coordonnée, ce sera moins intuitif avec coors[2].
ii. Itération sur les clés pour obtenir les valeurs
Si on souhaite voir toutes les associations clés / valeurs, on peut itérer sur un dictionnaire de la
manière suivante :
>>> ani2 = {'nom': 'singe', 'poids': 70, 'taille': 1.75}

>>> for key in ani2:
... print(key, ani2[key])
...
poids 70
nom singe
taille 1.75
Par défaut, l'itération sur un dictionnaire se fait sur les clés. Dans cet exemple, la variable
d'itération key prend successivement la valeur de chaque clé, ani2[key] donne la valeur
correspondant à chaque clé.
iii. Méthodes .keys() et .values()
Les méthodes .keys() et .values() renvoient, comme vous vous en doutez, les clés et les valeurs
d'un dictionnaire :
>>> ani2.keys()
dict_keys(['poids', 'nom', 'taille'])
>>> ani2.values()
dict_values([70, 'singe', 1.75])
iv. Existence d'une clé ou d'une valeur

Pour vérifier si une clé existe dans un dictionnaire, on peut utiliser le test d’appartenance avec
l'opérateur in qui renvoie un booléen :
>>> if "poids" in ani2:
... print("La clé 'poids' existe pour ani2")
...
La clé 'poids' existe pour ani2
>>> if "age" in ani2:
... print("La clé 'age' existe pour ani2")
...
Dans le second test (lignes 5 à 7), le message n'est pas affiché car la clé age n'est pas présente
dans le dictionnaire ani2.
21
Si on souhaite tester si une valeur existe dans un dictionnaire, on peut utiliser l'opérateur in avec
l'objet renvoyé par la méthode .values() :
>>> ani2.values()
dict_values(['singe', 70, 1.75])
>>> "singe" in ani2.values()
True
v. Méthode .get()
Par défaut, si on demande la valeur associée à une clé qui n'existe pas, Python renvoie une erreur:
>>> ani2["age"]
KeyError: 'age'
La méthode .get() s'affranchit de ce problème. Elle extrait la valeur associée à une clé mais ne
renvoie pas d'erreur si la clé n'existe pas :
>>> ani2.get("nom")
'singe'
>>> ani2.get("age")
>>>
Ici la valeur associée à la clé nom est singe mais la clé age n'existe pas. On peut également indiquer
à .get() une valeur par défaut si la clé n'existe pas :
>>> ani2.get("age", 42)
42
Remarque : Les listes, les dictionnaires et les tuples sont des containers, c'est-à-dire qu'il s'agit
d'objets qui contiennent une collection d'autres objets. En Python, on peut construire des listes
qui contiennent des dictionnaires, des tuples ou d'autres listes, mais aussi des dictionnaires
contenant des tuples, des listes, etc. Les combinaisons sont infinies !
22
VI. Tests
1. Définition
Les tests sont un élément essentiel à tout langage informatique si on veut lui donner un peu de
complexité car ils permettent à l'ordinateur de prendre des décisions. Pour cela, Python utilise
l'instruction if ainsi qu'une comparaison.
SYNTAXE
Algorithmique Python
SI condition ALORS if condition1:
Instruction 1 (ou bloc d’instructions 1)
bloc d'instructions 1
SINON
Instruction 2 (ou bloc d’instructions 2) else:
FINSI bloc d'instructions 2
SI condition1 ALORS if condition1:
bloc d’instructions 1
bloc d'instructions 1
SINON SI condition2 ALORS
bloc d’instructions 2 elif condition2:
SINON bloc d'instructions 2
bloc d’instructions 3
FINSI else:
FINSI bloc d'instructions 3
Exemple1 :
>>> x = 2
>>> if x == 2:
... print("Le test est vrai !")
...
Le test est vrai !
Exemple2 :
>>> x = "souris"
>>> if x == "tigre":
...
Remarques concernant ces deux exemples :

• Dans le premier exemple, le test étant vrai, l'instruction print("Le test est vrai !")
est exécutée. Dans le second exemple, le test est faux et rien n'est affiché.
• Les blocs d'instructions dans les tests doivent forcément être indentés. L'indentation
indique la portée des instructions à exécuter si le test est vrai.
• La ligne qui contient l'instruction if se termine par le caractère deux-points « : ».
2. Tests à plusieurs cas

Parfois, il est pratique de tester si la condition est vraie ou si elle est fausse dans une même
instruction if. Plutôt que d'utiliser deux instructions if, on peut se servir des instructions if et
else :
>>> x = 2
>>> if x == 2:
... else:
... print("Le test est faux !")
23
...
Le test est vrai !
>>> x = 3
>>> if x == 2:
... else:
... print("Le test est faux !")
...
Le test est faux !
On peut utiliser une série de tests dans la même instruction if, notamment pour tester plusieurs
valeurs d'une même variable.
Exemple : résultat d’un semestre en python
if (moyenneUE1 >= 8 et moyenneUE2 >= 8):
if moyenneGenerale >= 10:
print("Le semestre est validé!")
elif (moyenneGenerale + moyenneSemestrePrecedent)/2 >= 10:
print("Le semestre est validé par compensation avec le semestre
précédent.")
else:
print("La compensation est impossible. Le semestre n'est pas
validé.")
else:
print("Le semestre n'est pas validé car au moins l'une des UE est
inférieure à 8.")
Dans cet exemple, Python teste la première condition, puis, si et seulement si elle est fausse, teste
la deuxième et ainsi de suite... Le code correspondant à la première condition vérifiée est exécuté
puis Python sort du bloc d'instructions du if.
3. Importance de l'indentation
De nouveau, faites bien attention à l'indentation ! Vous devez être très rigoureux sur ce point.
Pour vous en convaincre, exécutez ces deux exemples de code :
Code 1
nombres = [4, 5, 6]
for nb in nombres:
if nb == 5:
print("Le test est vrai")
print(f"car la variable nb vaut {nb}")
Résultat :
Le test est vrai
car la variable nb vaut 5
Code 2
nombres = [4, 5, 6]
for nb in nombres:
if nb == 5:
print("Le test est vrai")
print(f"car la variable nb vaut {nb}")
Résultat :
Le test est vrai
24
Les deux codes pourtant très similaires produisent des résultats très différents. Si vous observez
avec attention l'indentation des instructions sur la ligne 5, vous remarquerez que dans le code 1,
l'instruction est indentée deux fois, ce qui signifie qu'elle appartient au bloc d'instructions du test
if. Dans le code 2, l'instruction de la ligne 5 n'est indentée qu'une seule fois, ce qui fait qu'elle
n'appartient plus au bloc d'instructions du test if, d'où l'affichage de car la variable nb vaut
xx pour toutes les valeurs de nb.
4. Tests multiples
Les tests multiples permettent de tester plusieurs conditions en même temps en utilisant des
opérateurs booléens. Les deux opérateurs les plus couramment utilisés sont le OU et le ET. Voici
un petit rappel sur le fonctionnement de l'opérateur OU :
Condition 1 Opérateur Condition 2 Résultat
Vrai OU Vrai Vrai
Vrai OU Faux Vrai
Faux OU Vrai Vrai
Faux OU Faux Faux
et de l'opérateur ET :
Condition 1 Opérateur Condition 2 Résultat
Vrai ET Vrai Vrai
Vrai ET Faux Faux
Faux ET Vrai Faux
Faux ET Faux Faux
En Python, on utilise le mot réservé and pour l'opérateur ET et le mot réservé or pour l'opérateur
OU. Respectez bien la casse des opérateurs and et or qui, en Python, s'écrivent en minuscule.
Exemple :
>>> x = 2
>>> y = 2
>>> if x == 2 and y == 2:
... print("le test est vrai")
...
le test est vrai
Notez que le même résultat serait obtenu en utilisant deux instructions if imbriquées :
>>> x = 2
>>> y = 2
>>> if x == 2:
... if y == 2:
... print("le test est vrai")
...
le test est vrai
Vous pouvez aussi tester directement l'effet de ces opérateurs à l'aide de True et False (attention
à respecter la casse).
>>> True or False
True
Enfin, on peut utiliser l'opérateur logique de négation not qui inverse le résultat d'une condition :
25
>>> not True
False
>>> not False
True
>>> not (True and True)
False
5. Instructions break et continue

Ces deux instructions permettent de modifier le comportement d'une boucle (for ou while) avec
un test.
L'instruction break stoppe la boucle.
>>> for i in range(5):
... if i > 2:
... break
... print(i)
...
0
1
2
L'instruction continue saute à l'itération suivante, sans exécuter la suite du bloc d'instructions de
la boucle.
... if i == 2:
... continue
... print(i)
...
0
1
3
4
26
VII. Boucles et comparaisons
1. Boucles for
i. Principe
En programmation, on est souvent amené à répéter plusieurs fois une instruction. Incontournables
à tout langage de programmation, les boucles vont nous aider à réaliser cette tâche de manière
compacte et efficace.
Imaginez par exemple que vous souhaitiez afficher les éléments d'une liste les uns après les autres.
Dans l'état actuel de vos connaissances, il faudrait taper quelque chose du style :
animaux = ["girafe", "tigre", "singe", "souris"]
print(animaux[0])
print(animaux[1])
print(animaux[2])
print(animaux[3])
Si votre liste ne contient que 4 éléments, ceci est encore faisable mais imaginez qu'elle en contienne
100 voire 1000 ! Pour remédier à cela, il faut utiliser les boucles. Exemple :
>>> for animal in animaux:
... print(animal)
...
girafe
tigre
singe
souris
La variable animal est appelée variable d'itération, elle prend successivement les différentes
valeurs de la liste animaux à chaque itération de la boucle. Celle-ci est créée par Python la première
fois que la ligne contenant le for est exécutée (si elle existait déjà son contenu serait écrasé). Une
fois la boucle terminée, cette variable d'itération animal ne sera pas détruite et contiendra ainsi la
dernière valeur de la liste animaux (ici la chaîne de caractères souris).
Notez bien les types des variables utilisées ici : animaux est une liste sur laquelle on itère, et
animal est une chaîne de caractères car chaque élément de la liste est une chaîne de caractères.
Le caractère deux-points « : » à la fin de la ligne débutant par for, signifie que la boucle for
attend un bloc d'instructions, en l’occurrence toutes les instructions que Python répétera à chaque
itération de la boucle. On appelle ce bloc d'instructions le corps de la boucle. Comment indique-
t-on à Python où ce bloc commence et se termine ? Cela est signalé uniquement par l'indentation,
c'est-à-dire le décalage vers la droite de la (ou des) ligne(s) du bloc d'instructions.
Dans l'exemple suivant, le corps de la boucle contient deux instructions : print(animal) et
print(animal*2) car elles sont indentées par rapport à la ligne débutant par for :
for animal in animaux:
print(animal)
print(animal*2)
print("C'est fini")
La ligne 4 print("C'est fini") ne fait pas partie du corps de la boucle car elle est au même
niveau que le for (c'est-à-dire non indentée par rapport au for). Notez également que chaque
instruction du corps de la boucle doit être indentée de la même manière.
Si on oublie l'indentation, Python renvoie un message d'erreur :
27
... print(animal)
File "<stdin>", line 2
print(animal)
^
IndentationError: expected an indented block
Dans les exemples ci-dessus, nous avons exécuté une boucle en itérant directement sur une liste.
Une tranche d'une liste étant elle-même une liste, on peut également itérer dessus :
>>> for animal in animaux[1:3]:
... print(animal)
...
tigre
singe
On a vu que les boucles for pouvaient utiliser une liste contenant des chaînes de caractères, mais
elles peuvent tout aussi bien utiliser des listes contenant des entiers (ou n'importe quel type de
variable).
>>> for i in [1, 2, 3]:
... print(i)
...
1
2
3
ii. Fonction range()

Python possède la fonction range() qui est aussi bien commode pour faire une boucle sur une
liste d'entiers de manière automatique :
... print(i)
...
0
1
2
3
Remarques importantes :
- 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.
- range() est une fonction qui a été spécialement conçue pour que l'on puisse 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. Si vous vous souvenez bien, il s'agit d'une fonction de casting, qui
convertit un type en un autre.
iii. Itération sur les indices ou les éléments

Parcourir une liste, par une itération sur ses indices :
28
... 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]). Notez à nouveau le nom i de la variable
d'itération car on itère sur les indices.
Parmi les 2 méthodes, la plus efficace est celle qui réalise les itérations directement sur les
éléments :
... print(animal)
...
girafe
tigre
singe
souris
Toutefois, il se peut qu'au cours d'une boucle vous ayez besoin des indices, auquel cas vous devrez
itérer sur les indices :
>>> for i in range(len(animaux)):
... print(f"L'animal {i} est un(e) {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 vous permet d'itérer sur les indices et les
éléments eux-mêmes.
>>> for i, animal in enumerate(animaux):
... print(f"L'animal {i} est un(e) {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. Boucles while
Une autre alternative à l'instruction for couramment utilisée en informatique est la boucle while.
Le principe est simple. Un bloc d'instructions est exécuté tant qu'une certaine condition reste vraie.
Exemple : (en algorithmique)
ECRIRE("entrez un nombre strictement positif")
LIRE(n)
TANTQUE n < 0 :
ECRIRE("erreur, le nombre n'était pas strictement positif. Recommencez svp.")
LIRE(n)
FINTANTQUE
29
Exemple : (en python)
n = int(input("entrez un nombre strictement positif"))
while n < 0 :
n = int(input("erreur, le nombre n'était pas strictement positif.
Recommencez svp."))
Autre exemple :
>>> i = 1
>>> while i <= 4:
... print(i)
... i = i + 1
...
1
2
3
4
Une boucle while nécessite généralement trois éléments pour fonctionner correctement :
1. Initialisation de la variable d'itération avant la boucle (ligne 1).
2. Test de la variable d'itération associée à l'instruction while (ligne 2).
3. Mise à jour de la variable d'itération dans le corps de la boucle (ligne 4).
Faites bien attention aux tests et à l'incrémentation que vous utilisez car une erreur mène souvent
à des « boucles infinies » qui ne s'arrêtent jamais. Vous pouvez néanmoins toujours stopper
l'exécution d'un script Python à l'aide de la combinaison de touches Ctrl-C (c'est-à-dire en pressant
simultanément les touches Ctrl et C). Par exemple :
i = 0
while i < 10:
print("Le python c'est cool !")
Ici, nous avons omis de mettre à jour la variable i dans le corps de la boucle. Par conséquent, la
boucle ne s'arrêtera jamais (sauf en pressant Ctrl-C) puisque la condition i < 10 sera toujours
vraie.
La boucle while combinée à la fonction input() peut s'avérer commode lorsqu'on souhaite
demander à l'utilisateur une valeur numérique. Par exemple :
>>> i = 0
>>> while i < 10:
... reponse = input("Entrez un entier supérieur à 10 : ")
... i = int(reponse)
...
Entrez un entier supérieur à 10 : 4
Entrez un entier supérieur à 10 : -3
Entrez un entier supérieur à 10 : 15
>>> i
15
La fonction input() prend en argument un message (sous la forme d'une chaîne de caractères),
demande à l'utilisateur d'entrer une valeur et renvoie celle-ci sous forme d'une chaîne de caractères.
Il faut ensuite convertir cette dernière en entier (avec la fonction int()).
30
VIII. Les fichiers
1. Lecture dans un fichier
Généralement, l'information en grande quantité est stockée sous forme de donnée dans des fichiers.
Pour traiter cette information, vous devez le plus souvent lire ou écrire dans un ou plusieurs
fichiers. Python possède pour cela de nombreux outils qui vous simplifient la vie.
i. Méthode .readlines()
Avant tout, créez un fichier dans un éditeur de texte que vous enregistrerez dans votre répertoire
courant avec le nom zoo.txt et le contenu suivant :
girafe
tigre
singe
souris
Ensuite, testez le code suivant dans l'interpréteur Python :
>>> fic = open("zoo.txt", "r")

>>> fic
<_io.TextIOWrapper name='zoo.txt' mode='r' encoding='UTF-8'>
>>> fic.readlines()
['girafe\n', 'tigre\n', 'singe\n', 'souris\n']
>>> fic.close()
>>> fic.readlines()
ValueError: I/O operation on closed file.
Commentaires sur cet exemple :

Ligne 1 : L'instruction open() ouvre le fichier zoo.txt. Ce fichier est ouvert en lecture seule,
comme l'indique le second argument r (pour read) de la fonction open(). En ce moment, le fichier
n'est pas encore lu, mais simplement ouvert (un peu comme lorsqu'on ouvre un livre, mais qu'on
ne l'a pas encore lu). Le curseur de lecture est prêt à lire le premier caractère du fichier.
L'instruction open("zoo.txt", "r") suppose que le fichier zoo.txt est dans le répertoire depuis
lequel l'interpréteur Python a été lancé. Si ce n'est pas le cas, il faut préciser le chemin d'accès au
fichier. Par exemple, /home/pierre/zoo.txt pour Linux ou Mac OS X ou
C:\Users\pierre\zoo.txt pour Windows.
Ligne 2 : Lorsqu'on affiche le contenu de la variable fic, on se rend compte que Python la
considère comme un objet de type fichier ouvert (ligne 3).
Ligne 4 : Nous utilisons à nouveau la syntaxe objet.méthode(). Ici ; la méthode .readlines()
agit sur l'objet fic en déplaçant le curseur de lecture du début à la fin du fichier, puis elle renvoie
une liste contenant toutes les lignes du fichier (dans notre analogie avec un livre, ceci
correspondrait à lire toutes les lignes du livre).
Ligne 6 : Enfin, on applique la méthode .close() sur l'objet fic, ce qui, vous vous en doutez,
ferme le fichier (ceci correspondrait à fermer le livre). Vous remarquerez que la méthode
.close() ne renvoie rien mais modifie l'état de l'objet fic en fichier fermé. Ainsi, si on essaie de
lire à nouveau les lignes du fichier, Python renvoie une erreur car il ne peut pas lire un fichier
fermé (lignes 7 à 10).
Un exemple complet de lecture d'un fichier avec Python.
31
>>> fic = open("zoo.txt", "r")
>>> lignes = fic.readlines()
>>> lignes
['girafe\n', 'tigre\n', 'singe\n', 'souris\n']
>>> for ligne in lignes :
... print(ligne)
...
girafe
tigre
singe
souris
>>> fic.close()
En cinq lignes de code, on a lu, parcouru le fichier et affiché son contenu.

Remarque :
• Chaque élément de la liste lignes est une chaîne de caractères. C'est en effet sous forme de
chaînes de caractères que Python lit le contenu d'un fichier.
• Chaque élément de la liste lignes se termine par le caractère \n. Ce caractère un peu
particulier correspond au « saut de ligne » qui permet de passer d'une ligne à la suivante.
Ceci est codé par un caractère spécial que l'on représente par \n.
• Par défaut, l'instruction print() affiche quelque chose puis revient à la ligne. Ce retour à la
ligne dû à print() se cumule alors avec celui de la fin de ligne (\n) de chaque ligne du fichier
et donne l'impression qu'une ligne est sautée à chaque fois.
Il existe en Python le mot-clé with qui permet d'ouvrir et de fermer un fichier de manière efficace.
Si pour une raison ou une autre l'ouverture ou la lecture du fichier conduit à une erreur, l'utilisation
de with garantit la bonne fermeture du fichier, ce qui n'est pas le cas dans le code précédent. Voici
donc le même exemple avec with :
>>> with open("zoo.txt", 'r') as fich:

... lignes = fich.readlines()
... for ligne in lignes:
... print(ligne)
...
girafe
tigre
singe
souris
>>>
Remarque :
• L'instruction with introduit un bloc d'indentation. C'est à l'intérieur de ce bloc que nous
effectuons toutes les opérations sur le fichier.
• Une fois sorti du bloc d'indentation, Python fermera automatiquement le fichier. Vous
n'avez donc plus besoin d’utiliser la méthode .close().
32
ii. Méthode .read()
Il existe d'autres méthodes que .readlines() pour lire (et manipuler) un fichier. Par exemple, la
méthode .read() lit tout le contenu d'un fichier et renvoie une chaîne de caractères unique.
>>> with open("zoo.txt", "r") as fich:
... fich.read()
...
'girafe\ntigre\nsinge\nsouris\n'
>>>
iii. Méthode .readline()

La méthode .readline() (sans s à la fin) lit une ligne d'un fichier et la renvoie sous forme de
chaîne de caractères. À chaque nouvel appel de .readline(), la ligne suivante est renvoyée.
Associée à la boucle while, cette méthode permet de lire un fichier ligne par ligne.
>>> with open("zoo.txt", "r") as filin:
... ligne = filin.readline()
... while ligne != "":
... print(ligne)
... ligne = filin.readline()
...
girafe
tigre
singe
souris
>>>
iv. Itération directe sur le fichier

Python essaie de vous faciliter la vie au maximum. Voici un moyen à la fois simple et élégant de
parcourir un fichier.
>>> with open("zoo.txt", "r") as fich:
... for ligne in fich:
... print(ligne)
...
girafe
tigre
singe
souris
>>>
L'objet fich est « itérable », ainsi la boucle for va demander à Python d'aller lire le fichier ligne
par ligne.
v. Écriture dans un fichier

Écrire dans un fichier est aussi simple que de le lire. Voyez l'exemple suivant :
>>> animaux2 = ["poisson", "abeille", "chat"]
>>> with open("zoo2.txt", "w") as fich:
33
... for animal in animaux2:
... fich.write(animal)
...
7
7
4
Quelques commentaires sur cet exemple :
Ligne 1 : Création d'une liste de chaînes de caractères animaux2.

Ligne 2 : Ouverture du fichier zoo2.txt en mode écriture, avec le caractère w pour write.
L'instruction with crée un bloc d'instructions qui doit être indenté.
Ligne 3 : Parcours de la liste animaux2 avec une boucle for.
Ligne 4 : À chaque itération de la boucle, nous avons écrit chaque élément de la liste dans le fichier.
La méthode .write() s'applique sur l'objet fich. Notez qu'à chaque utilisation de la méthode
.write(), celle-ci nous affiche le nombre d'octets (équivalent au nombre de caractères) écrits dans
le fichier (lignes 6 à 8). Ceci est valable uniquement dans l'interpréteur, si vous créez un
programme avec les mêmes lignes de code, ces valeurs ne s'afficheront pas à l'écran.
Si nous ouvrons le fichier zoo2.txt avec un éditeur de texte, voici ce que nous obtenons :
poissonabeillechat
Ce n'est pas exactement le résultat attendu car implicitement nous voulions le nom de chaque
animal sur une ligne. Nous avons oublié d'ajouter le caractère fin de ligne après chaque nom
d'animal.
Pour ce faire, nous pouvons utiliser l'écriture formatée :
>>> animaux2 = ["poisson", "abeille", "chat"]
>>> with open("zoo2.txt", "w") as fich:
... for animal in animaux2:
... fich.write(f"{animal}\n")
...
8
8
5
Ligne 4 : L'écriture formatée permet d'ajouter un retour à la ligne (\n) après le nom de chaque
animal.
Lignes 6 à 8 : Le nombre d'octets écrits dans le fichier est augmenté de 1 par rapport à l'exemple
précédent car le caractère retour à la ligne compte pour un seul octet.
Le contenu du fichier zoo2.txt est alors :
poisson
abeille
chat
Vous voyez qu'il est extrêmement simple en Python de lire ou d'écrire dans un fichier.
vi. Ouvrir deux fichiers avec l'instruction with

On peut avec l'instruction with ouvrir deux fichiers (ou plus) en même temps. Exemple suivant :
with open("zoo.txt", "r") as fich1, open("zoo2.txt", "w") as fich2:
for ligne in fich1:
fich2.write("* " + ligne)
34
Si le fichier zoo.txt contient le texte suivant :
souris
girafe
lion
singe
alors le contenu de zoo2.txt sera :

* souris
* girafe
* lion
* singe
Dans cet exemple, with permet une notation très compacte en s'affranchissant de deux méthodes
.close().
35
IX. Les modules
1. Définition
Les modules sont des programmes Python qui contiennent des fonctions que l'on est amené à
réutiliser souvent (on les appelle aussi bibliothèques ou libraries). Ce sont des « boîtes à outils »
qui vont vous être très utiles.
Les développeurs de Python ont mis au point de nombreux modules qui effectuent une quantité
phénoménale de tâches. Pour cette raison, prenez toujours le réflexe de vérifier si une partie du
code que vous souhaitez écrire n'existe pas déjà sous forme de module. La plupart de ces modules
sont déjà installés dans les versions standards de Python.
2. Importation de modules
Précédemment, la notion de module a été évoquée lorsque nous avons voulu tirer un nombre
aléatoire :
>>> import random
>>> random.randint(0, 10)
4
Ce que fait cet exemple :

• Ligne 1, l'instruction import donne accès à toutes les fonctions du module random.
• Ensuite, ligne 2, nous utilisons la fonction randint(0, 10) du module random. Cette
fonction renvoie un nombre entier tiré aléatoirement entre 0 inclus et 10 inclus.
Le module math donne accès aux fonctions trigonométriques sinus et cosinus, et à la constante :
>>> import math
>>> math.cos(math.pi / 2)
6.123233995736766e-17
>>> math.sin(math.pi / 2)
1.0
En résumé, l'utilisation de la syntaxe import module permet d'importer toute 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. Python possède de nombreux autres modules
internes (c'est-à-dire présent de base lorsqu'on installe Python).
Il existe un autre moyen d'importer une ou plusieurs fonctions d'un module :
>>> from random import randint
>>> randint(0,10)
7
À l'aide du mot-clé from, on peut importer une fonction spécifique d'un module donné. Remarquez
bien qu'il est inutile de répéter le nom du module dans ce cas, seul le nom de la fonction en question
est requis.
On peut également importer toutes les fonctions d'un module :
>>> from random import *
>>> randint(0,50)
46
>>> uniform(0,2.5)
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 randint() et uniform() qui
renvoie des nombres aléatoires entiers et floats.
36
Dans la pratique, plutôt que de charger toutes les fonctions d'un module en une seule fois :
from random import *
nous vous conseillons de charger le module seul de la manière suivante :

import random
puis d'appeler explicitement les fonctions voulues, par exemple :

random.randint(0,2)
Il est également possible de définir un alias (un nom plus court) pour un module :
>>> import random as rand
>>> rand.randint(1, 10)
6
>>> rand.uniform(1, 3)
2.643472616544236
Dans cet exemple, les fonctions du module random sont accessibles via l'alias rand.
Enfin, pour vider de la mémoire un module déjà chargé, on peut utiliser l'instruction del :
>>> import random
>>> random.randint(0,10)
2
>>> del random
>>> random.randint(0,10)
File "<stdin>", line 1, in ?
NameError: name 'random' is not defined
On constate alors qu'un rappel (ligne 5) d'une fonction du module random après l'avoir vidé de la
mémoire (ligne 4) retourne un message d'erreur (lignes 6-8).
3. Quelques modules courants

Il existe une série de modules que vous serez probablement amenés à utiliser si vous programmez
en Python. En voici une liste non exhaustive :
• math : fonctions et constantes mathématiques de base (sin, cos, exp, pi...).

• sys : interaction avec l'interpréteur Python, passage d'arguments (cf. plus bas).
• os : dialogue avec le système d'exploitation (cf. plus bas).
• random : génération de nombres aléatoires.
• time : accès à l'heure de l'ordinateur et aux fonctions gérant le temps.
• urllib : récupération de données sur internet depuis Python.
• Tkinter : interface python avec Tk. Création d'objets graphiques (cf. chapitre 20 Fenêtres
graphiques et Tkinter).
• re : gestion des expressions régulières (cf. chapitre 16 Expressions régulières et
parsing*).
37
X. Les fonctions
1. Principes et généralités
En programmation, les fonctions sont très utiles pour réaliser plusieurs fois la même opération au
sein d'un programme. Elles rendent également le code plus lisible et plus clair en le fractionnant
en blocs logiques.
Une fonction est une sorte de « boîte noire » :
1. À laquelle vous passez aucune, une ou plusieurs variable(s) entre parenthèses. Ces
variables sont appelées arguments. Il peut s'agir de n'importe quel type d'objet Python.
2. Qui effectue une action.
3. Et qui renvoie un objet Python ou rien du tout.
Par exemple, si vous appelez la fonction len() de la manière suivante :

>>> len([0, 1, 2])
3
voici ce qui se passe :

1. vous appelez 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 vous renvoie un entier égal à cette longueur.
Autre exemple, si vous appelez la méthode ma_liste.append() (n'oubliez pas, une méthode est
une fonction qui agit sur l'objet auquel elle est attachée par un point) :
>>> ma_liste.append(5)
1. Vous passez l'entier 5 en argument ;

2. la méthode append() ajoute l'entier 5 à l'objet ma_liste ;
3. et elle ne renvoie rien.
Aux yeux du programmeur au contraire, une fonction est une portion de code effectuant une suite
d'instructions bien particulière :
• Une fonction effectue une tâche. Pour cela, elle reçoit éventuellement des arguments et
renvoie éventuellement quelque chose.
• 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 les autres). Cette modularité améliore la qualité générale et la lisibilité du code.
Pour finir sur les généralités, nous avons utilisé dans la Figure 1 le terme programme principal
(main en anglais) pour désigner l'endroit depuis lequel on appelle une fonction (on verra plus tard
que l'on peut en fait appeler une fonction de n'importe où). Le programme principal désigne le
code qui est exécuté lorsqu'on lance le script Python, c'est-à-dire toute la suite d'instructions en
dehors des fonctions. En général, dans un script Python, on écrit d'abord les fonctions puis le
programme principal.
2. Définition
Pour définir une fonction, Python utilise le mot-clé def. Si on souhaite que la fonction renvoie
quelque chose, il faut utiliser le mot-clé return. Par exemple :
>>> def carre(x):
... return x**2
38
...
>>> print(carre(2))
4
Notez que la syntaxe de def utilise les deux points comme les boucles for et while ainsi que les
tests if, un bloc d’instructions est donc attendu. De même que pour les boucles et les tests,
l'indentation de ce bloc d'instructions (qu'on appelle le corps de la fonction) est obligatoire.
Dans l'exemple précédent, nous avons passé un argument à la fonction carre() qui nous a renvoyé
(ou retourné) une valeur que nous avons immédiatement affichée à l'écran avec l'instruction
print(). Cela signifie que cette dernière est récupérable dans une variable :
>>> res = carre(2)

>>> print(res)
4
Ici, le résultat renvoyé par la fonction est stocké dans la variable res. Notez qu'une fonction ne
prend pas forcément un argument et ne renvoie pas forcément une valeur, par exemple :
>>> def hello():
... print("bonjour")
...
>>> hello()
bonjour
Dans ce cas la fonction, hello() se contente d'afficher la chaîne de caractères "bonjour" à l'écran.
Elle ne prend aucun argument et ne renvoie rien. Par conséquent, cela n'a pas de sens de vouloir
récupérer dans une variable le résultat renvoyé par une telle fonction. Si on essaie tout de même,
Python affecte la valeur None qui signifie "rien" en anglais :
>>> var = hello()
bonjour
>>> print(var)
None
Ceci n'est pas une faute car Python n'émet pas d'erreur, toutefois cela ne présente, la plupart du
temps, guère d'intérêt.
3. Passage d'arguments
Le nombre d'arguments que l'on peut passer à une fonction est variable. Nous avons vu ci-dessus
des fonctions auxquelles on passait 0 ou 1 argument. Souvenez-vous par exemple de range(1,
10) ou encore range(1, 10, 2). Le nombre d'argument est donc laissé libre à l'initiative du
programmeur qui développe une nouvelle fonction.
Une particularité des fonctions en Python est que vous n'êtes pas obligé de préciser le type des
arguments que vous lui passez, dès lors que les opérations que vous effectuez avec ces arguments
sont valides. Python est en effet connu comme étant un langage au « typage dynamique », c'est-
à-dire qu'il reconnaît pour vous le type des variables au moment de l'exécution. Par exemple :
>>> def fois(x, y):
... return x*y
...
>>> fois(2, 3)
6
>>> fois(3.1415, 5.23)
16.430045000000003
>>> fois("to", 2)
'toto'
>>> fois([1,3], 2)
[1, 3, 1, 3]
39
L'opérateur * reconnaît plusieurs types (entiers, floats, chaînes de caractères, listes). Mais, il est
plus judicieux que chaque argument ait un type précis (entiers, floats, chaînes de caractères, etc)
et pas l'un ou l'autre.
4. Renvoi de résultats
Un énorme avantage en Python est que les fonctions sont capables de renvoyer plusieurs objets à
la fois, comme dans cette fraction de code :
>>> def carre_cube(x):
... return x**2, x**3
...
>>> carre_cube(2)
(4, 8)
En réalité Python ne renvoie qu'un seul objet, mais celui-ci peut être séquentiel, c'est-à-dire
contenir lui-même d'autres objets. Notre fonction pourrait tout autant renvoyer une liste :
>>> def carre_cube2(x):
... return [x**2, x**3]
...
>>> carre_cube2(3)
[9, 27]
Renvoyer un tuple ou une liste de deux éléments (ou plus) est très pratique en conjonction avec
l'affectation multiple, par exemple :
>>> z1, z2 = carre_cube2(3)
>>> z1
9
>>> z2
27
Cela permet de récupérer plusieurs valeurs renvoyées par une fonction et de les affecter à la volée
à des variables différentes.
5. Arguments positionnels et arguments par nom
Jusqu'à maintenant, nous avons systématiquement passé le nombre d'arguments que la fonction
attendait. Mais que se passe-t-il si une fonction attend deux arguments et que nous ne lui en passons
qu'un seul ?
>>> def fois(x, y):
... return x*y
...
>>> fois(2, 3)
6
>>> fois(2)
TypeError: fois() missing 1 required positional argument: 'y'
On constate qu’en passant un seul argument à une fonction qui en attend deux, on provoque une
erreur.
- Arguments positionnels :
Lorsqu'on définit une fonction def fct(x, y): les arguments x et y sont appelés arguments
positionnels. Il est strictement obligatoire de les préciser lors de l'appel de la fonction. De plus, il
est nécessaire de respecter le même ordre lors de l'appel que dans la définition de la fonction. Dans
l'exemple ci-dessus, 2 correspondra à x et 3 correspondra à y. Finalement, tout dépendra de leur
position, d'où leur qualification de positionnel.
40
Mais il est aussi possible de passer un ou plusieurs argument(s) de manière facultative et de leur
attribuer une valeur par défaut :
>>> def fct(x=1):
... return x
...
>>> fct()
1
>>> fct(10)
10
- Arguments par nom :
Un argument défini avec une syntaxe def fct(arg=val): est appelé argument par nom. Le
passage d'un tel argument lors de l'appel de la fonction est facultatif. Ce type d'argument ne doit
pas être confondu avec les arguments positionnels présentés ci-dessus, dont la syntaxe est def
fct(arg):.
Il est bien sûr possible de passer plusieurs arguments par mot-clé :

>>> def fct(x=0, y=0, z=0):
... return x, y, z
...
>>> fct()
(0, 0, 0)
>>> fct(10)
(10, 0, 0)
>>> fct(10, 8)
(10, 8, 0)
>>> fct(10, 8, 3)
(10, 8, 3)
On observe que pour l'instant, les arguments par nom sont pris dans l'ordre dans lesquels on les
passe lors de l'appel. Comment pourrions-nous faire si on souhaitait préciser l'argument par nom
z et garder les valeurs de x et y par défaut ? Simplement en précisant le nom de l'argument lors de
l'appel :
>>> fct(z=10)
(0, 0, 10)
Python permet même de rentrer les arguments par nom dans un ordre arbitraire :
>>> fct(z=10, x=3, y=80)
(3, 80, 10)
>>> fct(z=10, y=80)
(0, 80, 10)
Que se passe-t-il lorsque nous avons un mélange d'arguments positionnels et par nom ? Et bien les
arguments positionnels doivent toujours être placés avant les arguments par nom :
>>> def fct(a, b, x=0, y=0, z=0):
... return a, b, x, y, z
...
>>> fct(1, 1)
(1, 1, 0, 0, 0)
>>> fct(1, 1, z=5)
(1, 1, 0, 0, 5)
>>> fct(1, 1, z=5, y=32)
(1, 1, 0, 32, 5)
On peut toujours passer les arguments par nom dans un ordre arbitraire à partir du moment où on
précise leur nom. Par contre, si les deux arguments positionnels a et b ne sont pas passés à la
fonction, Python renvoie une erreur.
41
>>> fct(z=0)
TypeError: fct() missing 2 required positional arguments: 'a' and 'b'
Préciser le nom des arguments par nom lors de l'appel d'une fonction est une pratique que nous
vous recommandons. Cela les distingue clairement des arguments positionnels.
L'utilisation d'arguments par nom est habituelle en Python. Elle permet de modifier le
comportement par défaut de nombreuses fonctions. Par exemple, si on souhaite que la fonction
print() n'affiche pas un retour à la ligne, on peut utiliser l'argument end :
>>> print("Message ", end="")
Message >>>
6. Variables locales et variables globales

Lorsqu'on manipule des fonctions, il est essentiel de bien comprendre comment se comportent les
variables. Une variable est dite locale lorsqu'elle est créée dans une fonction. Elle n'existera et ne
sera visible que lors de l'exécution de ladite fonction.
Une variable est dite globale lorsqu'elle est créée dans le programme principal. Elle sera visible
partout dans le programme.
Exemple :
# définition d'une fonction carre()
def carre(x):
y = x**2
return y
# programme principal
z = 5
resultat = carre(z)
print(resultat)
42

Cours de Programmation Python (2022 - 2023)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours de Programmation Python (2022 - 2023)

Transféré par

Droits d'auteur :

Formats disponibles

2022/2023

INITIATION PROGRAMMATION PYTHON

2. Conseils pour installer et configurer Python

3. Vérifier l’installation de Python

Servons-nous de l'interpréteur comme d'une calculatrice :

Lignes 2 et 3 : L'interpréteur nous a permis de connaître le contenu de la variable juste en tapant

Enfin, dans l'instruction x = y - 3, l'opération y - 3 est d'abord évaluée et ensuite le résultat

2. Les types de variables

L'opérateur puissance utilise les symboles ** :

ii. Opérations sur les chaînes de caractères

iii. Opérations illicites

vi. Note sur la division de deux nombres entiers

vii. Note sur le vocabulaire et la syntaxe

Les instructions de base

Les principales instructions composées sont l’instruction conditionnelle if (SI en algorithmique),

ii. Écriture formatée

3. Opération sur les listes

puis avec la méthode .append() :

Dans ce cas, on utilise plutôt animaux[0].

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

9. Minimum, maximum et somme d'une liste¶

ii. Affectation multiple et le nom de variable _

ii. Itération sur les clés pour obtenir les valeurs

>>> ani2 = {'nom': 'singe', 'poids': 70, 'taille': 1.75}

iv. Existence d'une clé ou d'une valeur

Remarques concernant ces deux exemples :

2. Tests à plusieurs cas

5. Instructions break et continue

ii. Fonction range()

iii. Itération sur les indices ou les éléments

La variable i prendra les valeurs successives 0, 1, 2 et 3 et on accèdera à chaque élément de la

Ensuite, testez le code suivant dans l'interpréteur Python :

>>> fic = open("zoo.txt", "r")

Commentaires sur cet exemple :

En cinq lignes de code, on a lu, parcouru le fichier et affiché son contenu.

>>> with open("zoo.txt", 'r') as fich:

iii. Méthode .readline()

iv. Itération directe sur le fichier

v. Écriture dans un fichier

Quelques commentaires sur cet exemple :

Ligne 1 : Création d'une liste de chaînes de caractères animaux2.

vi. Ouvrir deux fichiers avec l'instruction with

alors le contenu de zoo2.txt sera :

Ce que fait cet exemple :

nous vous conseillons de charger le module seul de la manière suivante :

puis d'appeler explicitement les fonctions voulues, par exemple :

3. Quelques modules courants

• math : fonctions et constantes mathématiques de base (sin, cos, exp, pi...).

Par exemple, si vous appelez la fonction len() de la manière suivante :

voici ce qui se passe :

1. Vous passez l'entier 5 en argument ;

>>> res = carre(2)

Il est bien sûr possible de passer plusieurs arguments par mot-clé :

6. Variables locales et variables globales

Vous aimerez peut-être aussi