Cours de Python - Introduction à la Programmation en Python pour la Biologie PDF

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...

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 configurer 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éfinition et création............................................. 16 2.2 Les types de variables............................................. 17 2.3 Nommage................................................... 18 2.4 Écriture scientifique.............................................. 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 Affichage 24 3.1 La fonction print()............................................. 24 3.2 Écriture formatée et f-strings......................................... 25 3.3 Écriture scientifique.............................................. 29 2 Table des matières Table des matières 3.4 Exercices.................................................... 29 4 Listes 31 4.1 Définition................................................... 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éfinition................................................... 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 floats......................................... 51 6.7 Exercices.................................................... 52 7 Fichiers 57 7.1 Lecture dans un fichier............................................ 57 7.2 Écriture dans un fichier............................................ 60 7.3 Ouvrir deux fichiers 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 fichiers............................ 62 7.6 Du respect des formats de données et de fichiers............................... 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éfinition................................................... 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 fichiers 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éfinition................................................... 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éfixe 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 4 Cours 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éfinition 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 fichier................................... 211 20.6 Concaténation d’arrays............................................ 212 20.7 Un peu d’algèbre linéaire........................................... 213 20.8 Parcours de matrice et affectation 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 Table des matières Table des matières 21 Module Matplotlib 224 21.1 Installation et convention........................................... 224 21.2 Chargement du module............................................ 224 21.3 Représentation en nuage de points...................................... 224 21.4 Représentation sous forme de courbe..................................... 226 21.5 Représentation en diagramme en bâtons................................... 229 22 Module Pandas 231 22.1 Installation et convention........................................... 231 22.2 Chargement du module............................................ 231 22.3 Series..................................................... 232 22.4 Dataframes.................................................. 233 22.5 Un exemple plus concret avec les kinases................................... 240 22.6 Exercices.................................................... 250 23 Avoir la classe avec les objets 251 23.1 Construction d’une classe........................................... 252 23.2 Exercices.................................................... 260 24 Avoir plus la classe avec les objets 261 24.1 Espace de noms................................................ 261 24.2 Polymorphisme................................................. 265 24.3 Héritage.................................................... 267 24.4 Composition.................................................. 274 24.5 Différence entre les attributs de classe et d’instance............................. 276 24.6 Accès et modifications des attributs depuis l’extérieur............................ 280 24.7 Bonnes pratiques pour construire et manipuler ses classes.......................... 287 24.8 Note finale de sémantique........................................... 293 24.9 Exercices.................................................... 294 25 Fenêtres graphiques et Tkinter 297 25.1 Utilité d’une GUI............................................... 297 25.2 Quelques concepts liés à la programmation graphique............................ 298 25.3 Notion de fonction callback.......................................... 299 25.4 Prise en main du module Tkinter....................................... 300 25.5 Construire une application Tkinter avec une classe............................. 302 25.6 Le widget canvas............................................... 303 25.7 Pour aller plus loin............................................... 309 25.8 Exercices.................................................... 314 26 Remarques complémentaires 317 26.1 Différences Python 2 et Python 3....................................... 317 26.2 Anciennes méthodes de formatage des chaînes de caractères........................ 319 26.3 Gestion des exceptions............................................ 321 26.4 Shebang et /usr/bin/env python3...................................... 324 26.5 Passage d’arguments avec *args et **kwargs.............................. 325 26.6 Décorateurs.................................................. 327 26.7 Un peu de transformée de Fourier avec NumPy............................... 330 26.8 Sauvegardez votre historique de commandes................................. 330 27 Mini-projets 332 27.1 Description des projets............................................ 332 27.2 Accompagnement pas à pas.......................................... 334 27.3 Scripts de correction.............................................. 348 6 Cours de Python / Université Paris Cité / UFR Sciences du Vivant Table des matières Table des matières A Quelques formats de données en biologie 349 A.1 FASTA..................................................... 349 A.2 GenBank.................................................... 351 A.3 PDB...................................................... 353 A.4 Format XML, CSV et TSV.......................................... 359 B Installation de Python 366 B.1 Que recommande-t-on pour l’installation de Python ?............................ 366 B.2 Installation de Python avec Miniconda.................................... 367 B.3 Utilisation de conda pour installer des modules complémentaires...................... 375 B.4 Choisir un bon éditeur de texte........................................ 379 B.5 Comment se mettre dans le bon répertoire dans le shell........................... 382 B.6 Python web et mobile............................................. 383 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 7  Avant-propos Quelques mots sur l’origine de ce cours Ce cours, développé par Patrick Fuchs et Pierre Poulain, 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, devenue Université Paris Cité 1 ; et plus spécialement pour les étudiants du master Biologie Informatique. Si vous relevez des erreurs à la lecture de ce document, merci de nous les signaler. Le cours est disponible en version HTML 2 et PDF 3. Remerciements Merci à tous les contributeurs, occasionnels ou réguliers, entre autre : Jennifer Becq, Benoist Laurent, Hubert Santuz, Virginie Martiny, Romain Laurent, Benjamin Boyer, Jonathan Barnoud, Amélie Bâcle, Thibault Tubiana, Romain Retu- reau, Catherine Lesourd, Philippe Label, Rémi Cuchillo, Cédric Gageat, Philibert Malbranche, Mikaël Naveau, Alexandra Moine-Franel, Dominique Tinel, et plus généralement les promotions des masters de biologie informatique et in silico drug design, ainsi que du diplôme universitaire en bioinformatique intégrative. Nous remercions tout particulièrement Sander Nabuurs pour la première version de ce cours remontant à 2003, Denis Mestivier pour les idées de certains exercices et Philip Guo pour son site Python Tutor 4. 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. Cela rend le cours vivant et dynamique, continuez comme ça ! 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. Le livre Ce cours est également publié aux éditions Dunod sous le titre « Programmation en Python pour les sciences de la vie 5 ». Le livre en est à sa 2e édition, vous pouvez vous le procurer dans toutes les bonnes librairies. Afin de promouvoir le partage des connaissances et le logiciel libre, nos droits d’auteurs provenant de la vente de cet ouvrage sont reversés à deux associations : Wikimédia France 6 qui s’occupe notamment de l’encyclopédie libre Wikipédia 1. https://www.u-paris.fr/ 2. https://python.sdv.u-paris.fr/index.html 3. https://python.sdv.u-paris.fr/cours-python.pdf 4. http://pythontutor.com/ 5. https://www.dunod.com/sciences-techniques/programmation-en-python-pour-sciences-vie-0 6. https://www.wikimedia.fr/ 8 Table des matières Table des matières Figure 1 – Couverture livre Dunod, 2e édition. et NumFOCUS 7 qui soutient le développement de logiciels libres scientifiques et notamment l’écosystème scientifique autour de Python. 7. https://numfocus.org/ Cours de Python / Université Paris Cité / UFR Sciences du Vivant 9  CHAPITRE 1 Introduction 1.1 Qu’est-ce que 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.11 a été publiée en octobre 2022. La version 2 de Python est obsolète et n’est plus maintenue, évitez de l’utiliser. La Python Software Foundation 1 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 X, Linux, Android, iOS, depuis les mini-ordinateurs Raspberry Pi jusqu’aux supercalculateurs. Il est gratuit. Vous pouvez l’installer sur autant d’ordinateurs que vous voulez (même sur votre téléphone !). 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é. Un script Python n’a pas besoin d’être compilé pour être exécuté, contrairement à des langages comme le C ou le C++. Il est orienté objet. C’est-à-dire qu’il est possible de concevoir en Python des entités qui miment celles du monde réel (une molécule d’ADN, une protéine, un atome, etc.) avec un certain nombre de règles de fonctionnement et d’interactions. Il est relativement simple à prendre en main 2. C’est le langage de programmation le plus utilisé au monde (voir les classements TIOBE 3 et IEEE Spectrum 4 ). Enfin, il est très utilisé en bioinformatique, chimie-informatique 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, du lycée à l’enseignement supérieur. 1. https://www.python.org/psf/ 2. Nous sommes d’accord, cette notion est très relative. 3. https://www.tiobe.com/tiobe-index/ 4. https://spectrum.ieee.org/the-top-programming-languages-2023 10 1.2. Conseils pour l’apprentissage de Python Chapitre 1. Introduction 1.2 Conseils pour l’apprentissage de Python Comme tout apprentissage, apprendre la programmation Python prend du temps et nécessite de pratiquer. Contrai- rement à d’autres activités scientifiques expérimentales (biologie moléculaire, chimie organique, électronique, etc.), pro- grammer en Python ne nécessite pas de matériel coûteux, juste un ordinateur et éventuellement une connexion internet. Par ailleurs, Python est un programme informatique qui par définition ne se fatigue pas, est patient et toujours disponible. N’hésitez donc pas à pratiquer, pratiquer et pratiquer encore. 1.3 Conseils pour installer et configurer Python Pour pratiquer la programmation Python, il est préférable que Python soit installé sur votre ordinateur. La bonne nouvelle est que vous pouvez installer gratuitement Python sur votre machine, que ce soit sous Windows, Mac OS X ou Linux. Nous donnons ici un résumé des points importants concernant cette installation. La marche à suivre pas-à-pas est détaillée à l’adresse https://python.sdv.u-paris.fr/ dans la rubrique B. Installation de Python. 1.3.1 Python 2 ou Python 3 ? Ce cours est basé sur la version 3 de Python, qui est désormais le standard. Si, néanmoins, vous deviez 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 26 Remarques complémentaires (en ligne) vous apportera plus de précisions. 1.3.2 Miniconda Nous vous conseillons d’installer Miniconda 5 , logiciel gratuit, disponible pour Windows, Mac OS X et Linux, et qui installera pour vous Python 3. Avec le gestionnaire de paquets conda, fourni avec Miniconda, vous pourrez installer des modules supplémentaires qui sont très utiles en bioinformatique (NumPy, scipy, matplotlib, pandas, Biopython), mais également Jupyter Lab qui vous permettra d’éditer des notebooks Jupyter. Vous trouverez en ligne 6 une documentation pas-à-pas pour installer Miniconda, Python 3 et les modules supplémentaires qui seront utilisés dans ce cours. 1.3.3 Éditeur de texte 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, on vous conseille d’utiliser notepad++ sous Windows, BBEdit ou CotEditor sous Mac OS X et gedit sous Linux. La configuration de ces éditeurs de texte est détaillée dans la rubrique Installation de Python disponible en ligne. Bien sûr, si vous préférez d’autres éditeurs comme Visual Studio Code, Sublime Text, emacs, vim, geany… utilisez-les ! À toute fin utile, on rappelle que les logiciels Microsoft Word, WordPad et LibreOffice Writer ne sont pas des éditeurs de texte, ce sont des traitements de texte qui ne peuvent pas et ne doivent pas être utilisés pour écrire du code informatique. 1.4 Notations utilisées Dans cet ouvrage, les commandes, les instructions Python, les résultats et les contenus de fichiers sont indiqués avec cette police pour les éléments ponctuels ou 1 sous cette forme, 2 sur plusieurs lignes, 3 pour les éléments les plus longs. Pour ces derniers, le numéro à gauche indique le numéro de la ligne et sera utilisé pour faire référence à une instruction particulière. Ce numéro n’est bien sûr là qu’à titre indicatif. Par ailleurs, dans le cas de programmes, de contenus de fichiers ou de résultats trop longs pour être inclus dans leur intégralité, la notation [...] indique une coupure arbitraire de plusieurs caractères ou lignes. 5. https://conda.io/miniconda.html 6. https://python.sdv.u-paris.fr/livre-dunod Cours de Python / Université Paris Cité / UFR Sciences du Vivant 11 Chapitre 1. Introduction 1.5. Introduction au shell 1.5 Introduction au shell Un shell est un interpréteur de commandes interactif permettant d’interagir avec l’ordinateur. On utilisera le shell pour lancer l’interpréteur Python. Pour approfondir la notion de shell, vous pouvez consulter les pages Wikipedia : du shell Unix 7 fonctionnant sous Mac OS X et Linux ; du shell PowerShell 8 fonctionnant sous Windows. Un shell possède toujours une invite de commande, c’est-à-dire un message qui s’affiche avant l’endroit où on entre des commandes. Dans tout cet ouvrage, cette invite est représentée par convention par le symbole dollar $ (qui n’a rien à avoir ici avec la monnaie), et ce quel que soit le système d’exploitation. Par exemple, si on vous demande de lancer l’instruction suivante : $ python il faudra taper seulement python sans le $ ni l’espace après le $. 1.6 Premier contact avec Python 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, ouvrez un shell puis lancez la commande : python La commande précédente va lancer l’interpréteur Python. Vous devriez obtenir quelque chose de ce style pour Windows : PS C:\Users\pierre>python Python 3.12.2 | packaged by Anaconda, Inc. | (main, Feb 27 2024, 17:28:07) [MSC v.1916 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> pour Mac OS X : iMac-de-pierre:Downloads$ python Python 3.12.2 | packaged by Anaconda, Inc. | (main, Feb 27 2024, 12:57:28) [Clang 14.0.6 ] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> ou pour Linux : pierre@jeera:~$ python Python 3.12.2 | packaged by conda-forge | (main, Feb 16 2024, 20:50:58) [GCC 12.3.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> Les blocs PS C:\Users\pierre> pour Windows, iMac-de-pierre:Downloads$ pour Mac OS X, pierre@jeera:~$ pour Linux. représentent l’invite de commande de votre shell. Il se peut que vous ayez aussi le mot (base) qui indique que vous avez un environnement conda activé. Par la suite, cette invite de commande sera représentée simplement par le caractère $, que vous soyez sous Windows, Mac OS X ou Linux. Le triple chevron >>> est l’invite de commande (prompt en anglais) de l’interpréteur Python. Ici, Python attend une commande que vous devez saisir au clavier. Tapez par exemple l’instruction : print("Hello world!") puis, validez cette 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 une nouvelle instruction en affichant l’invite de l’interpréteur Python (>>>). En résumé, voici ce qui a dû apparaître sur votre écran : 7. https://fr.wikipedia.org/wiki/Shell_Unix 8. https://fr.wikipedia.org/wiki/Windows_PowerShell 12 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 1.7. Premier programme Chapitre 1. Introduction 1 >>> print("Hello world!") 2 Hello world! 3 >>> Vous pouvez refaire un nouvel essai en vous servant cette fois de l’interpréteur comme d’une calculatrice : 1 >>> 1+1 2 2 3 >>> 6*3 4 18 À 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 sous Linux et Mac OS X ou Ctrl et Z puis Entrée sous Windows. En résumant, l’interpréteur fonctionne sur le modèle : 1 >>> instruction python 2 résultat où le triple chevron correspond à l’entrée (input) que l’utilisateur tape au clavier, et l’absence de chevron en début de ligne correspond à la sortie (output) générée par Python. Une exception se présente toutefois : lorsqu’on a une longue ligne de code, on peut la couper en deux avec le caractère \ (backslash) pour des raisons de lisibilité : 1 >>> Voici une longue ligne de code \ 2... décrite sur deux lignes 3 résultat En ligne 1 on a rentré la première partie de la ligne de code. On termine par un \, ainsi Python sait que la ligne de code n’est pas finie. L’interpréteur nous l’indique avec les trois points.... En ligne 2, on rentre la fin de la ligne de code puis on appuie sur Entrée. À ce moment, Python nous génère le résultat. Si la ligne de code est vraiment très longue, il est même possible de la découper en trois voire plus : 1 >>> Voici une ligne de code qui \ 2... est vraiment très longue car \ 3... elle est découpée sur trois lignes 4 résultat L’interpréteur Python est donc 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 appuyant sur la touche Entrée). Il existe de nombreux autres langages interprétés comme Perl 9 ou R 10. Le gros avantage de ce type de langage est qu’on peut immédiatement tester une commande à l’aide de l’interpréteur, ce qui est très utile pour débugger (c’est-à-dire trouver et 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.7 Premier programme 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 (ou programme) Python. Pour reprendre l’exemple précédent, ouvrez un éditeur de texte (pour choisir et configurer un éditeur de texte, reportez-vous si nécessaire à la rubrique Installation de Python en ligne 11 ) et entrez le code suivant : print("Hello world!") Ensuite, enregistrez votre fichier sous le nom test.py, puis quittez l’éditeur de texte. Remarque L’extension de fichier standard des scripts Python est.py. 9. http://www.perl.org 10. http://www.r-project.org 11. https://python.sdv.u-paris.fr/livre-dunod Cours de Python / Université Paris Cité / UFR Sciences du Vivant 13 Chapitre 1. Introduction 1.8. Commentaires Pour exécuter votre script, ouvrez un shell et entrez la commande : python test.py Vous devriez obtenir un résultat similaire à ceci : $ python test.py Hello world! Si c’est bien le cas, bravo ! Vous avez exécuté votre premier programme Python. 1.8 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. Les commentaires doivent expliquer votre code dans un langage humain. L’utilisation des commentaires est rediscutée dans le chapitre 16 Bonnes pratiques en programmation Python. Voici un exemple : 1 # Votre premier commentaire en Python. 2 print("Hello world!") 3 4 # D'autres commandes plus utiles pourraient suivre. Remarque On appelle souvent à tort le caractère # « dièse ». On devrait plutôt parler de « croisillon 12 ». 1.9 Notion 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 le chapitre 5 Boucles et comparaisons) ou d’exécuter plusieurs instructions si une condition est vraie (avec les tests, voir le chapitre 6 Tests). Par exemple, imaginons que nous souhaitions afficher chacune des bases d’une séquence d’ADN, les compter puis afficher le nombre total de bases à la fin. Nous pourrions utiliser l’algorithme présenté en pseudo-code dans la figure 1.1. Figure 1.1 – Notion d’indentation et de bloc d’instructions. Pour chaque base de la séquence ATCCGACTG, nous souhaitons effectuer deux actions : d’abord afficher la base puis compter une base de plus. Pour indiquer cela, on décalera vers la droite ces deux instructions par rapport à la ligne précédente (pour chaque base [...]). Ce décalage est appelé indentation et l’ensemble des lignes indentées constitue un bloc d’instructions. Une fois qu’on aura réalisé ces deux actions sur chaque base, on pourra passer à la suite, c’est-à-dire afficher la taille de la séquence. Pour bien préciser que cet affichage se fait à la fin, donc une fois l’affichage puis le comptage de chaque base terminés, la ligne correspondante n’est pas indentée (c’est-à-dire qu’elle n’est pas décalée vers la droite). 12. https://fr.wikipedia.org/wiki/Croisillon_(signe) 14 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 1.10. Autres ressources Chapitre 1. Introduction 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 recommandé (voir le chapitre 16 Bonnes pratiques en programmation Python). Si tout cela semble un peu complexe, ne vous inquiétez pas. Vous allez comprendre tous ces détails chapitre après chapitre. 1.10 Autres ressources Pour compléter votre apprentissage de Python, n’hésitez pas à consulter d’autres ressources complémentaires à cet ouvrage. D’autres auteurs abordent l’apprentissage de Python d’une autre manière. Nous vous conseillons les ressources suivantes en langue française : Le livre Apprendre à programmer avec Python 3 de Gérard Swinnen. Cet ouvrage est téléchargeable gratuitement sur le site de Gérard Swinnen 13. Les éditions Eyrolles proposent également la version papier de cet ouvrage. Le livre Apprendre à programmer en Python avec PyZo et Jupyter Notebook de Bob Cordeau et Laurent Pointal, publié aux éditions Dunod. Une partie de cet ouvrage est téléchargeable gratuitement sur le site de Laurent Pointal 14. Le livre Apprenez à programmer en Python de Vincent Legoff 15 que vous trouverez sur le site Openclassroms. Et pour terminer, une ressource incontournable en langue anglaise : Le site www.python.org 16. Il contient énormément d’informations et de liens sur Python. La page d’index des modules 17 est particulièrement utile (et traduite en français). 13. http://www.inforef.be/swi/python.htm 14. https://perso.limsi.fr/pointal/python:courspython3 15. https://openclassrooms.com/fr/courses/235344-apprenez-a-programmer-en-python 16. http://www.python.org 17. https://docs.python.org/fr/3/py-modindex.html Cours de Python / Université Paris Cité / UFR Sciences du Vivant 15  CHAPITRE 2 Variables 2.1 Définition et création Définition Une variable est une zone de la mémoire de l’ordinateur dans laquelle une valeur est stockée. Aux yeux du program- meur, cette variable est définie par un nom, alors que pour l’ordinateur, il s’agit en fait d’une adresse, c’est-à-dire d’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 : 1 >>> x = 2 2 >>> x 3 2 Ligne 1. 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é (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. Python a aussi fait en sorte qu’on puisse retrouver la variable sous le nom x. Enfin, Python a assigné la valeur 2 à la variable x. Dans d’autres langages (en C par exemple), il faut coder ces différentes étapes une par une. Python étant un langage dit de haut niveau, la simple instruction x = 2 a suffi à réaliser les trois étapes en une fois ! Lignes 2 et 3. 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 (debugger) les erreurs dans un programme. En revanche, 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 lors de l’exécution (pour autant, cette instruction reste valide et ne générera pas d’erreur). Depuis la version 3.10, l’interpréteur Python a amélioré ses messages d’erreur. Il est ainsi capable de suggérer des noms de variables existants lorsqu’on fait une faute de frappe : 16 2.2. Les types de variables Chapitre 2. Variables 1 >>> voyelles = "aeiouy" 2 >>> voyelle 3 Traceback (most recent call last): 4 File "", line 1, in 5 NameError: name 'voyelle' is not defined. Did you mean: 'voyelles'? Si le mot qu’on tape n’est pas très éloigné, cela fonctionne également lorsqu’on se trompe à différents endroits du mot ! 1 pharmacie = "vente de médicaments" 2 >>> farmacia 3 Traceback (most recent call last): 4 File "", line 1, in 5 NameError: name 'farmacia' is not defined. Did you mean: 'pharmacie'? Revenons sur le signe = ci-dessus. Définition Le symbole = est appelé opérateur d’affectation. Il permet d’assigner une valeur à une variable en Python. Cet opérateur s’utilise toujours de la droite vers la gauche. Par exemple, dans l’instruction x = 2 ci-dessus, Python attribue la valeur située à droite (ici, 2) à la variable située à gauche (ici, x). D’autres langages de programmation comme R utilisent les symboles > x = 2 2 >>> y = x 3 >>> y 4 2 5 >>> x = 5 - 2 6 >>> x 7 3 Ligne 2. Ici on a un nom de variable à gauche et à droite de l’opérateur =. Dans ce cas, on garde la règle d’aller toujours de la droite vers la gauche. C’est donc le contenu de la variable y qui est affecté à la variable x. Ligne 5. Comme on le verra plus bas, si on a à droite de l’opérateur = une expression, ici la soustraction 4 - 2, celle-ci est d’abord évaluée et c’est le résultat de cette opération qui sera affecté à la variable x. On pourra noter également que la valeur de x précédente (2) a été écrasée. Attention L’opérateur d’affectation = écrase systématiquement la valeur de la variable située à sa gauche si celle-ci existe déjà. 2.2 Les types de variables Définition Le type d’une variable correspond à la nature de celle-ci. Les trois principaux types dont nous aurons besoin dans un premier temps sont les entiers (integer ou int), les nombres décimaux que nous appellerons floats et les chaînes de caractères (string ou str). Bien sûr, il existe de nombreux autres types (par exemple, les booléens, les nombres complexes, etc.). Si vous n’êtes pas effrayés, vous pouvez vous en rendre compte ici 1. 1. https://docs.python.org/fr/3.12/library/stdtypes.html Cours de Python / Université Paris Cité / UFR Sciences du Vivant 17 Chapitre 2. Variables 2.3. Nommage Dans l’exemple précédent, nous avons stocké un nombre entier (int) dans la variable x, mais il est tout à fait possible de stocker des floats, des chaînes de caractères (string ou str) ou de nombreux autres types de variables que nous verrons par la suite : 1 >>> y = 3.14 2 >>> y 3 3.14 4 >>> a = "bonjour" 5 >>> a 6 'bonjour' 7 >>> b = 'salut' 8 >>> b 9 'salut' 10 >>> c = """girafe""" 11 >>> c 12 'girafe' 13 >>> d = '''lion''' 14 >>> d 15 'lion' Remarque Python reconnaît certains types de variables automatiquement (entier, float). Par contre, pour une chaîne de carac- tères, il faut l’entourer de guillemets (doubles, simples, voire trois guillemets successifs doubles ou simples) afin d’indiquer à Python le début et la fin de la chaîne de caractères. Dans l’interpréteur, l’affichage direct du contenu d’une chaîne de caractères se fait avec des guillemets simples, quel que soit le type de guillemets utilisé pour définir la chaîne de caractères. En Python, comme dans la plupart des langages de programmation, c’est le point qui est utilisé comme séparateur décimal. Ainsi, 3.14 est un nombre reconnu comme un float en Python alors que ce n’est pas le cas de 3,14. Il existe également des variables de type booléen. Un booléen 2 est une variable qui ne prend que deux valeurs : Vrai ou Faux. En python, on utilise pour cela les deux mots réservés True et False : 1 >>> var = True 2 >>> var2 = False 3 >>> var 4 True 5 >>> var2 6 False Nous verrons l’utilité des booléens dans les chapitres 5 Boucles et 6 Tests. 2.3 Nommage Le nom des variables en Python peut être constitué de lettres minuscules (a à z), de lettres majuscules (A à Z), de nombres (0 à 9) ou du caractère souligné (_). Vous ne pouvez pas utiliser d’espace dans un nom de variable. Par ailleurs, un nom de variable ne doit pas débuter par un chiffre et il n’est pas recommandé de le faire débuter par le caractère _ (sauf cas très particuliers). De plus, il faut absolument éviter d’utiliser un mot « réservé » par Python comme nom de variable (par exemple : print, range, for, from, etc.). Dans la mesure du possible, il est conseillé de mettre des noms de variables explicites. Sauf dans de rares cas que nous expliquerons plus tard dans le cours, évitez les noms de variables à une lettre. Enfin, Python est sensible à la casse, ce qui signifie que les variables TesT, test et TEST sont différentes. 2.4 Écriture scientifique On peut écrire des nombres très grands ou très petits avec des puissances de 10 en utilisant le symbole e : 2. https://fr.wikipedia.org/wiki/Bool%C3%A9en 18 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 2.5. Opérations Chapitre 2. Variables 1 >>> 1e6 2 1000000.0 3 >>> 3.12e-3 4 0.00312 On appelle cela écriture ou notation scientifique. On pourra noter deux choses importantes : 1e6 ou 3.12e-3 n’implique pas l’utilisation du nombre exponentiel e, mais signifie 1 × 106 ou 3.12 × 10−3 respec- tivement ; même si on ne met que des entiers à gauche et à droite du symbole e (comme dans 1e6), Python génère systéma- tiquement un float. Enfin, vous avez sans doute constaté qu’il est parfois pénible d’écrire des nombres composés de beaucoup de chiffres, par exemple le nombre d’Avogradro 6.02214076 × 1023 ou le nombre d’humains sur Terre 3 8094752749 au 5 mars 2024 à 19h34. Pour s’y retrouver, Python autorise l’utilisation du caractère « souligné » (ou underscore) _ pour séparer des groupes de chiffres. Par exemple : 1 >>> avogadro_number = 6.022_140_76e23 2 >>> print(avogadro_number) 3 6.02214076e+23 4 >>> humans_on_earth = 8_094_752_749 5 >>> print(humans_on_earth) 6 8094752749 Dans ces exemples, le caractère _ (underscore ou « souligné ») est utilisé pour séparer des groupes de trois chiffres, mais on peut faire ce qu’on veut : 1 >>> print(80_94_7527_49) 2 8094752749 2.5 Opérations 2.5.1 Opérations sur les types numériques Les quatre opérations arithmétiques de base se font de manière simple sur les types numériques (nombres entiers et floats) : 1 >>> x = 45 2 >>> x + 2 3 47 4 >>> x - 2 5 43 6 >>> x * 3 7 135 8 >>> y = 2.5 9 >>> x - y 10 42.5 11 >>> (x * 10) + y 12 452.5 Remarquez toutefois que si vous mélangez les types entiers et floats, le résultat est renvoyé comme un float (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 / effectue une division. Contrairement aux opérateurs +, - et *, celui-ci renvoie systématiquement un float : 1 >>> 3 / 4 2 0.75 3 >>> 2.5 / 2 4 1.25 5 >>> 6 / 3 6 2.0 7 >>> 10 / 2 8 5.0 3. https://thepopulationproject.org/ Cours de Python / Université Paris Cité / UFR Sciences du Vivant 19 Chapitre 2. Variables 2.5. Opérations L’opérateur puissance utilise les symboles ** : 1 >>> 2**3 2 8 3 >>> 2**4 4 16 Pour obtenir le quotient et le reste d’une division entière (voir ici 4 pour un petit rappel sur la division entière), on utilise respectivement les symboles // et modulo % : 1 >>> 5 // 4 2 1 3 >>> 5 % 4 4 1 5 >>> 8 // 4 6 2 7 >>> 8 % 4 8 0 Les symboles +, -, *, /, **, // et % sont appelés opérateurs, car ils réalisent des opérations sur les variables. Enfin, il existe des opérateurs « combinés » qui effectue une opération et une affectation en une seule étape : 1 >>> i = 0 2 >>> i = i + 1 3 >>> i 4 1 5 >>> i += 1 6 >>> i 7 2 8 >>> i += 2 9 >>> i 10 4 L’opérateur += effectue une addition puis affecte le résultat à la même variable. Cette opération s’appelle une « incrémentation ». Les opérateurs -=, *= et /= se comportent de manière similaire pour la soustraction, la multiplication et la division. 2.5.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 : 1 >>> chaine = "Salut" 2 >>> chaine 3 'Salut' 4 >>> chaine + " Python" 5 'Salut Python' 6 >>> chaine * 3 7 'SalutSalutSalut' L’opérateur d’addition + concatène (assemble) deux chaînes de caractères. On parle de concaténation. L’opérateur de multiplication * entre un nombre entier et une chaîne de caractères duplique (répète) plusieurs fois une chaîne de caractères. On parle de duplication. Attention Vous observez que les opérateurs + et * se comportent différemment s’il s’agit d’entiers ou de chaînes de caractères. Ainsi, l’opération 2 + 2 est une addition alors que l’opération "2" + "2" est une concaténation. On appelle ce compor- tement redéfinition des opérateurs. Nous serons amenés à revoir cette notion dans le chapitre 24 Avoir plus la classe avec les objets (en ligne). 4. https://fr.wikipedia.org/wiki/Division_euclidienne 20 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 2.6. La fonction type() Chapitre 2. Variables 2.5.3 Opérations illicites Attention à ne pas faire d’opération illicite, car vous obtiendriez un message d’erreur : 1 >>> "toto" * 1.3 2 Traceback (most recent call last): 3 File "", line 1, in 4 TypeError: can't multiply sequence by non-int of type 'float' 5 >>> "toto" + 2 6 Traceback (most recent call last): 7 File "", line 1, in 8 TypeError: can only concatenate str (not "int") to str Notez que Python vous donne des informations dans son message d’erreur. Dans le second exemple, il indique que vous devez utiliser une variable de type str, c’est-à-dire une chaîne de caractères et pas un int, c’est-à-dire un entier. 2.6 La fonction type() Si vous ne vous souvenez plus du type d’une variable, utilisez la fonction type() qui vous le rappellera. 1 >>> x = 2 2 >>> type(x) 3 4 >>> y = 2.0 5 >>> type(y) 6 7 >>> z = '2' 8 >>> type(z) 9 10 >>> type(True) 11 Nous verrons plus tard ce que signifie le mot class. Attention Pour Python, la valeur 2 (nombre entier) est différente de 2.0 (float) et est aussi différente de '2' (chaîne de caractères). 2.7 Conversion de types En programmation, on est souvent amené à convertir les types, c’est-à-dire passer d’un type numérique à une chaîne de caractères ou vice-versa. En Python, rien de plus simple avec les fonctions int(), float() et str(). Pour vous en convaincre, regardez ces exemples : 1 >>> i = 3 2 >>> str(i) 3 '3' 4 >>> i = '456' 5 >>> int(i) 6 456 7 >>> float(i) 8 456.0 9 >>> i = '3.1416' 10 >>> float(i) 11 3.1416 On verra au chapitre 7 Fichiers que ces conversions sont essentielles. En effet, lorsqu’on lit ou écrit des nombres dans un fichier, ils sont considérés comme du texte, donc des chaînes de caractères. Toute conversion d’une variable d’un type en un autre est appelé casting en anglais, il se peut que vous croisiez ce terme si vous consultez d’autres ressources. Cours de Python / Université Paris Cité / UFR Sciences du Vivant 21 Chapitre 2. Variables 2.8. Note sur le vocabulaire et la syntaxe 2.8 Note sur le vocabulaire et la syntaxe Nous avons vu dans ce chapitre la notion de variable qui est commune à tous les langages de programmation. Toutefois, Python est un langage dit « orienté objet », il se peut que dans la suite du cours, nous employions le mot objet pour désigner une variable. Par exemple, « une variable de type entier » sera pour nous équivalent à « un objet de type entier ». Nous verrons dans le chapitre 23 Avoir la classe avec les objets (en ligne) ce que le mot « objet » signifie réellement (tout comme le mot « classe »). Par ailleurs, nous avons rencontré plusieurs fois des fonctions dans ce chapitre, notamment avec type(), int(), float() et str(). Dans le chapitre 1 Introduction, nous avons également vu la fonction print(). On reconnaît qu’il s’agit d’une fonction, car son nom est suivi de parenthèses (par exemple, type()). En Python, la syntaxe générale est fonction(). Ce qui se trouve entre les parenthèses d’une fonction est appelé argument et c’est ce que l’on « passe » à la fonction. Dans l’instruction type(2), c’est l’entier 2 qui est l’argument passé à la fonction type(). Pour l’instant, on retiendra qu’une fonction est une sorte de boîte à qui on passe un (ou plusieurs) argument(s), qui effectue une action et qui peut renvoyer un résultat ou plus généralement un objet. Par exemple, la fonction type() renvoie le type de la variable qu’on lui a passé en argument. Si ces notions vous semblent obscures, ne vous inquiétez pas, au fur et à mesure que vous avancerez dans le cours, tout deviendra limpide. 2.9 Minimum et maximum Python propose les fonctions min() et max() qui renvoient respectivement le minimum et le maximum de plusieurs entiers ou floats : 1 >>> min(1, -2, 4) 2 -2 3 >>> pi = 3.14 4 >>> e = 2.71 5 >>> max(e, pi) 6 3.14 7 >>> max(1, 2.4, -6) 8 2.4 Par rapport à la discussion de la rubrique précédente, min() et max() sont des exemples de fonctions prenant plusieurs arguments. En Python, quand une fonction prend plusieurs arguments, on doit les séparer par une virgule. min() et max() prennent en argument autant d’entiers et de floats que l’on veut, mais il en faut au moins deux. 2.10 Exercices Conseil Pour ces exercices, utilisez l’interpréteur Python. 2.10.1 Nombres de Friedman Les nombres de Friedman 5 sont des nombres qui peuvent s’exprimer avec tous leurs chiffres dans une expression mathématique. Par exemple, 347 est un nombre de Friedman, car il peut s’écrire sous la forme 4 + 73. De même pour 127 qui peut s’écrire sous la forme 27 − 1. Déterminez si les expressions suivantes correspondent à des nombres de Friedman. Pour cela, vous les écrirez en Python puis exécuterez le code correspondant. 7 + 36 (3 + 4)3 36 − 5 5. https://fr.wikipedia.org/wiki/Nombre_de_Friedman 22 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 2.10. Exercices Chapitre 2. Variables (1 + 28 ) × 5 (2 + 18 )7 2.10.2 Prédire le résultat : opérations Essayez de prédire le résultat de chacune des instructions suivantes, puis vérifiez-le dans l’interpréteur Python : (1+2)**3 "Da" * 4 "Da" + 3 ("Pa"+"La") * 2 ("Da"*4) / 2 5 / 2 5 // 2 5 % 2 2.10.3 Prédire le résultat : opérations et conversions de types Essayez de prédire le résultat de chacune des instructions suivantes, puis vérifiez-le dans l’interpréteur Python : str(4) * int("3") int("3") + float("3.2") str(3) * float("3.2") str(3/4) * 2 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 23  CHAPITRE 3 Affichage 3.1 La fonction print() Dans le chapitre 1 Introduction, nous avons rencontré la fonction print() qui affiche une chaîne de caractères (le fameux "Hello world!"). En fait, la fonction print() affiche l’argument qu’on lui passe entre parenthèses et un retour à ligne. Ce retour à ligne supplémentaire est ajouté par défaut. Si toutefois, on ne veut pas afficher ce retour à la ligne, on peut utiliser l’argument par « mot-clé » end : 1 >>> print("Hello world!") 2 Hello world! 3 >>> print("Hello world!", end="") 4 Hello world!>>> Ligne 1. On a utilisé l’instruction print() classiquement en passant la chaîne de caractères "Hello world!" en argument. Ligne 3. On a ajouté un second argument end="", en précisant le mot-clé end. Nous aborderons les arguments par mot-clé dans le chapitre 10 Fonctions. Pour l’instant, dites-vous que cela modifie le comportement par défaut des fonctions. Ligne 4. L’effet de l’argument end="" est que les trois chevrons >>> se retrouvent collés après la chaîne de caractères "Hello world!". Une autre manière de s’en rendre compte est d’utiliser deux fonctions print() à la suite. Dans la portion de code suivante, le caractère « ; » sert à séparer plusieurs instructions Python sur une même ligne : 1 >>> print("Hello") ; print("Joe") 2 Hello 3 Joe 4 >>> print("Hello", end="") ; print("Joe") 5 HelloJoe 6 >>> print("Hello", end=" ") ; print("Joe") 7 Hello Joe La fonction print() peut également afficher le contenu d’une variable quel que soit son type. Par exemple, pour un entier : 1 >>> var = 3 2 >>> print(var) 3 3 24 3.2. Écriture formatée et f-strings Chapitre 3. Affichage Il est également possible d’afficher le contenu de plusieurs variables (quel que soit leur type) en les séparant par des virgules : 1 >>> x = 32 2 >>> nom = "John" 3 >>> print(nom, "a", x, "ans") 4 John a 32 ans Python a écrit une phrase complète en remplaçant les variables x et nom par leur contenu. Vous remarquerez que pour afficher plusieurs éléments de texte sur une seule ligne, nous avons utilisé le séparateur « , » entre les différents éléments. Python a également ajouté un espace à chaque fois que l’on utilisait le séparateur « , ». On peut modifier ce comportement en passant à la fonction print() l’argument par mot-clé sep : 1 >>> x = 32 2 >>> nom = "John" 3 >>> print(nom, "a", x, "ans", sep="") 4 Johna32ans 5 >>> print(nom, "a", x, "ans", sep="-") 6 John-a-32-ans 7 >>> print(nom, "a", x, "ans", sep="_") 8 John_a_32_ans Pour afficher deux chaînes de caractères l’une à côté de l’autre, sans espace, on peut soit les concaténer, soit utiliser l’argument par mot-clé sep avec une chaîne de caractères vide : 1 >>> ani1 = "chat" 2 >>> ani2 = "souris" 3 >>> print(ani1, ani2) 4 chat souris 5 >>> print(ani1 + ani2) 6 chatsouris 7 >>> print(ani1, ani2, sep="") 8 chatsouris 3.2 Écriture formatée et f-strings 3.2.1 Définitions Définition L’écriture formatée est un mécanisme permettant d’afficher des variables avec un format précis, par exemple justifiées à gauche ou à droite, ou encore avec un certain nombre de décimales pour les floats. L’écriture formatée est incontournable lorsqu’on veut créer des fichiers organisés en « belles colonnes » comme par exemple les fichiers PDB (pour en savoir plus sur ce format, reportez-vous à l’annexe A Quelques formats de données en biologie). Depuis la version 3.6, Python a introduit les f-strings pour mettre en place l’écriture formatée que nous allons décrire en détail dans cette rubrique. Il existe d’autres manières pour formater des chaînes de caractères qui étaient utilisées avant la version 3.6, nous expliquons cela dans le chapitre 26 Remarques complémentaires (en ligne). Toutefois, nous vous conseillons vivement l’utilisation des f-strings si vous débutez l’apprentissage de Python. Il est inutile d’apprendre les anciennes manières. Définition f-string est le diminutif de formatted string literals. Mais encore ? Dans le chapitre précédent, nous avons vu les chaînes de caractères ou encore strings qui étaient représentées par un texte entouré de guillemets simples ou doubles. Par exemple : 1 "Ceci est une chaîne de caractères" L’équivalent en f-string est la même chaîne de caractères précédée du caractère f sans espace entre les deux : 1 f"Ceci est une chaîne de caractères" Cours de Python / Université Paris Cité / UFR Sciences du Vivant 25 Chapitre 3. Affichage 3.2. Écriture formatée et f-strings Ce caractère f avant les guillemets va indiquer à Python qu’il s’agit d’une f-string mettant en place le mécanisme de l’écriture formatée, contrairement à une string normale. Nous expliquons plus en détail dans le chapitre 11 Plus sur les chaînes de caractères pourquoi on doit mettre ce f et quel est le mécanisme sous-jacent. 3.2.2 Prise en main des f-strings Les f-strings permettent une meilleure organisation de l’affichage des variables. Reprenons l’exemple ci-dessus à propos de notre ami John : 1 >>> x = 32 2 >>> nom = "John" 3 >>> print(f"{nom} a {x} ans") 4 John a 32 ans Il suffit de passer un nom de variable au sein de chaque couple d’accolades et Python les remplace par leur contenu. La syntaxe apparait plus lisible que l’équivalent vu précédemment : 1 >>> print(nom, "a", x, "ans") 2 John a 32 ans Bien sûr, il ne faut pas omettre le f avant le premier guillemet, sinon Python prendra cela pour une chaîne de caractères normale et ne mettra pas en place le mécanisme de remplacement entre les accolades : 1 >>> print("{nom} a {x} ans") 2 {nom} a {x} ans Remarque Une variable est utilisable plus d’une fois pour une f-string donnée : 1 >>> var = "to" 2 >>> print(f"{var} et {var} font {var}{var}") 3 to et to font toto 4 >>> Enfin, il est possible de mettre entre les accolades des valeurs numériques ou des chaînes de caractères : 1 >>> print(f"J'affiche l'entier {10} et le float {3.14}") 2 J'affiche l'entier 10 et le float 3.14 3 >>> print(f"J'affiche la chaine {'Python'}") 4 J'affiche la chaine Python Même si cela ne présente que peu d’intérêt pour l’instant, il s’agit d’une commande Python parfaitement valide. Nous verrons des exemples plus pertinents par la suite. Cela fonctionne avec n’importe quel type de variable (entiers, chaînes de caractères, floats, etc.). Attention toutefois pour les chaînes de caractères, utilisez des guillemets simples au sein des accolades si vous définissez votre f-string avec des guillemets doubles. 3.2.3 Spécification de format Les f-strings permettent de remplacer des variables au sein d’une chaîne de caractères. On peut également spécifier le format de leur affichage. Prenons un exemple. Imaginez que vous vouliez calculer, puis afficher, la proportion de GC d’un génome. La proportion de GC s’obtient comme la somme des bases Guanine (G) et Cytosine (C) divisée par le nombre total de bases (A, T, C, G) du génome considéré. Si on a, par exemple, 4 500 bases G et 2 575 bases C, pour un total de 14 800 bases, vous pourriez procéder comme suit (notez bien l’utilisation des parenthèses pour gérer les priorités des opérateurs) : 1 >>> prop_GC = (4500 + 2575) / 14800 2 >>> print("La proportion de GC est", prop_GC) 3 La proportion de GC est 0.4780405405405405 26 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 3.2. Écriture formatée et f-strings Chapitre 3. Affichage Le résultat obtenu présente trop de décimales (seize dans le cas présent). Pour écrire le résultat plus lisiblement, vous pouvez spécifier dans les accolades {} le format qui vous intéresse. Dans le cas présent, vous voulez formater un float pour l’afficher avec deux puis trois décimales : 1 >>> print(f"La proportion de GC est {prop_GC:.2f}") 2 La proportion de GC est 0.48 3 >>> print(f"La proportion de GC est {prop_GC:.3f}") 4 La proportion de GC est 0.478 Détaillons le contenu des accolades de la première ligne ({prop_GC:.2f}) : D’abord on a le nom de la variable à formatter, prop_GC, c’est indispensable avec les f-strings. Ensuite on rencontre les deux-points :, ceux-ci indiquent que ce qui suit va spécifier le format dans lequel on veut afficher la variable prop_GC. À droite des deux-points on trouve.2f qui indique ce format : la lettre f indique qu’on souhaite afficher la variable sous forme d’un float, les caractères.2 indiquent la précision voulue, soit ici deux chiffres après la virgule. Notez enfin que le formatage avec.xf (x étant un entier positif) renvoie un résultat arrondi. Vous pouvez aussi formater des entiers avec la lettre d (ici d veut dire decimal integer) : 1 >>> nb_G = 4500 2 >>> print(f"Ce génome contient {nb_G:d} guanines") 3 Ce génome contient 4500 guanines ou mettre plusieurs nombres dans une même chaîne de caractères : 1 >>> nb_G = 4500 2 >>> nb_C = 2575 3 >>> print(f"Ce génome contient {nb_G:d} G et {nb_C:d} C, " 4... f"soit une proportion de {prop_GC:.2f}") 5 Ce génome contient 4500 G et 2575 C, soit une proportion de 0.48 6 >>> perc_GC = prop_GC * 100 7 >>> print(f"Ce génome contient {nb_G:d} G et {nb_C:d} C, " 8... f"soit un %GC de {perc_GC:.2f} %") 9 Ce génome contient 4500 G et 2575 C, soit un %GC de 47.80 % Les instructions étant longues dans cet exemple, nous avons coupé chaque chaîne de caractères sur deux lignes. Il faut mettre à chaque fois le f pour préciser à Python qu’on utilise une f-string. Les... indiquent que l’interpréteur attend que l’on ferme la parenthèse du print entamé sur la ligne précédente. Nous reverrons cette syntaxe dans le chapitre 11 Plus sur les chaînes de caractères. Enfin, il est possible de préciser sur combien de caractères vous voulez qu’un résultat soit écrit et comment se fait l’alignement (à gauche, à droite), ou si vous voulez centrer le texte. Dans la portion de code suivante, le caractère ; sert de séparateur entre les instructions sur une même ligne : 1 >>> print(10) ; print(1000) 2 10 3 1000 4 >>> print(f"{10:>6d}") ; print(f"{1000:>6d}") 5 10 6 1000 7 >>> print(f"{10:6d}") ; print(f"{1000:0>6d}") 17 000010 18 001000 Notez que > spécifie un alignement à droite, < spécifie un alignement à gauche et ^ spécifie un alignement centré. Il est également possible d’indiquer le caractère qui servira de remplissage lors des alignements (l’espace est le caractère par défaut). Cours de Python / Université Paris Cité / UFR Sciences du Vivant 27 Chapitre 3. Affichage 3.2. Écriture formatée et f-strings Ce formatage est également possible sur des chaînes de caractères avec la lettre s (comme string) : 1 >>> print("atom HN") ; print("atom HDE1") 2 atom HN 3 atom HDE1 4 >>> print(f"atom {'HN':>4s}") ; print(f"atom {'HDE1':>4s}") 5 atom HN 6 atom HDE1 Vous voyez tout de suite l’énorme avantage de l’écriture formatée. Elle vous permet d’écrire en colonnes parfaitement alignées. Nous verrons que ceci est très pratique si l’on veut écrire les coordonnées des atomes d’une molécule au format PDB (pour en savoir plus sur ce format, reportez-vous à l’annexe A Quelques formats de données en biologie). Pour les floats, il est possible de combiner le nombre de caractères à afficher avec le nombre de décimales : 1 >>> print(f"{perc_GC:7.3f}") 2 47.804 3 >>> print(f"{perc_GC:10.3f}") 4 47.804 L’instruction 7.3f signifie que l’on souhaite écrire un float avec 3 décimales et formaté sur 7 caractères (par défaut justifiés à droite). L’instruction 10.3f fait la même chose sur 10 caractères. Remarquez que le séparateur décimal. compte pour un caractère. De même, si on avait un nombre négatif, le signe - compterait aussi pour un caractère. 3.2.4 Autres détails sur les f-strings Si on veut afficher des accolades littérales avec les f-strings, il faut les doubler pour échapper au formatage : 1 >>> print(f"Accolades littérales {{}} ou {{ ou }} " 2... f"et pour le formatage {10}") 3 Accolades littérales {} ou { ou } et pour le formatage 10 Une remarque importante, si on ne met pas de variable à formater entre les accolades dans une f-string, cela conduit à une erreur : 1 >>> print(f"accolades sans variable {}") 2 File "", line 1 3 SyntaxError: f-string: empty expression not allowed Enfin, il est important de bien comprendre qu’une f-string est indépendante de la fonction print(). Si on donne une f-string à la fonction print(), Python évalue d’abord la f-string et c’est la chaîne de caractères qui en résulte qui est affichée à l’écran. Tout comme dans l’instruction print(5*5), c’est d’abord la multiplication (5*5) qui est évaluée, puis son résultat qui est affiché à l’écran. On peut s’en rendre compte de la manière suivante dans l’interpréteur : 1 >>> f"{perc_GC:10.3f}" 2 ' 47.804' 3 >>> type(f"{perc_GC:10.3f}") 4 Python considère le résultat de l’instruction f"{perc_GC:10.3f}" comme une chaîne de caractères et la fonction type() nous le confirme. 3.2.5 Expressions dans les f-strings Une fonctionnalité extrêmement puissante des f-strings est de supporter des expressions Python au sein des accolades. Ainsi, il est possible d’y mettre directement une opération ou encore un appel à une fonction : 1 >>> print(f"Le résultat de 5 * 5 vaut {5 * 5}") 2 Le résultat de 5 * 5 vaut 25 3 >>> print(f"Résultat d'une opération avec des floats : {(4.1 * 6.7)}") 4 Résultat d'une opération avec des floats : 27.47 5 >>> print(f"Le minimum est {min(1, -2, 4)}") 6 Le minimum est -2 7 >>> entier = 2 8 >>> print(f"Le type de {entier} est {type(entier)}") 9 Le type de 2 est 28 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 3.3. Écriture scientifique Chapitre 3. Affichage Nous aurons l’occasion de revenir sur cette fonctionnalité au fur et à mesure de ce cours. Les possibilités offertes par les f-strings sont nombreuses. Pour vous y retrouver dans les différentes options de formatage, nous vous conseillons de consulter ce mémo 1 (en anglais). 3.3 Écriture scientifique Pour les nombres très grands ou très petits, l’écriture formatée permet d’afficher un nombre en notation scientifique (sous forme de puissance de 10) avec la lettre e : 1 >>> print(f"{1_000_000_000:e}") 2 1.000000e+09 3 >>> print(f"{0.000_000_001:e}") 4 1.000000e-09 Il est également possible de définir le nombre de chiffres après la virgule. Dans l’exemple ci-dessous, on affiche un nombre avec aucun, 3 et 6 chiffres après la virgule : 1 >>> avogadro_number = 6.022_140_76e23 2 >>> print(f"{avogadro_number:.0e}") 3 6e+23 4 >>> print(f"{avogadro_number:.3e}") 5 6.022e+23 6 >>> print(f"{avogadro_number:.6e}") 7 6.022141e+23 3.4 Exercices NOT DONE YET !!! Conseil Pour les exercices 2 à 6, utilisez l’interpréteur Python. 3.4.1 Affichage dans l’interpréteur et dans un programme Ouvrez l’interpréteur Python et tapez l’instruction 1+1. Que se passe-t-il ? Écrivez la même chose dans un script test.py que vous allez créer avec un éditeur de texte. Exécutez ce script en tapant python test.py dans un shell. Que se passe-t-il ? Pourquoi ? Faites en sorte d’afficher le résultat de l’addition 1+1 en exécutant le script dans un shell. 3.4.2 Poly-A Générez une chaîne de caractères représentant un brin d’ADN poly-A (c’est-à-dire qui ne contient que des bases A) de 20 bases de longueur, sans taper littéralement toutes les bases. 3.4.3 Poly-A et poly-GC Sur le modèle de l’exercice précédent, générez en une ligne de code un brin d’ADN poly-A (AAAA…) de 20 bases suivi d’un poly-GC régulier (GCGCGC…) de 40 bases. 3.4.4 Écriture formatée En utilisant l’écriture formatée, affichez en une seule ligne les variables a, b et c dont les valeurs sont respectivement la chaîne de caractères "salut", le nombre entier 102 et le float 10.318. La variable c sera affichée avec deux décimales. 3.4.5 Écriture formatée 2 Dans un script percGC.py, calculez un pourcentage de GC avec l’instruction suivante : perc_GC = ((4500 + 2575)/14800)*100 Ensuite, affichez le contenu de la variable perc_GC à l’écran avec 0, 1, 2 puis 3 décimales sous forme arrondie en utilisant l’écriture formatée et les f-strings. On souhaite que le programme affiche la sortie suivante : 1. https://fstring.help/cheat/ Cours de Python / Université Paris Cité / UFR Sciences du Vivant 29 Chapitre 3. Affichage 3.4. Exercices Le pourcentage de GC est 48 % Le pourcentage de GC est 47.8 % Le pourcentage de GC est 47.80 % Le pourcentage de GC est 47.804 % 3.4.6 Décomposition de fractions Utilisez l’opérateur modulo (%) et l’opérateur division entière (//) pour simplifier des fractions, connaissant leur numérateur et leur dénominateur, et afficher le résultat avec des f-strings. Par exemple pour la fraction 37 , le numérateur vaut 7 et le dénominateur vaut 3, et le résultat s’affichera sous la forme : 7/3 = 2 + 1/3 Ici, 2 est le résultat de la division entière du numérateur par le dénominateur et 1 est le reste de la division entière du numérateur par le dénominateur. Faites de même pour les fractions suivantes : 9 23 21 7 , , et 4 5 8 2 30 Cours de Python / Université Paris Cité / UFR Sciences du Vivant  CHAPITRE 4 Listes 4.1 Définition Définition Une liste est une structure de données qui contient une collection d’objets Python. Il s’agit d’un nouveau type par rapport aux entiers, float, booléens et chaînes de caractères que nous avons vus jusqu’à maintenant. On parle aussi d’objet séquentiel en ce sens qu’il contient une séquence d’autres objets. Python autorise la construction de liste contenant des valeurs de types différents (par exemple entier et chaîne de caractères), ce qui leur confère une grande flexibilité. Une liste est déclarée par une série de valeurs (n’oubliez pas les guillemets, simples ou doubles, s’il s’agit de chaînes de caractères) séparées par des virgules, et le tout encadré par des crochets. En voici quelques exemples : 1 >>> animaux = ["girafe", "tigre", "singe", "souris"] 2 >>> tailles = [5, 2.5, 1.75, 0.15] 3 >>> mixte = ["girafe", 5, "souris", 0.15] 4 >>> animaux 5 ['girafe', 'tigre', 'singe', 'souris'] 6 >>> tailles 7 [5, 2.5, 1.75, 0.15] 8 >>> mixte 9 ['girafe', 5, 'souris', 0.15] Lorsque l’on affiche une liste, Python la restitue telle qu’elle a été saisie. 4.2 Utilisation Un des gros avantages d’une liste est que vous accédez à ses éléments par leur position. Ce numéro est appelé indice (ou index) de la liste. liste : ["girafe", "tigre", "singe", "souris"] indice : 0 1 2 3 Soyez très attentif au fait que les indices d’une liste de n éléments commencent à 0 et se terminent à n − 1. Voyez l’exemple suivant : 31 Chapitre 4. Listes 4.3. Opération sur les listes 1 >>> animaux = ["girafe", "tigre", "singe", "souris"] 2 >>> animaux 3 'girafe' 4 >>> animaux 5 'tigre' 6 >>> animaux 7 'souris' Par conséquent, si on appelle l’élément d’indice 4 de notre liste, Python renverra un message d’erreur : 1 >>> animaux 2 Traceback (innermost last): 3 File "", line 1, in ? 4 IndexError: list index out of range N’oubliez pas ceci ou vous risquez d’obtenir des bugs inattendus ! 4.3 Opération sur les listes Tout comme les chaînes de caractères, les listes supportent l’opérateur + de concaténation, ainsi que l’opérateur * pour la duplication : 1 >>> ani1 = ["girafe", "tigre"] 2 >>> ani2 = ["singe", "souris"] 3 >>> ani1 + ani2 4 ['girafe', 'tigre', 'singe', 'souris'] 5 >>> ani1 * 3 6 ['girafe', 'tigre', 'girafe', 'tigre', 'girafe', 'tigre'] L’opérateur + est très pratique pour concaténer deux listes. Vous pouvez aussi utiliser la méthode.append() lorsque vous souhaitez ajouter un seul élément à la fin d’une liste. Remarque La notion de méthode est introduite dans la rubrique Note sur le vocabulaire et la syntaxe à la fin de ce chapitre. Dans l’exemple suivant, nous allons créer une liste vide : 1 >>> liste1 = [] 2 >>> liste1 3 [] puis lui ajouter deux éléments, l’un après l’autre, d’abord avec la concaténation : 1 >>> liste1 = liste1 + 2 >>> liste1 3 4 >>> liste1 = liste1 + [-5] 5 >>> liste1 6 [15, -5] puis avec la méthode.append() : 1 >>> liste1.append(13) 2 >>> liste1 3 [15, -5, 13] 4 >>> liste1.append(-3) 5 >>> liste1 6 [15, -5, 13, -3] Dans cet exemple, nous ajoutons des éléments à une liste en utilisant l’opérateur de concaténation + ou la méthode.append(). Conseil 32 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 4.4. Indiçage négatif Chapitre 4. Listes Nous vous conseillons dans ce cas précis d’utiliser la méthode.append(), dont la syntaxe est plus élégante. Nous reverrons en détail la méthode.append() dans le chapitre 12 Plus sur les listes. 4.4 Indiçage négatif La liste peut également être indexée avec des nombres négatifs selon le modèle suivant : liste : ["girafe", "tigre", "singe", "souris"] indice positif : 0 1 2 3 indice négatif : -4 -3 -2 -1 ou encore : liste : ["A", "B", "C", "D", "E", "F"] indice positif : 0 1 2 3 4 5 indice négatif : -6 -5 -4 -3 -2 -1 Les indices négatifs reviennent à compter à partir de la fin. Leur principal avantage est que vous pouvez accéder au dernier élément d’une liste à l’aide de l’indice -1 sans pour autant connaître la longueur de cette liste. L’avant-dernier élément a lui l’indice -2, l’avant-avant dernier l’indice -3, etc. : 1 >>> animaux = ["girafe", "tigre", "singe", "souris"] 2 >>> animaux[-1] 3 'souris' 4 >>> animaux[-2] 5 'singe' Pour accéder au premier élément de la liste avec un indice négatif, il faut par contre connaître le bon indice : 1 >>> animaux[-4] 2 'girafe' Dans ce cas, on utilise plutôt animaux. 4.5 Tranches Un autre avantage des listes est la possibilité de sélectionner une partie d’une liste en utilisant un indiçage construit sur le modèle [m:n+1] pour récupérer tous les éléments, du émième au énième (de l’élément m inclu à l’élément n+1 exclu). On dit alors qu’on récupère une tranche de la liste, par exemple : 1 >>> animaux = ["girafe", "tigre", "singe", "souris"] 2 >>> animaux[0:2] 3 ['girafe', 'tigre'] 4 >>> animaux[0:3] 5 ['girafe', 'tigre', 'singe'] 6 >>> animaux[0:] 7 ['girafe', 'tigre', 'singe', 'souris'] 8 >>> animaux[:] 9 ['girafe', 'tigre', 'singe', 'souris'] 10 >>> animaux[1:] 11 ['tigre', 'singe', 'souris'] 12 >>> animaux[1:-1] 13 ['tigre', 'singe'] Notez que lorsqu’aucun indice n’est indiqué à gauche ou à droite du symbole deux-points :, Python prend par défaut tous les éléments depuis le début ou tous les éléments jusqu’à la fin respectivement. On peut aussi préciser le pas en ajoutant un symbole deux-points supplémentaire et en indiquant le pas par un entier : Cours de Python / Université Paris Cité / UFR Sciences du Vivant 33 Chapitre 4. Listes 4.6. Fonction len() 1 >>> animaux = ["girafe", "tigre", "singe", "souris"] 2 >>> animaux[0:3:2] 3 ['girafe', 'singe'] 4 >>> x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 5 >>> x 6 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 7 >>> x[::1] 8 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 9 >>> x[::2] 10 [0, 2, 4, 6, 8] 11 >>> x[::3] 12 [0, 3, 6, 9] 13 >>> x[1:6:3] ?? 14 [1, 4] Finalement, on se rend compte que l’accès au contenu d’une liste fonctionne sur le modèle liste[début:fin:pas]. 4.6 Fonction len() L’instruction len() vous permet de connaître la longueur d’une liste, c’est-à-dire le nombre d’éléments que contient la liste. Voici un exemple d’utilisation : 1 >>> animaux = ["girafe", "tigre", "singe", "souris"] 2 >>> len(animaux) 3 4 4 >>> len([1, 2, 3, 4, 5, 6, 7, 8]) 5 8 4.7 Les fonctions range() et list() L’instruction range() est une fonction spéciale en Python qui génère des nombres entiers compris dans un intervalle. Lorsqu’elle est utilisée en combinaison avec la fonction list(), on obtient une liste d’entiers. Par exemple : 1 >>> list(range(10)) 2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] La commande list(range(10)) a généré une liste contenant tous les nombres entiers de 0 inclus à 10 exclu. Nous verrons l’utilisation de la fonction range() toute seule dans le chapitre 5 Boucles et comparaisons. Dans l’exemple ci-dessus, la fonction range() a pris un argument, mais elle peut également prendre deux ou trois arguments, voyez plutôt : 1 >>> list(range(0, 5)) 2 [0, 1, 2, 3, 4] 3 >>> list(range(15, 20)) 4 [15, 16, 17, 18, 19] 5 >>> list(range(0, 1000, 200)) 6 [0, 200, 400, 600, 800] 7 >>> list(range(2, -2, -1)) 8 [2, 1, 0, -1] L’instruction range() fonctionne sur le modèle range([début,] fin[, pas]). Les arguments entre crochets sont optionnels. Pour obtenir une liste de nombres entiers, il faut l’utiliser systématiquement avec la fonction list(). Enfin, prenez garde aux arguments optionnels par défaut (0 pour début et 1 pour pas) : 1 >>> list(range(10,0)) 2 [] Ici la liste est vide car Python a pris la valeur du pas par défaut qui est de 1. Ainsi, si on commence à 10 et qu’on avance par pas de 1, on ne pourra jamais atteindre 0. Python génère ainsi une liste vide. Pour éviter ça, il faudrait, par exemple, préciser un pas de -1 pour obtenir une liste d’entiers décroissants : 1 >>> list(range(10,0,-1)) 2 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 34 Cours de Python / Université Paris Cité / UFR Sciences du Vivant 4.8. Listes de listes Chapitre 4. Listes 4.8 Listes de listes Pour finir, sachez qu’il est tout à fait possible de construire des listes de listes. Cette fonctionnalité peut parfois être très pratique. Par exemple : 1 >>> prairie1 = ["girafe", 4] 2 >>> prairie2 = ["tigre", 2] 3 >>> prairie3 = ["singe", 5] 4 >>> savane = [prairie1, prairie2, prairie3] 5 >>> savane 6 [['girafe', 4], ['tigre', 2], ['singe', 5]] Dans cet exemple, chaque sou