cours-python

Cours de Python
Introduction à la programmation Python pour la biologie
https://python.sdv.u-paris.fr/
Patrick Fuchs et Pierre Poulain
prénom [point] nom [arobase] u-paris [point] fr
version du 29 septembre 2025
Université Paris Cité, France
Ce document est sous licence
Creative Commons Attribution - Partage dans les Mêmes Conditions 3.0 France
(CC BY-SA 3.0 FR)
https://creativecommons.org/licenses/by-sa/3.0/fr/

Table des matières
Avant-propos 8
Quelques mots sur l’origine de ce cours ....................................... 8
Remerciements ................................................... 8
Le livre ........................................................ 8
1 Introduction 10
1.1 Qu’est-ce que Python ? ............................................ 10
1.2 Conseils pour l’apprentissage de Python ................................... 11
1.3 Conseils pour installer et congurer Python ................................. 11
1.4 Notations utilisées ............................................... 11
1.5 Introduction au shell ............................................. 12
1.6 Premier contact avec Python ......................................... 12
1.7 Premier programme .............................................. 13
1.8 Commentaires ................................................. 14
1.9 Notion de bloc d’instructions et d’indentation ................................ 14
1.10 Autres ressources ............................................... 15
2 Variables 16
2.1 Dénition et création ............................................. 16
2.2 Les types de variables ............................................. 17
2.3 Nommage ................................................... 18
2.4 Écriture scientique .............................................. 18
2.5 Opérations ................................................... 19
2.6 La fonction type() ............................................. 21
2.7 Conversion de types .............................................. 21
2.8 Note sur le vocabulaire et la syntaxe ..................................... 22
2.9 Minimum et maximum ............................................ 22
2.10 Exercices .................................................... 22
3 Achage 24
3.1 La fonction print() ............................................. 24
3.2 Messages d’erreur ............................................... 25
3.3 Écriture formatée et f-strings ......................................... 26
2

Table des matières Table des matières
3.4 Écriture scientique .............................................. 30
3.5 Exercices .................................................... 30
4 Listes 32
4.1 Dénition ................................................... 32
4.2 Utilisation ................................................... 32
4.3 Opération sur les listes ............................................ 33
4.4 Indiçage négatif ................................................ 34
4.5 Tranches .................................................... 34
4.6 Fonction len() ................................................ 35
4.7 Les fonctions range() et list() ..................................... 35
4.8 Listes de listes ................................................. 36
4.9 Minimum, maximum et somme d’une liste .................................. 36
4.10 Problème avec les copies de listes ....................................... 36
4.11 Note sur le vocabulaire et la syntaxe ..................................... 37
4.12 Exercices .................................................... 37
5 Boucles et comparaisons 39
5.1 Boucles for .................................................. 39
5.2 Comparaisons ................................................. 42
5.3 Boucles while ................................................ 43
5.4 Exercices .................................................... 44
6 Tests 49
6.1 Dénition ................................................... 49
6.2 Tests à plusieurs cas .............................................. 49
6.3 Importance de l’indentation .......................................... 50
6.4 Tests multiples ................................................. 51
6.5 Instructions break et continue ...................................... 52
6.6 Tests de valeur sur des oats ......................................... 52
6.7 Exercices .................................................... 53
7 Fichiers 58
7.1 Lecture dans un chier ............................................ 58
7.2 Écriture dans un chier ............................................ 61
7.3 Ouvrir deux chiers avec l’instruction with ................................. 62
7.4 Note sur les retours à la ligne sous Unix et sous Windows .......................... 62
7.5 Importance des conversions de types avec les chiers ............................ 63
7.6 Du respect des formats de données et de chiers ............................... 63
7.7 Exercices .................................................... 63
8 Dictionnaires et tuples 66
8.1 Dictionnaires .................................................. 66
8.2 Tuples ..................................................... 70
8.3 Exercices .................................................... 73
9 Modules 76
9.1 Dénition ................................................... 76
9.2 Importation de modules ............................................ 76
9.3 Obtenir de l’aide sur les modules importés .................................. 78
9.4 Quelques modules courants .......................................... 79
9.5 Module random : génération de nombres aléatoires ............................. 80
9.6 Module sys : passage d’arguments ...................................... 81
9.7 Module pathlib : gestion des chiers et des répertoires ........................... 83
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 3

Table des matières Table des matières
9.8 Exercices .................................................... 84
10 Fonctions 88
10.1 Principe et généralités ............................................. 88
10.2 Dénition ................................................... 89
10.3 Passage d’arguments ............................................. 90
10.4 Renvoi de résultats .............................................. 90
10.5 Arguments positionnels et arguments par mot-clé .............................. 91
10.6 Variables locales et variables globales ..................................... 93
10.7 Principe DRY ................................................. 97
10.8 Exercices .................................................... 97
11 Plus sur les chaînes de caractères 102
11.1 Préambule ...................................................102
11.2 Chaînes de caractères et listes .........................................102
11.3 Caractères spéciaux ..............................................103
11.4 Préxe de chaîne de caractères ........................................103
11.5 Méthodes associées aux chaînes de caractères ................................105
11.6 Extraction de valeurs numériques d’une chaîne de caractères ........................107
11.7 Fonction map() ................................................107
11.8 Test d’appartenance ..............................................108
11.9 Conversion d’une liste de chaînes de caractères en une chaîne de caractères ................108
11.10Method chaining ...............................................109
11.11Exercices ....................................................110
12 Plus sur les listes 116
12.1 Méthodes associées aux listes .........................................116
12.2 Construction d’une liste par itération .....................................119
12.3 Test d’appartenance ..............................................119
12.4 Fonction zip() ................................................119
12.5 Copie de listes .................................................121
12.6 Initialisation d’une liste de listes .......................................122
12.7 Liste de compréhension ............................................123
12.8 Tris puissants de listes .............................................125
12.9 Exercices ....................................................126
13 Plus sur les fonctions 129
13.1 Appel d’une fonction dans une fonction ...................................129
13.2 Fonctions récursives ..............................................130
13.3 Portée des variables ..............................................132
13.4 Portée des listes ................................................133
13.5 Règle LGI ...................................................134
13.6 Recommandations ...............................................135
13.7 Exercices ....................................................136
14 Conteneurs 138
14.1 Généralités ...................................................138
14.2 Plus sur les dictionnaires ...........................................141
14.3 Plus sur les tuples ...............................................144
14.4 Sets et frozensets ...............................................148
14.5 Récapitulation des propriétés des conteneurs .................................151
14.6 Dictionnaires et sets de compréhension ....................................152
14.7 Module collections ...............................................153
14.8 Exercices ....................................................154
4Cours de Python / Université Paris Cité / UFR Sciences du Vivant

Table des matières Table des matières
15 Création de modules 158
15.1 Pourquoi créer ses propres modules ? .....................................158
15.2 Création d’un module .............................................158
15.3 Utilisation de son propre module .......................................159
15.4 Les docstrings .................................................159
15.5 Visibilité des fonctions dans un module ....................................160
15.6 Module ou script ? ...............................................161
15.7 Exercice ....................................................162
16 Bonnes pratiques en programmation Python 163
16.1 De la bonne syntaxe avec la PEP 8 ......................................164
16.2 Les docstrings et la PEP 257 .........................................168
16.3 Outils de contrôle qualité du code ......................................169
16.4 Outil de formatage automatique du code ...................................171
16.5 Organisation du code .............................................172
16.6 Conseils sur la conception d’un script .....................................173
16.7 Pour terminer : la PEP 20 ..........................................174
17 Expressions régulières et parsing 176
17.1 Dénition et syntaxe .............................................176
17.2 Quelques ressources en ligne .........................................178
17.3 Le module re ..................................................178
17.4 Exercices ....................................................181
18 Jupyter et ses notebooks 184
18.1 Installation ...................................................184
18.2 JupyterLab ...................................................184
18.3 Création d’un notebook ............................................185
18.4 Le format Markdown .............................................188
18.5 Des graphiques dans les notebooks ......................................188
18.6 Les magic commands .............................................189
18.7 Lancement d’une commande Unix ......................................191
19 Module Biopython 194
19.1 Installation et convention ...........................................194
19.2 Chargement du module ............................................194
19.3 Manipulation de séquences ..........................................195
19.4 Interrogation de la base de données PubMed .................................195
19.5 Exercices ....................................................198
20 Module NumPy 201
20.1 Installation et convention ...........................................201
20.2 Chargement du module ............................................201
20.3 Objets de type array ..............................................201
20.4 Construction automatique de matrices ....................................212
20.5 Chargement d’un array depuis un chier ...................................213
20.6 Concaténation d’arrays ............................................214
20.7 Un peu d’algèbre linéaire ...........................................215
20.8 Parcours de matrice et aectation de lignes et colonnes ...........................217
20.9 Masques booléens ...............................................218
20.10Quelques conseils ...............................................221
20.11Exercices ....................................................222
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 5