courspython 1

Matthieu Boileau & Vincent Legoll
Apprendre
Python
pour les sciences
CNRS - Université de Strasbourg

2

Table des matières
1 Généralités 7
1.1 Programme du cours ......................................... 7
1.1.1 Généralités .......................................... 7
1.1.2 Variables et types de données ................................ 7
1.1.3 Opérations, contrôle, fonctions et modules ......................... 7
1.1.4 Numpy ............................................ 8
1.1.5 Microprojet .......................................... 8
1.1.6 Introduction à Pandas .................................... 8
1.2 Prise en main des notebooks ..................................... 8
1.2.1 Les deux modes du notebook : ............................... 8
1.2.2 Changement de mode .................................... 8
1.2.3 Mode Commande ....................................... 8
1.2.4 Mode Edition ......................................... 8
1.2.5 Autres commandes utiles .................................. 9
1.3 Le langage Python .......................................... 9
1.3.1 Historique ........................................... 9
1.3.2 Un langage en forte croissance ............................... 10
1.4 Qu’est-ce qu’un langage interprété ? ................................ 10
1.5 Quelques interpréteurs Python ................................... 11
1.6 Exécution d’un programme Python ................................. 11
1.6.1 Dans la console Python interactive ............................. 11
1.6.2 Depuis la console système .................................. 12
1.6.3 Dans la console iPython ................................... 12
1.6.4 Au sein d’un notebook Jupyter ............................... 13
1.6.5 Utilisation d’un IDE (Environnement de développement intégré) ............ 13
1.6.6 Pourquoi un IDE ? ...................................... 14
1.7 Applications du langage Python ................................... 14
1.7.1 Grand public ......................................... 14
1.7.2 Mais aussi ........................................... 14
1.7.3 Intérêt pour les sciences ................................... 14
1.7.4 Le Python scientique .................................... 15
1.7.5 Les principaux paquets dédiés au Python scientique : .................. 15
1.7.6 Python plutôt que Matlab ? ................................. 15
1.8 Documentation et sources ...................................... 15
1.8.1 La documentation ...................................... 15
1.8.2 Les sources de ce support .................................. 16
2 Variables et types de données 17
2.1 Langage python et sa syntaxe .................................... 17
2.1.1 Variables et aectation .................................... 17
2.1.2 Le mécanisme d’aectation en détail ............................ 18
2.1.3 Accéder à la valeur d’une variable ............................. 18
3

4TABLE DES MATIÈRES
2.1.4 L’aectation du point de vue de l’objet .......................... 18
2.1.5 Le type ............................................ 19
2.2 Types de données ........................................... 20
2.3 Types de base ............................................. 21
2.3.1 None .............................................. 21
2.3.2 Booléens ............................................ 21
2.3.3 Numériques .......................................... 22
2.4 Séquences ............................................... 25
2.4.1 Chaînes de caractères .................................... 25
2.4.2 Listes ............................................. 31
2.4.3 Tuples ............................................. 36
2.4.4 Types muables et types immuables ............................. 38
2.4.5 Le slicing de séquences en Python ............................. 40
2.5 Chaînes de caractères, le retour ................................... 43
2.6 Les dictionnaires ........................................... 45
2.6.1 Un exemple .......................................... 45
2.6.2 Un autre exemple ....................................... 46
2.7 Les ensembles ............................................. 48
2.7.1 Exemples ........................................... 48
2.8 Fichiers ................................................ 49
2.8.1 Ouverture ........................................... 49
2.8.2 Fermeture ........................................... 49
2.8.3 Méthodes de lecture ..................................... 49
2.8.4 Méthodes d’écriture ..................................... 50
3 Opérations, contrôle, fonctions et modules 53
3.1 Opérateurs .............................................. 53
3.1.1 Arithmétiques ........................................ 53
3.1.2 Logiques ............................................ 54
3.1.3 Comparaison ......................................... 55
3.1.4 bits à bits (bitwise) ...................................... 56
3.1.5 Aectation augmentée .................................... 57
3.1.6 Compatibilité de type, coercition de type ......................... 58
3.1.7 Priorité des opérateurs .................................... 58
3.2 Structures de contrôle ........................................ 59
3.2.1 La mise en page comme syntaxe .............................. 59
3.2.2 pass .............................................. 59
3.2.3 Tests conditionnels ...................................... 60
3.3 Boucles ................................................ 61
3.3.1 Boucle while ......................................... 61
3.3.2 Boucle for .......................................... 61
3.3.3 Instruction break ....................................... 63
3.3.4 Instruction continue .................................... 63
3.4 Fonctions ............................................... 64
3.4.1 Fonctions sans arguments .................................. 64
3.4.2 Fonctions avec arguments .................................. 65
3.4.3 Espace de nommage et portée des variables ........................ 69
3.4.4 Fonctions built-in ....................................... 70
3.4.5 Exercices sur les fonctions .................................. 72
3.5 Exceptions .............................................. 73
3.5.1 Exercice ............................................ 74
3.6 Les gestionnaires de contexte .................................... 75
3.7 Les compréhensions de listes ..................................... 76
3.8 Les expressions génératrices ..................................... 76

TABLE DES MATIÈRES 5
3.9 Modules ................................................ 77
3.9.1 Créer ses propres modules .................................. 77
3.9.2 Imports relatifs ........................................ 80
3.9.3 Exercice ............................................ 80
3.9.4 Quelques modules de la stdlib ................................ 81
3.10 Bonnes pratiques ........................................... 82
3.10.1 Commentez votre code .................................... 82
3.10.2 Documentez en utilisant les docstrings ........................... 82
3.10.3 Utilisez les annotations de type ............................... 82
3.10.4 Conventions d’écriture .................................... 83
3.10.5 Organisez votre code source ................................. 83
3.11 Utiliser les environnements de développement intégrés : ..................... 83
3.11.1 Utilisez un gestionnaires de versions ............................ 84
3.11.2 Héberger vos dépôts de sources ............................... 84
3.11.3 Véricateurs de code source ................................. 84
3.11.4 Tests en Python ....................................... 84
3.11.5 Environnements virtuels ................................... 85
3.12 Philosophie du langage : le zen de Python ............................. 85
3.13 Python 3.x vs 2.x ........................................... 86
3.13.1 Diérences notables entre Python 2 et Python 3 ..................... 86
3.14 Exercice de synthèse : décodage de l’ARN ............................. 86
3.14.1 Enoncé ............................................ 86
3.14.2 Consignes ........................................... 86
3.14.3 Solution complète ...................................... 87
3.15 Exercices complémentaires ...................................... 87
3.15.1 Chaines de caractères .................................... 87
3.15.2 Récursion ........................................... 88
4 Une introduction à Numpy 91
4.1 Numpy ................................................. 91
4.2 Démarrer avec Numpy ........................................ 92
4.3 Tableaux Numpy ........................................... 92
4.3.1 Une question de performance ................................ 92
4.3.2 La diérence avec les listes ................................. 92
4.3.3 Propriétés ........................................... 93
4.4 Création de tableaux Numpy .................................... 93
4.4.1 Avec des valeur constantes .................................. 93
4.4.2 Création à partir d’une séquence .............................. 94
4.4.3 Exercice : créer les tableaux suivants ............................ 94
4.4.4 Création de tableaux à partir de chiers .......................... 95
4.4.5 Format HDF5 avec H5py .................................. 96
4.5 Opérations basiques sur les tableaux ................................ 96
4.6 Indexation et slicing ......................................... 97
4.6.1 Indexation ........................................... 97
4.6.2 Slicing ............................................. 97
4.6.3 Exercice ............................................ 98
4.7 Quelques opérations d’algèbre linéaire ...............................100
4.8 Les méthodes associées aux tableaux ................................101
4.9 Programmation avec Numpy ....................................102
4.10 Références ...............................................102