Table des matières
1 Introduction 11
1.1 Quelques mots sur l’origine de ce cours . . . 11
1.2 Remerciements 11
1.3 Avant de commencer . . . . . 12
1.4 C’est quoi Python? . . . . . . 12
1.5 Premier contact avec Python sous Linux . . 13
1.6 Premier programme Python . 14
1.6.1 Appel de l’interpréteur 14
1.6.2 Appel direct du script 14
1.7 Commentaires . 15
1.8 Notion de bloc d’instructions et d’indentation . . . . . . . 15
1.9 Python 2 ou Python 3? . . . 16
2 Variables 17
2.1 Définition d’une variable . . . 17
2.2 Les types de variables . . . . 18
2.3 Nommage des variables . . . 18
2.4 Opérations . . 18
2.4.1 Opérations sur les types numériques 18
2.4.2 Opérations sur les chaînes de caractères . . . . . . 19
2.4.3 Opérations illicites . . 19
2.5 La fonction type() . . . . . . 20
2.6 Conversion de types . . . . . 20
2.7 Note sur la division . . . . . . 20
2.8 Note sur le vocabulaire et la syntaxe . . . . 21
3 Affichage 23
3.1 Écriture formatée . . . . . . . 23
3.2 Ancienne méthode de formatage des chaînes de caractères 26
3.3 Note sur le vocabulaire et la syntaxe . . . . 27
3.4 Exercices . . . 27
3.4.1 Affichage dans l’interpréteur et dans un programme . . . . . . . 27
3.4.2 Poly-A . 27
3.4.3 Poly-A et poly-GC . . 27
3.4.4 Écriture formatée . . . 27
3.4.5 Écriture formatée 2 . . 28
4 Listes 29
4.1 Définition . . . 29
4.2 Utilisation . . . 29
4.3 Opération sur les listes . . . . 30
4.4 Indiçage négatif 31
3
4.5 Tranches . . . . 31
4.6 Fonction len() . 32
4.7 Les fonctions range() et list() 32
4.8 Listes de listes 33
4.9 Exercices . . . 33
4.9.1 Jours de la semaine . 34
4.9.2 Saisons 34
4.9.3 Table des 9 . . . . . . 34
4.9.4 Nombres pairs . . . . 34
5 Boucles et comparaisons 35
5.1 Boucles for . . 35
5.1.1 Principe 35
5.1.2 Fonction range() . . . 37
5.1.3 Nommage de la variable d’itération . 37
5.1.4 Itération sur les indices . . . . . . . 37
5.2 Comparaisons . 39
5.3 Boucles while . 40
5.4 Exercices . . . 40
5.4.1 Boucles de base . . . . 41
5.4.2 Boucle et jours de la semaine . . . . 41
5.4.3 Table des 1 . . . . . . 41
5.4.4 Nombres pairs et impairs . . . . . . 41
5.4.5 Calcul de moyenne . . 41
5.4.6 Produit de nombres consécutifs . . . 41
5.4.7 Triangle 41
5.4.8 Triangle inversé . . . . 42
5.4.9 Triangle gauche . . . . 42
5.4.10 Triangle isocèle . . . . 42
5.4.11 Parcours de matrice . 43
5.4.12 Parcours de demi-matrice sans la diagonale (exercice ++) . . . . 43
5.4.13 Sauts de puce . . . . . 44
5.4.14 Suite de Fibonacci (exercice +++) . 44
6 Tests 47
6.1 Définition . . . 47
6.2 Tests à plusieurs cas . . . . . 47
6.3 Tests multiples 49
6.4 Instructions break et continue 50
6.5 Tests de valeur sur des réels . 50
6.6 Exercices . . . 51
6.6.1 Jours de la semaine . 51
6.6.2 Séquence complémentaire d’un brin d’ADN . . . . 51
6.6.3 Minimum d’une liste . 51
6.6.4 Fréquence des acides aminés . . . . . 51
6.6.5 Notes et mention d’un étudiant . . . 52
6.6.6 Nombres pairs . . . . 52
6.6.7 L’énigme du père Fouras . . . . . . . 52
6.6.8 Conjecture de Syracuse (exercice +++) . . . . . . 52
6.6.9 Attribution simple de la structure secondaire des résidus d’une protéine (exercice +++) . 53
6.6.10 Détermination des nombres premiers inférieurs à 100 (exercice +++) . . . . . 53
6.6.11 Recherche d’un nombre par dichotomie (exercice +++) . . . . . 54
7 Fichiers 57
7.1 Lecture dans un fichier . . . . 57
7.1.1 Méthode read() . . . . 58
7.1.2 Méthode readline() . . 58
7.1.3 Méthodes seek() et tell() . . . . . . . 59
7.1.4 Itérations directement sur le fichier . 59
7.2 Écriture dans un fichier . . . 60
7.3 Méthode optimisée d’ouverture et de fermeture de fichier . 60
7.4 Note sur les retours chariots sous Unix et sous Windows . 61
7.5 Importance des conversions de types avec les fichiers . . . 62
7.6 Exercices . . . 62
7.6.1 Lecture et saut de ligne . . . . . . . 62
7.6.2 Écriture et saut de ligne . . . . . . . 62
7.6.3 Structures secondaires 62
7.6.4 Spirale (exercice +++) . . . . . . . 62
8 Modules 65
8.1 Définition . . . 65
8.2 Importation de modules . . . 65
8.3 Obtenir de l’aide sur les modules importés . 66
8.4 Modules courants . . . . . . . 67
8.5 Module sys : passage d’arguments . . . . . . 68
8.6 Module os . . . 69
8.7 Exercices . . . 70
8.7.1 Racine carrée . . . . . 70
8.7.2 Cosinus 70
8.7.3 Liste de fichiers dans un répertoire . 70
8.7.4 Affichage temporisé . 70
8.7.5 Séquences aléatoires de chiffres . . . 70
8.7.6 Séquences aléatoires de bases . . . . 71
8.7.7 Jour de naissance . . . 71
8.7.8 Détermination du nombre pi par la méthode Monte Carlo (exercice +++) . . . 71
9 Fonctions 73
9.1 Principe et généralités . . . . 73
9.2 Définition . . . 74
9.3 Passage d’arguments . . . . . 75
9.4 Variables locales et variables globales . . . . 76
9.5 Exercices . . . 80
9.5.1 Fonctions et pythontutor . . . . . . 80
9.5.2 Fonction puissance . . 81
9.5.3 Fonction pyramide . . 81
9.5.4 Fonction nombre premier . . . . . . 81
9.5.5 Fonction complement 81
9.5.6 Fonction distance . . . 82
9.5.7 Fonctions distribution et stat . . . . 82
9.5.8 Fonction distance à l’origine . . . . . 82
9.5.9 Fonction aire sous la courbe (exercice +++) . . . 82
10 Plus sur les chaînes de caractères 85
10.1 Préambule . . . 85
10.2 Chaînes de caractères et listes 85
10.3 Caractères spéciaux . . . . . 86
10.4 Méthodes associées aux chaînes de caractères . . . . . . . 86
10.5 Extraction de valeurs numériques d’une chaîne de caractères . . . . . . . 88
10.6 Conversion d’une liste de chaînes de caractères en une chaîne de caractères . . . . . . 88
10.7 Exercices . . . 90
10.7.1 Parcours d’une liste de chaînes de caractères . . . 90
10.7.2 Fréquence des bases dans une séquence nucléique . 90
10.7.3 Conversion des acides aminés du code à trois lettres au code à une lettre . . . . 90
10.7.4 Distance de Hamming 91
10.7.5 Palindrome . . . . . . 91
10.7.6 Mot composable . . . 91
10.7.7 Alphabet et pangramme . . . . . . . 91
10.7.8 Affichage des carbones alpha d’une structure de protéine . . . . . 92
10.7.9 Calcul des distances entre les carbones alpha consécutifs d’une structure de protéine 92
11 Plus sur les listes 95
11.1 Propriétés des listes . . . . . 95
11.2 Test d’appartenance . . . . . 97
11.3 Copie de listes 97
11.4 Exercices . . . 99
11.4.1 Tri de liste . . . . . . 99
11.4.2 Séquence nucléique aléatoire . . . . . 99
11.4.3 Séquence nucléique complémentaire 99
11.4.4 Doublons . . . . . . . 100
11.4.5 Séquence nucléique aléatoire 2 . . . 100
11.4.6 Triangle de Pascal (Exercice +++) . 100
12 Plus sur les fonctions 101
12.1 Appel d’une fonction dans une fonction . . 101
12.2 Fonctions récursives . . . . . 102
12.3 Portée des variables . . . . . 103
12.4 Portée des listes 105
12.5 Règle LGI . . . 106
12.6 Recommandations . . . . . . 106
12.7 Exercices . . . 107
12.7.1 Prédire la sortie . . . 107
13 Dictionnaires et tuples 109
13.1 Dictionnaires . 109
13.1.1 Itération sur les clefs pour obtenir les valeurs . . . 109
13.1.2 Méthodes keys() et values() . . . . . 110
13.1.3 Existence d’une clef . 110
13.1.4 Liste de dictionnaires 110
13.2 Tuples . . . . . 111
13.3 Exercices . . . 112
13.3.1 Composition en acides aminés . . . . 112
13.3.2 Mots de 2 lettres . . . 112
13.3.3 Mots de 3 et 4 lettres 112
13.3.4 Mots de 2 lettres de Saccharomyces cerevisiae . . . 112
13.3.5 Mots de n lettres et fichiers genbank 112
13.3.6 Mots de n lettres du génome d’E. Coli . . . . . . . 112
13.3.7 Dictionnaire et carbone alpha . . . . 113
13.3.8 Dictionnaire et PDB . 113
13.3.9 Barycentre d’une protéine . . . . . . 113
14 Création de modules 115
14.1 Pourquoi créer ses propres modules? . . . . 115
14.2 Comment créer son propre module . . . . . 115
14.3 Utilisation de son propre module . . . . . . 116
14.4 Les docstrings . 116
14.5 Modules et fonctions . . . . . 117
14.6 Module ou script? . . . . . . 117
14.7 Exercices . . . 119
14.7.1 Module ADN . . . . . 119
15 Expressions régulières et parsing 121
15.1 Définition et syntaxe . . . . . 121
15.2 Module re et fonction search . 123
15.2.1 La fonction search() . 123
15.2.2 Les fonctions match() et fullmatch() 124
15.2.3 Compilation d’expressions régulières 124
15.2.4 Groupes 125
15.2.5 La fonction findall() . 125
15.2.6 La fonction sub() . . . 126
15.3 Exercices . . . 127
15.3.1 Regex de base . . . . . 127
15.3.2 Nettoyeur d’espaces . 127
15.3.3 Nettoyeur de doublons 127
15.3.4 Compteur de gènes . . 127
15.3.5 Recherche de séquence dans un fichier gbk . . . . . 127
15.3.6 Le défi du dé-htmliseur (+++) . . . 128
15.3.7 Remplacements puissants (+++) . . 128
16 Autres modules d’intérêt 129
17 Modules d’intérêt en bioinformatique 131
17.1 Module numpy 131
17.1.1 Objets de type array . 132
17.1.2 array et dimensions . 133
17.1.3 Indices . 135
17.1.4 Construction automatique de matrices . . . . . . . 135
17.1.5 Un peu d’algèbre linéaire . . . . . . 136
17.1.6 Un peu de transformée de Fourier . 137
17.2 Module biopython . . . . . . 138
17.3 Module matplotlib . . . . . . 139
17.3.1 Réprésentation sous forme de points 139
17.3.2 Réprésentation sous forme de courbe 141
17.3.3 Représentation sous forme de barres 142
17.4 Exercices . . . 143
17.4.1 Extraction des coordonnées atomiques . . . . . . . 143
17.4.2 Lecture des coordonnées . . . . . . . 144
17.4.3 Utilisation de numpy . 144
17.4.4 Calcul de la distance . 144
18 Jupyter et ses notebooks 145
18.1 Lancement de Jupyter et création d’un notebook . . . . . 145
18.2 Le format Markdown . . . . . 148
18.3 Des graphiques dans les notebooks . . . . . 150
18.4 Les magic commands . . . . . 151
19 Avoir la classe avec les objets 153
19.1 Construction d’une classe . . 153
19.2 Utilisation de la classe Rectangle . . . . . . 154
19.3 Modification du rectangle en carré . . . . . 154
19.4 Création d’un objet Rectangle avec des paramètres imposés . . . . . . . 154
19.5 Exercices . . . 154
19.5.1 Classe Rectangle . . . 154
19.5.2 Classe Atome . . . . . 155
19.5.3 Classe Atome améliorée . . . . . . . 155
20 Pour aller plus loin 157
20.1 Shebang et /usr/bin/env python3 . . . . . . 157
20.2 Différences Python 2 et Python 3 . . . . . . 157
20.2.1 Interpréteur par défaut . . . . . . . 157
20.2.2 La fonction print() . . 158
20.2.3 Division d’entiers . . . 158
20.2.4 La fonction range() . . 158
20.2.5 Encodage et utf-8 . . 159
20.3 Liste de compréhension . . . 160
20.3.1 Nombres pairs compris entre 0 et 30 160
20.3.2 Jeu sur la casse des mots d’une phrase . . . . . . . 160
20.3.3 Formatage d’une séquence avec 60 caractères par ligne . . . . . . 160
20.3.4 Formatage fasta d’une séquence (avec la ligne de commentaire) . 160
20.3.5 Sélection des carbones alpha dans un fichier pdb . 161
20.4 Gestion des erreurs . . . . . . 161
20.5 Sauvegardez votre historique de commandes 163
21 Mini-projets 165
21.1 Mots anglais dans le protéome humain . . . 165
21.1.1 Composition aminée . 165
21.1.2 Des mots . . . . . . . 165
21.1.3 Des protéines . . . . . 165
21.1.4 À la pêche aux mots . 166
21.1.5 Et le mot le plus fréquent est . . 166
21.1.6 Pour être plus complet 166
21.2 genbank2fasta . 167
21.2.1 genbank2fasta sans expression régulière . . . . . . 167
21.2.2 genbank2fasta avec expression régulière . . . . . . 170
22 Annexe : Quelques formats de données rencontrés en biologie 175
22.1 Fasta . . . . . . 175
22.1.1 Exemples . . . . . . . 175
22.1.2 Manipulation avec Python . . . . . . 176
22.2 GenBank . . . 177
22.2.1 L’en-tête . . . . . . . 177
22.2.2 Les features . . . . . . 178
22.2.3 La séquence . . . . . . 179
22.2.4 Manipulation avec Python . . . . . . 179
22.3 PDB . . . . . . 180
22.3.1 En-tête 180
22.3.2 Coordonnées . . . . . 181
22.3.3 Manipulation avec Python . . . . . . 184
Chapitre 1
Introduction
1.1 Quelques mots sur l’origine de ce cours
Ce cours a été conçu à l’origine pour les étudiants débutants en programmation Python des filières de biologie et de biochimie de l’Université Paris Diderot - Paris 7; et plus spécialement pour les étudiants du master Biologie Informatique.
Ce cours est basé sur la version 3 de Python, version recommandée par la communauté scientifique. Des références à l’ancienne version, Python 2, seront néanmoins régulièrement apportées.
Si vous relevez des erreurs à la lecture de ce document, merci de nous les signaler.
Le cours est disponible en version HTMLet PDF.
1.2 Remerciements
Un grand merci à Sanderdu Centre for Molecular and Biomolecular Informatic de Nijmegen aux Pays-Bas pour la toute première versionde ce cours qui remonte à l’année 2003.
Nous remercions le professeur Philip Guode l’UC San Diego, pour nous avoir autorisé à utiliser des clichés de son excellent site pythontutor.
Merci également à tous les contributeurs, occasionels ou réguliers : Jennifer Becq, Virginie Martiny,
Romain Laurent, Benoist Laurent, Benjamin Boyer, Hubert Santuz, Catherine Lesourd, Philippe Label, Rémi Cuchillo, Cédric Gageat, Philibert Malbranche, Mikaël Naveau, Amélie Bacle, Alexandra Moine-Franel.
Nous remercions aussi Denis Mestivier de qui nous nous sommes inspirés pour certains exercices.
Enfin, merci à vous tous, les curieux de Python, qui avez été nombreux à nous envoyer des retours sur ce cours, à nous suggérer des améliorations et à nous signaler des coquilles.
De nombreuses personnes nous ont aussi demandé les corrections des exercices. Nous ne les mettons pas sur le site afin d’éviter la tentation de les regarder trop vite, mais vous pouvez nous écrire et nous vous les enverrons.
1.3. Avant de commencer
1.3 Avant de commencer
Avant de débuter ce cours, voici quelques indications générales qui pourront vous servir pour la suite.
— Familiarisez-vous avec le site . Il contient énormément d’informations et de liens sur Python et vous permet en outre de le télécharger pour différentes plateformes (Linux, Mac, Windows). La page d’index des modulesest particulièrement utile.
— Pour aller plus loin avec Python, Gérard Swinnen a écrit un très bon livreen français intitulé Apprendre à programmer avec Python 3 et téléchargeable gratuitement. Les éditions Eyrolles proposent également la version papierde cet ouvrage.
— Ce cours est basé sur une utilisation de Python sous Linux mais il est parfaitement transposable aux systèmes d’exploitation Windows et Mac.
— L’apprentissage d’un langage informatique comme Python va nécessiter d’écrire des lignes de codes à l’aide d’un éditeur de texte. Si vous êtes débutants, nous vous conseillons vivement d’utiliser gedit ou geany, qui sont les plus proches des éditeurs que l’on peut trouver sous Windows (notepad). Des éditeurs comme emacs et vi sont très puissants mais nécessitent un apprentissage particulier.
1.4 C’est quoi Python?
Le langage de programmation Python a été créé en 1989 par Guido van Rossum, aux Pays-Bas. Le nom
Python vient d’un hommage à la série télévisée Monty Python’s Flying Circus dont G. van Rossum est fan. La première version publique de ce langage a été publiée en 1991.
La dernière version de Python est la version 3. Plus précisément, la version 3.7 a été publiée en juin
La Python Software Foundation est l’association qui organise le développement de Python et anime la communauté de développeurs et d’utilisateurs.
Ce langage de programmation présente de nombreuses caractéristiques intéressantes : - Il est multiplateforme. C’est-à-dire qu’il fonctionne sur de nombreux systèmes d’exploitation : Windows, Mac OS, Linux, Android, iOS, depuis les mini-ordinateurs Raspberry Pi jusqu’aux supercalculateurs. - Il est gratuit. Vous pouvez l’installer sur autant d’ordinateur que vous voulez. - C’est un langage de haut niveau. Il demande relativement peu de connaissance sur le fonctionnement d’un ordinateur pour être utilisé. - C’est un langage interprété. Le programme n’a pas besoin de compilé son programme pour pouvoir l’utiliser, contrairement à des langages comme le C ou le C++. - Il est orienté objet. C’est-à-dire qu’il est possible de créer en Python des entités qui ont un sens dans le monde réel (une cellule, une protéine, un atome) avec un certains nombres de fonctionnement et d’interaction. - Il relativement simple à prendre en main. - Enfin, il est très utilisé en bioinformatique et plus généralement en analyse de données.
Toutes ces caractéristiques font que Python est désormais enseigné dans de nombreuses formations, depuis l’enseignement secondaire jusqu’à l’enseignement supérieur.
1.5. Premier contact avec Python sous Linux Chapitre 1. Introduction
1.5 Premier contact avec Python sous Linux
Python est un langage interprété, c’est-à-dire que chaque ligne de code est lue puis interprétée afin d’être exécutée par l’ordinateur. Pour vous en rendre compte, lancez la commande :
Celle-ci va lancer l’interpréteur Python. Vous devriez obtenir quelque chose de ce style :
1 [email protected]:~$ python3
2 Python 3.5.2 (default, Nov 17 2016, 17:05:23)
3 [GCC 5.4.0 20160609] on linux
4 Type "help", "copyright", "credits" or "license" for more information.
5 >>>
Le bloc [email protected]:~$ représente l’invite de commande de votre shell sous Linux. Par la suite, cette invite de commande sera représentée simplement par le caractère $.
Le triple chevron >>> est l’invite de commande de Python (prompt en anglais), ce qui signifie que Python attend une commande. Tapez par exemple l’instruction puis validez votre commande en appuyant sur la touche Entrée.
Python a exécuté la commande directement et a affiché le texte Hello world!. Il attend ensuite votre prochaine instruction en affichant l’invite de l’interpréteur Python (>>>). En résumé, voici ce qui a du apparaître sur votre écran :
Vous pouvez refaire un nouvel essai en vous servant cette fois de l’interpréteur comme d’une calculatrice.
À ce stade, vous pouvez entrer une autre commande ou bien quitter l’interpréteur Python, soit en tapant la commande exit() puis en validant en appuyant sur la touche Entrée, soit en pressant simultanément les touches Ctrl et D.
Finalement l’interpréteur Python est un système interactif dans lequel vous pouvez entrer des commandes, que Python exécutera sous vos yeux (au moment où vous validerez la commande en tapant sur Entrée).
Il existe de nombreux autres langages interprétés tels que Perlou R. Le gros avantage est que l’on peut directement tester une commande à l’aide de l’interpréteur, ce qui est très utile pour débugger (c’est-à-dire corriger les éventuelles erreurs d’un programme). Gardez bien en mémoire cette propriété de Python qui pourra parfois vous faire gagner un temps précieux!
1.6. Premier programme Python
1.6 Premier programme Python
Bien sûr, l’interpréteur présente vite des limites dès lors que l’on veut exécuter une suite d’instructions plus complexe. Comme tout langage informatique, on peut enregistrer ces instructions dans un fichier, que l’on appelle communément un script Python.
Pour reprendre l’exemple précédent, ouvrez un éditeur de texte (par exemple gedit ou nedit) et entrez
le code suivant.
1 print('Hello World !')
Ensuite enregistrez votre fichier sous le nom , puis quittez l’éditeur de texte. L’extension standard des scripts Python est .py. Pour exécuter votre script, vous avez deux moyens.
1.6.1 Appel de l’interpréteur
Donnez le nom de votre script comme argument à la commande Python :
3 $
1.6.2 Appel direct du script
Pour appeler directement votre script Python, deux opérations sont nécessaires :
script :
Dans notre exemple, le script contient alors le texte suivant :
Pour exécuter votre script, tapez son nom précédé des deux caractères ./ (afin de préciser au shell où se trouve votre script) :
1.7. Commentaires Chapitre 1. Introduction
1.7 Commentaires
Dans un script, tout ce qui suit le caractère # est ignoré par Python jusqu’à la fin de la ligne et est considéré comme un commentaire. Une exception notable est la première ligne de votre script qui peut être
et qui a alors une signification particulière pour Python.
Les commentaires sont indispensables pour que vous puissiez annoter votre code. Il faut absolument les utiliser pour décrire les principales parties de votre code dans un langage humain.
1.8 Notion de bloc d’instructions et d’indentation
Pour terminer ce chapitre d’introduction, nous allons aborder dès maintenant les notions de bloc d’instructions et d’indentation.
En programmation, il est courant de répéter un certain nombre de choses (avec les boucles, voir chapitre 5) ou de faire des choix (avec les tests, voir chapitre 6).
Par exemple, imaginez que vous souhaitiez répéter 10 fois 3 instructions différentes, les unes à la suite des autres. Regardez l’exemple suivant en pseudo-code :
1instruction_qui_indique_à_Python_de_répéter_10_fois_ce_qui_suit:
2 sous_instruction1
3 sous_instruction2
4 sous_instruction3
5 instruction_suivante
La première ligne correspond à une instruction qui va indiquer à Python de répéter 10 fois d’autres instructions (il s’agit d’une boucle, on verra le nom de la commande exacte plus tard). Dans le pseudocode ci-dessus, il y a 3 instructions à répéter, nommées sous_instruction1 à sous_instruction3.
Notez bien les détails de la syntaxe. La première ligne indique que l’on veut répéter une ou plusieurs instructions, elle se termine par :. Ce symbole : indique à Python qu’il doit attendre un bloc d’instructions, c’est-à-dire un certains nombres de sous-instructions à répéter. Python reconnaît un bloc d’instructions car il est indenté. L’indentation est le décalage d’un ou plusieurs espaces ou tabulations des instructions sous_instruction1 à sous_instruction3, par rapport à instruction_qui_indique_à_Python_de_répéter_10_fois_ce_qui_suit:.
Pratiquement, l’indentation en Python doit être homogène (soit des espaces, soit des tabulations, mais pas un mélange des deux). Une indentation avec 4 espaces est le style d’indentation le plus traditionnel et celui qui permet une bonne lisibilité du code.
Enfin, la ligne instruction_suivante sera exécutée une fois que le bloc d’instructions sera terminé.
Si tout cela vous semble un peu fastidieux, ne vous inquiétez pas. Vous allez comprendre tous ces détails, et surtout les acquérir, en continuant ce cours chapitre par chapitre.
Cours de Python / Université Paris Diderot - Paris 7 / UFR Sciences du Vivant 15
1.9. Python 2 ou Python 3?
1.9 Python 2 ou Python 3?
Ce cours est basé sur la version 3 de Python, qui est maintenant devenu un standard. La plupart des projets importants ont migré vers Python 3. Par ailleurs Python 2 cessera d’être maintenu au delà de mi-202016. Python 3 est donc la version que nous vous recommandons fortement.
Si néanmoins, vous devez un jour travailler sur un ancien programme écrit en Python 2, sachez qu’il existe quelques différences importantes entre Python 2 et Python 3. Le chapitre 19 Pour aller plus loin vous donnera plus de précisions.
Chapitre 2
Variables
2.1 Définition d’une variable
Une variable est une zone de la mémoire dans laquelle une valeur est stockée. Aux yeux du programmeur, cette variable est définie par un nom, alors que pour l’ordinateur, il s’agit en fait d’une adresse (i.e. une zone particulière de la mémoire).
En Python, la déclaration d’une variable et son initialisation (c’est-à-dire la première valeur que l’on va stocker dedans) se font en même temps. Pour vous en convaincre, testez les instructions suivantes après avoir lancé l’interpréteur :
Dans cet exemple, nous avons déclaré, puis initialisé la variable x avec la valeur 2. Notez bien qu’en réalité, il s’est passé plusieurs choses :
— Python a deviné que la variable était un entier. On dit que Python est un langage au typage dynamique.
— Python a alloué (i.e. réservé) l’espace en mémoire pour y accueillir un entier (chaque type de variable prend plus ou moins d’espace en mémoire), et a fait en sorte qu’on puisse retrouver la variable sous le nom x
— Python a assigné la valeur 2 à la variable x.
Dans certains autres langages, il faut coder ces différentes étapes une par une (en C par exemple). Python étant un langage dit de haut niveau, la simple instruction x = 2 a suffi à réaliser les 3 étapes en une fois!
Ensuite, l’interpréteur nous a permis de connaître le contenu de la variable juste en tapant son nom. Retenez ceci car c’est une spécificité de l’interpréteur Python, très pratique pour chasser les erreurs (debugging) dans un programme. Par contre, la ligne d’un script Python qui contient seulement le nom d’une variable (sans aucune autre indication) n’affichera pas la valeur de la variable à l’écran (pour autant ceci reste valide et ne génèrera pas d’erreur).
Dernière chose, l’opérateur d’affectation = s’utilise dans un certain sens : par exemple x = 2 signifie qu’on attribue la valeur située à droite de l’opérateur = (2) à la variable située à gauche (x). Certains autres langages comme R utilise les symboles
Si on a x = y - 3, l’opération y - 3 est d’abord évaluée et ensuite le résultat de cette opération est affecté à la variable x.
17
2.2. Les types de variables
2.2 Les types de variables
Le type d’une variable correspond à la nature de celle-ci. Les trois types principaux dont nous aurons besoin dans un premier temps sont les entiers (integer ou int), les réels (float) et les chaînes de caractères (string ou str). Bien sûr, il existe de nombreux autres types (par exemple, les nombres complexes), c’est d’ailleurs un des gros avantages de Python (si vous n’êtes pas effrayés, vous pouvez vous en rendre compte ici1).
Dans l’exemple précédent, nous avons stocké un nombre entier (int) dans la variable x, mais il est tout a fait possible de stocker des nombres réels (float), des chaînes de caractères (string ou str) ou plein d’autres types de variables que nous verrons par la suite :
Vous remarquez que Python reconnaît certains types de variable automatiquement (entier, réel). Par contre, pour une chaîne de caractères, il faut l’entourer de guillemets (simples, doubles voire trois guillemets successifs simples ou doubles) afin d’indiquer à Python le début et la fin de la chaîne.
2.3 Nommage des variables
Le nom des variable en Python peut-être constitué de lettres minuscules (a à z), de lettres majuscules (A à Z), de nombres (0 à 9) ou du caractère souligné (_).
Néanmoins, un nom de variable ne doit pas débuter ni par un chiffre, ni par _ et ne peut pas contenir de caractère accentué. Il faut absolument éviter d’utiliser un mot “réservé” par Python comme nom de variable (par exemple : print, range, for, from, etc.).
Python est sensible à la casse, ce qui signifie que les variables TesT, test ou TEST sont différentes.
Enfin, vous ne pouvez pas utilisez d’espace dans un nom de variable.
2.4 Opérations
2.4.1 Opérations sur les types numériques
Les quatre opérations de base se font de manière simple sur les types numériques (nombres entiers et
Remarquez toutefois que si vous mélangez les types entiers et réels, le résultat est renvoyé comme un réel (car ce type est plus général). Par ailleurs, l’utilisation de parenthèses permet de gérer les priorités.
L’opérateur puissance utilise le symbole **. Pour obtenir le reste d’une division entière (voir ici2 pour un petit rappel sur la division entière), on utilise le symbole modulo % :
Les symboles +, -, *, /, ** et % sont appelés opérateurs, car ils permettent de faire des opérations sur les variables.
2.4.2 Opérations sur les chaînes de caractères
Pour les chaînes de caractères, deux opérations sont possibles, l’addition et la multiplication :
L’opérateur d’addition + permet de concaténer (assembler) deux chaînes de caractères et l’opérateur de multiplication * permet de dupliquer plusieurs fois une chaîne.
Attention : Vous voyez que les opérateurs + et * se comportent différemment selon s’il s’agit d’entiers ou de chaînes de caractères : 2 + 2 est un addition, '2' + '2' est une concaténation. On appelle ce comportement surcharge des opérateurs. Nous serons amenés à revoir cette notion dans le chapitre 18 sur les classes.
