Fuchs Poulain cours-python

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

Table des matières Table des matières
5 Boucles et comparaisons 28
5.1 Boucles for .................................................... 28
5.2 Comparaisons ................................................... 31
5.3 Boucles while .................................................. 31
5.4 Exercices ..................................................... 32
6 Tests 37
6.1 Définition ..................................................... 37
6.2 Tests à plusieurs cas ................................................ 37
6.3 Importance de l’indentation ............................................ 38
6.4 Tests multiples .................................................. 38
6.5 Instructions break et continue ......................................... 39
6.6 Tests de valeur sur des floats ........................................... 40
6.7 Exercices ..................................................... 40
7 Fichiers 45
7.1 Lecture dans un fichier .............................................. 45
7.2 Écriture dans un fichier .............................................. 47
7.3 Ouvrir deux fichiers avec l’instruction with ................................... 48
7.4 Note sur les retours à la ligne sous Unix et sous Windows ............................ 48
7.5 Importance des conversions de types avec les fichiers .............................. 49
7.6 Du respect des formats de données et de fichiers ................................. 49
7.7 Exercices ..................................................... 49
8 Modules 52
8.1 Définition ..................................................... 52
8.2 Importation de modules .............................................. 52
8.3 Obtenir de l’aide sur les modules importés .................................... 54
8.4 Quelques modules courants ............................................ 55
8.5 Module sys : passage d’arguments ........................................ 55
8.6 Module os : interaction avec le système d’exploitation .............................. 57
8.7 Exercices ..................................................... 57
9 Fonctions 60
9.1 Principe et généralités ............................................... 60
9.2 Définition ..................................................... 61
9.3 Passage d’arguments ............................................... 62
9.4 Renvoi de résultats ................................................ 62
9.5 Arguments positionnels et arguments par mot-clé ................................ 62
9.6 Variables locales et variables globales ...................................... 64
9.7 Exercices ..................................................... 67
10 Plus sur les chaînes de caractères 71
10.1 Préambule ..................................................... 71
10.2 Chaînes de caractères et listes ........................................... 71
10.3 Caractères spéciaux ................................................ 71
10.4 Méthodes associées aux chaînes de caractères .................................. 72
10.5 Extraction de valeurs numériques d’une chaîne de caractères .......................... 74
10.6 Conversion d’une liste de chaînes de caractères en une chaîne de caractères .................. 74
10.7 Exercices ..................................................... 75
Cours de Python / Université Paris Diderot - Paris 7 / UFR Sciences du Vivant 3

Table des matières Table des matières
11 Plus sur les listes 79
11.1 Méthodes associées aux listes ........................................... 79
11.2 Construction d’une liste par itération ....................................... 80
11.3 Test d’appartenance ................................................ 81
11.4 Copie de listes ................................................... 81
11.5 Exercices ..................................................... 83
12 Plus sur les fonctions 85
12.1 Appel d’une fonction dans une fonction ..................................... 85
12.2 Fonctions récursives ................................................ 86
12.3 Portée des variables ................................................ 87
12.4 Portée des listes .................................................. 88
12.5 Règle LGI ..................................................... 89
12.6 Recommandations ................................................. 89
12.7 Exercices ..................................................... 90
13 Dictionnaires et tuples 92
13.1 Dictionnaires ................................................... 92
13.2 Tuples ....................................................... 94
13.3 Exercices ..................................................... 94
14 Création de modules 97
14.1 Pourquoi créer ses propres modules? ....................................... 97
14.2 Création d’un module ............................................... 97
14.3 Utilisation de son propre module ......................................... 98
14.4 Les docstrings ................................................... 98
14.5 Visibilité des fonctions dans un module ..................................... 99
14.6 Module ou script? ................................................. 99
14.7 Exercice ...................................................... 100
15 Bonnes pratiques en programmation Python 101
15.1 De la bonne syntaxe avec la PEP 8 ........................................ 101
15.2 Les docstrings et la PEP 257 ........................................... 105
15.3 Outils de contrôle qualité du code ........................................ 107
15.4 Organisation du code ............................................... 109
15.5 Conseils sur la conception d’un script ...................................... 110
15.6 Pour terminer : la PEP 20 ............................................. 110
16 Expressions régulières et parsing 112
16.1 Définition et syntaxe ............................................... 112
16.2 Quelques ressources en ligne ........................................... 114
16.3 Le module re ................................................... 114
16.4 Exercices ..................................................... 116
17 Quelques modules d’intérêt en bioinformatique 119
17.1 Module NumPy .................................................. 119
17.2 Module Biopython ................................................ 124
17.3 Module matplotlib ................................................ 126
17.4 Module pandas .................................................. 130
17.5 Un exemple plus complet ............................................. 134
17.6 Exercices ..................................................... 139
4Cours de Python / Université Paris Diderot - Paris 7 / UFR Sciences du Vivant

Table des matières Table des matières
18 Jupyter et ses notebooks 142
18.1 Installation .................................................... 142
18.2 Lancement de Jupyter et création d’un notebook ................................. 142
18.3 Le format Markdown ............................................... 145
18.4 Des graphiques dans les notebooks ........................................ 147
18.5 Les magic commands ............................................... 150
18.6 JupyterLab .................................................... 150
19 Avoir la classe avec les objets 154
19.1 Construction d’une classe ............................................. 154
19.2 Espace de noms .................................................. 165
19.3 Polymorphisme .................................................. 168
19.4 Héritage ...................................................... 170
19.5 Accès et modifications des attributs depuis l’extérieur .............................. 175
19.6 Bonnes pratiques pour construire et manipuler ses classes ............................ 179
19.7 Exercices ..................................................... 183
20 Fenêtres graphiques et Tkinter 184
20.1 Utilité d’une GUI ................................................. 184
20.2 Quelques concepts liés à la programmation graphique .............................. 185
20.3 Notion de fonction callback ............................................ 185
20.4 Prise en main du module Tkinter ......................................... 187
20.5 Construire une application Tkinter avec une classe ................................ 188
20.6 Le widget canvas ................................................. 189
20.7 Pour aller plus loin ................................................ 194
20.8 Exercices ..................................................... 199
21 Remarques complémentaires 202
21.1 Différences Python 2 et Python 3 ......................................... 202
21.2 Liste de compréhension .............................................. 204
21.3 Gestion des exceptions .............................................. 204
21.4 Shebang et /usr/bin/env python3 ......................................... 207
21.5 Passage d’arguments avec *args et **kwargs ................................. 208
21.6 Un peu de transformée de Fourier avec NumPy ................................. 210
21.7 Sauvegardez votre historique de commandes ................................... 210
22 Mini-projets 211
22.1 Description des projets .............................................. 211
22.2 Accompagnement pas à pas ............................................ 212
22.3 Scripts de correction ............................................... 226
A Quelques formats de données rencontrés en biologie 227
A.1 FASTA ...................................................... 227
A.2 GenBank ..................................................... 229
A.3 PDB ........................................................ 230
A.4 Format XML, CSV et TSV ............................................ 236
B Installation de Python 241
B.1 Que recommande-t-on pour l’installation de Python ? .............................. 241
B.2 Installation de Python avec Miniconda ...................................... 241
B.3 Utilisation de conda pour installer des modules complémentaires ........................ 251
B.4 Choisir un bon éditeur de texte .......................................... 254
B.5 Comment se mettre dans le bon répertoire dans le shell ............................. 256
B.6 Python web et mobile ............................................... 258
Cours de Python / Université Paris Diderot - Paris 7 / UFR Sciences du Vivant 5