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 4 octobre 2024
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 Écriture formatée et f-strings ......................................... 25
3.3 Écriture scientique .............................................. 29
2

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

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

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