Cours de Python pour la biologie

Cours de Python
Introduction à la programmation Python pour la biologie
https://python.sdv.univ-paris-diderot.fr/
Patrick Fuchs et Pierre Poulain
prénom [point] nom [arobase] u-paris [point] fr
version du 29 août 2022
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 7
Quelques mots sur l’origine de ce cours ........................................ 7
Remerciements ..................................................... 7
Le livre ......................................................... 7
1 Introduction 9
1.1 C’est quoi Python? ................................................ 9
1.2 Conseils pour installer et configurer Python ................................... 9
1.3 Notations utilisées ................................................. 10
1.4 Introduction au shell ............................................... 10
1.5 Premier contact avec Python ........................................... 11
1.6 Premier programme ................................................ 12
1.7 Commentaires ................................................... 12
1.8 Notion de bloc d’instructions et d’indentation .................................. 13
1.9 Autres ressources ................................................. 13
2 Variables 14
2.1 Définition ..................................................... 14
2.2 Les types de variables ............................................... 14
2.3 Nommage ..................................................... 15
2.4 Écriture scientifique ................................................ 15
2.5 Opérations ..................................................... 16
2.6 La fonction type() ................................................ 17
2.7 Conversion de types ................................................ 17
2.8 Note sur la division de deux nombres entiers ................................... 18
2.9 Note sur le vocabulaire et la syntaxe ....................................... 18
2.10 Minimum et maximum .............................................. 18
2.11 Exercices ..................................................... 19
3 Affichage 20
3.1 La fonction print() ............................................... 20
3.2 Écriture formatée ................................................. 21
3.3 Écriture scientifique ................................................ 24
3.4 Ancienne méthode de formatage des chaînes de caractères ........................... 24
3.5 Note sur le vocabulaire et la syntaxe ....................................... 26
3.6 Exercices ..................................................... 26
4 Listes 28
4.1 Définition ..................................................... 28
4.2 Utilisation ..................................................... 28
4.3 Opération sur les listes .............................................. 28
4.4 Indiçage négatif .................................................. 29
4.5 Tranches ...................................................... 29
4.6 Fonction len() .................................................. 30
2

Table des matières Table des matières
4.7 Les fonctions range() et list() ........................................ 30
4.8 Listes de listes ................................................... 31
4.9 Minimum, maximum et somme d’une liste .................................... 31
4.10 Exercices ..................................................... 32
5 Boucles et comparaisons 33
5.1 Boucles for .................................................... 33
5.2 Comparaisons ................................................... 36
5.3 Boucles while .................................................. 36
5.4 Exercices ..................................................... 37
6 Tests 42
6.1 Définition ..................................................... 42
6.2 Tests à plusieurs cas ................................................ 42
6.3 Importance de l’indentation ............................................ 43
6.4 Tests multiples .................................................. 43
6.5 Instructions break et continue ......................................... 44
6.6 Tests de valeur sur des floats ........................................... 45
6.7 Exercices ..................................................... 45
7 Fichiers 50
7.1 Lecture dans un fichier .............................................. 50
7.2 Écriture dans un fichier .............................................. 52
7.3 Ouvrir deux fichiers avec l’instruction with ................................... 53
7.4 Note sur les retours à la ligne sous Unix et sous Windows ............................ 53
7.5 Importance des conversions de types avec les fichiers .............................. 54
7.6 Du respect des formats de données et de fichiers ................................. 54
7.7 Exercices ..................................................... 54
8 Modules 57
8.1 Définition ..................................................... 57
8.2 Importation de modules .............................................. 57
8.3 Obtenir de l’aide sur les modules importés .................................... 58
8.4 Quelques modules courants ............................................ 60
8.5 Module random : génération de nombres aléatoires ............................... 60
8.6 Module sys : passage d’arguments ........................................ 61
8.7 Module os : interaction avec le système d’exploitation .............................. 63
8.8 Exercices ..................................................... 63
9 Fonctions 66
9.1 Principe et généralités ............................................... 66
9.2 Définition ..................................................... 67
9.3 Passage d’arguments ............................................... 68
9.4 Renvoi de résultats ................................................ 68
9.5 Arguments positionnels et arguments par mot-clé ................................ 68
9.6 Variables locales et variables globales ...................................... 70
9.7 Principe DRY ................................................... 73
9.8 Exercices ..................................................... 74
10 Plus sur les chaînes de caractères 78
10.1 Préambule ..................................................... 78
10.2 Chaînes de caractères et listes ........................................... 78
10.3 Caractères spéciaux ................................................ 79
10.4 Préfixe de chaîne de caractères .......................................... 79
10.5 Méthodes associées aux chaînes de caractères .................................. 80
10.6 Extraction de valeurs numériques d’une chaîne de caractères .......................... 82
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 3

Table des matières Table des matières
10.7 Conversion d’une liste de chaînes de caractères en une chaîne de caractères .................. 82
10.8 Exercices ..................................................... 83
11 Plus sur les listes 88
11.1 Méthodes associées aux listes ........................................... 88
11.2 Construction d’une liste par itération ....................................... 90
11.3 Test d’appartenance ................................................ 91
11.4 Copie de listes ................................................... 91
11.5 Liste de compréhension .............................................. 92
11.6 Exercices ..................................................... 93
12 Plus sur les fonctions 96
12.1 Appel d’une fonction dans une fonction ..................................... 96
12.2 Fonctions récursives ................................................ 97
12.3 Portée des variables ................................................ 98
12.4 Portée des listes .................................................. 99
12.5 Règle LGI ..................................................... 100
12.6 Recommandations ................................................. 101
12.7 Exercices ..................................................... 102
13 Containers, dictionnaires, tuples et sets 104
13.1 Containers ..................................................... 104
13.2 Dictionnaires ................................................... 107
13.3 Tuples ....................................................... 111
13.4 Sets et frozensets ................................................. 116
13.5 Récapitulation des propriétés des containers ................................... 119
13.6 Dictionnaires et sets de compréhension ...................................... 119
13.7 Module collections ................................................ 120
13.8 Exercices ..................................................... 120
14 Création de modules 123
14.1 Pourquoi créer ses propres modules? ....................................... 123
14.2 Création d’un module ............................................... 123
14.3 Utilisation de son propre module ......................................... 124
14.4 Les docstrings ................................................... 124
14.5 Visibilité des fonctions dans un module ..................................... 125
14.6 Module ou script? ................................................. 125
14.7 Exercice ...................................................... 126
15 Bonnes pratiques en programmation Python 127
15.1 De la bonne syntaxe avec la PEP 8 ........................................ 127
15.2 Les docstrings et la PEP 257 ........................................... 131
15.3 Outils de contrôle qualité du code ........................................ 133
15.4 Organisation du code ............................................... 134
15.5 Conseils sur la conception d’un script ...................................... 136
15.6 Pour terminer : la PEP 20 ............................................. 136
16 Expressions régulières et parsing 138
16.1 Définition et syntaxe ............................................... 138
16.2 Quelques ressources en ligne ........................................... 140
16.3 Le module re ................................................... 140
16.4 Exercices ..................................................... 142
4Cours de Python / Université Paris Cité / UFR Sciences du Vivant

Table des matières Table des matières
17 Quelques modules d’intérêt en bioinformatique 145
17.1 Module NumPy .................................................. 145
17.2 Module Biopython ................................................ 157
17.3 Module matplotlib ................................................ 160
17.4 Module pandas .................................................. 164
17.5 Un exemple plus complet ............................................. 168
17.6 Exercices ..................................................... 174
18 Jupyter et ses notebooks 179
18.1 Installation .................................................... 179
18.2 Lancement de Jupyter et création d’un notebook ................................. 179
18.3 Le format Markdown ............................................... 182
18.4 Des graphiques dans les notebooks ........................................ 184
18.5 Les magic commands ............................................... 187
18.6 JupyterLab .................................................... 187
19 Avoir la classe avec les objets 191
19.1 Construction d’une classe ............................................. 191
19.2 Espace de noms .................................................. 202
19.3 Polymorphisme .................................................. 205
19.4 Héritage ...................................................... 207
19.5 Accès et modifications des attributs depuis l’extérieur .............................. 212
19.6 Bonnes pratiques pour construire et manipuler ses classes ............................ 216
19.7 Exercices ..................................................... 221
20 Fenêtres graphiques et Tkinter 222
20.1 Utilité d’une GUI ................................................. 222
20.2 Quelques concepts liés à la programmation graphique .............................. 223
20.3 Notion de fonction callback ............................................ 223
20.4 Prise en main du module Tkinter ......................................... 225
20.5 Construire une application Tkinter avec une classe ................................ 226
20.6 Le widget canvas ................................................. 227
20.7 Pour aller plus loin ................................................ 232
20.8 Exercices ..................................................... 237
21 Remarques complémentaires 240
21.1 Différences Python 2 et Python 3 ......................................... 240
21.2 Gestion des exceptions .............................................. 242
21.3 Shebang et /usr/bin/env python3 ......................................... 245
21.4 Passage d’arguments avec *args et **kwargs ................................. 245
21.5 Un peu de transformée de Fourier avec NumPy ................................. 247
21.6 Sauvegardez votre historique de commandes ................................... 247
22 Mini-projets 249
22.1 Description des projets .............................................. 249
22.2 Accompagnement pas à pas ............................................ 250
22.3 Scripts de correction ............................................... 264
A Quelques formats de données rencontrés en biologie 266
A.1 FASTA ...................................................... 266
A.2 GenBank ..................................................... 268
A.3 PDB ........................................................ 269
A.4 Format XML, CSV et TSV ............................................ 275
Cours de Python / Université Paris Cité / UFR Sciences du Vivant 5