Le langage Python
Partie 1
Tefy Raoelivololona
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.7 a été publiée en juin 2018.
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 libre et 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 cellule, 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
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.2 À quoi peut servir python ?
Python est un langage puissant, à la fois facile à apprendre et riche en possibilités. Dès l'instant où
vous l'installez sur votre ordinateur, vous disposez de nombreuses fonctionnalités intégrées au
langage. Il est, en outre, très facile d'étendre les fonctionnalités existantes. Il existe ce qu'on
appelle des bibliothèques qui aident le développeur à travailler sur des projets particuliers.
Plusieurs bibliothèques peuvent ainsi être installées pour, par exemple, développer des interfaces
graphiques en Python. Concrètement, voilà ce qu'on peut faire avec Python :
de petits programmes très simples, appelés scripts, chargés d'une mission très précise sur
votre machine ;
des programmes complets, comme des jeux, des suites bureautiques, des logiciels
multimédias, des clients de messagerie…
des projets très complexes, comme des progiciels (ensemble de plusieurs logiciels pouvant
fonctionner ensemble, principalement utilisés dans le monde professionnel).
Voici quelques-unes des fonctionnalités offertes par Python et ses bibliothèques :
créer des interfaces graphiques ;
faire circuler des informations au travers d'un réseau ;
dialoguer d'une façon avancée avec votre système d'exploitation.
1.3 Différentes versions de python
Lors de la création de la Python Software Foundation, en 2001, et durant les années qui ont suivi,
le langage Python est passé par une suite de versions que l'on a englobées dans l'appellation
Python 2.x (2.3, 2.5, 2.6…). Depuis le 13 février 2009, la version 3.0.1 est disponible. Quand un
langage de programmation est mis à jour, les développeurs se gardent bien de supprimer ou de
trop modifier d'anciennes fonctionnalités. L'intérêt est qu'un programme qui fonctionne sous une
certaine version marchera toujours avec la nouvelle version en date. Cependant, la Python
Software Foundation observant un bon nombre de fonctionnalités obsolètes, mises en œuvre
plusieurs fois a décidé de nettoyer tout le projet. Un programme qui tourne à la perfection sous
Python 2.x devra donc être mis à jour pour fonctionner de nouveau sous Python 3. C'est pourquoi
je vais vous conseiller ultérieurement de télécharger et d'installer la dernière version en date de
Python.
1.4 Technique de production des programmes
La compilation : on effectue la traduction d’un code source en un langage objet puis on assemble
les différents objets pour obtenir un exécutable sur une machine au travers d’un éditeur de lien.
Inconvénient : il faut refaire le processus à chaque modification.
Avantage : c’est rapide à l’exécution
L’interprétation : Chaque ligne source est analysée et exécutée.
Avantage : Pas de code objet , pas d’édition de lien
Inconvénient : Plus lent car on doit interpréter à chaque fois
Technique mixte : On traduit le langage source en un code intermédiaire et on exécute de code
intermédiaire (bytecode)
Inconvénient : c’est toujours de l’interprété
Avantage : c’est plus rapide que l’interprétation du source, c’est portable au niveau du
bytecode
Python utilise la technique mixte : Interprétation du bytecode compilé. Le bytecode qui est une
forme intermédiaire est portable sur toute machine munie d’une machine virtuelle Python.
Code source Compilateur ByteCode Interpréteur Résultat
1.5 Résumé
Python est un langage de programmation interprété, à ne pas confondre avec un langage
compilé
Il permet de créer toutes sortes de programmes, comme des jeux, des logiciels, des
progiciels, etc,
Il est possible d'associer des bibliothèques à Python afin d'étendre ses possibilités.
Il est portable, c'est à dire qu'il peut fonctionner sous différents systèmes d'exploitation
(Windows, Linux, Mac OS X,…).
2. Base de la programmation avec l’invite de commande
2.1 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.
Au lancement de l’interpréteur Python, vous devriez obtenir (sous windows) :
Python 3.9.0 (tags/v3.9.0:9cf6752, Oct 5 2020, 15:34:40) [MSC v.1927 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>>
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.
>>>
>>>
Chaque ligne de commande est validée par la touche Entrée
2.2 Les nombres et opérateurs
2.2.1 Les nombres
Python formate automatiquement les nombres saisis par supposition.
>>>
>>>
>>>
>>>
La fonction type() permet de connaître le format (ou le type) de l’objet. Ces deux objets ne sont
pas traduits de la même façon en mémoires.
2.2.2 Les opérateurs
Pour effectuer les opérations, on utilise respectivement les symboles +, -, * , /.
>>>
.
>>>
.
>>>
.
>>> # la division retourne toujours un nombre à virgule
.
Notez que le symbole # permet d’introduire des commentaires dans votre code. Ces
commentaires ne sont pas évalués par l’ordinateur, mais ils permettent d’améliorer la
compréhension du code pour vous et pour les autres personnes amenées à lire votre code.
>>> # la division classique retourne un nombre à virgule
.
>>>
>>> # l’opérateur // retourne le quotient de la division
.
>>> # l’opérateur % (modulo) retourne le reste de la division
.
>>> # quotient * diviseur + reste
.
L’opérateur pour le calcul des puissances : **
>>>
.
>>>
.
>>>
.
>>>
2.2.3 Les nombres complexes
On écrit les nombres complexes en notation cartésienne, ils sont constitués de deux flottants :
• la partie réelle
• la partie imaginaire
La partie imaginaire étant suffixée par la lettre j.
>>> 1j
>>> (5+3j) + (6-8j)
>>> (5+3j).real
>>> (5.3j).imag
>>>
>>>
>>>
2.3 Les variables
2.3.1 Définition
Une variable est une zone de la mémoire de l’ordinateur dans laquelle une valeur est stockée. Aux
yeux du programmeur, cette variable est définie par un nom, alors que pour la machine, 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 se font en même temps.
>>>
>>>
Python a « deviné » que la variable était un entier. On dit que Python est un langage au typage
dynamique.
>>>
>>>
>>> # permutation des valeurs de 2 variables
>>>
.
>>>
.
Le nom de variable doit respecter quelques règles de syntaxe incontournables :
Le nom de la variable ne peut être composé que de lettres, majuscules ou minuscules, de
chiffres et du symbole souligné « _ » (appelé underscore en anglais).
Le nom de la variable ne peut pas commencer par un chiffre.
Le langage Python est sensible à la casse, ce qui signifie que des lettres majuscules et
minuscules ne constituent pas la même variable (la variable AGE est différente de aGe, elle-
même différente de age).
2.3.2 Les mots réservés
Les mots-clés sont utilisés par Python, vous ne pouvez pas construire de variables portant ces
noms.
and del from none true
as elif global nonlocal try
assert else if not while
break except import or with
class false in pass yield
continue finally is raise
2.3.3 Les types de variables
Les trois principaux types dont nous aurons besoin dans un premier temps sont les :
entiers integer ou int,
nombres décimaux float
chaînes de caractères string ou str.
>>>
>>>
>>>
>>>
.
>>>
>>>
.
>>>
>>>
2.3.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 :
>>> 1e6 # notation scientifique
1000000.0
>>> 3.12e -3
0.00312
Python génère systématiquement 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 (au 26 août 2020) 7807568245. Pour s’y retrouver, Python autorise l’utilisation
du caractère « souligné » (ou underscore) _ pour séparer des groupes de chiffres. Par exemple :
>>>
>>>
>>>
>>>
2.3.5 Opérations sur les valeurs des variables
Les symboles +, -, *, / sont des opérateurs qui s’appliquent sur les variables de type int ou float.
Les symboles **, // et % s’appliquent sur les variables de type int.
On Remarque toutefois que si on mélange les types int et float, 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 :
>>>
>>>
>>>
>>>
>>>
>>>
>>>
Petite astuce, la dernière expression affichée à l’écran est automatique et systématiquement
assignée à la variable _.
>>>
>>>
>>>
>>>
>>>
Enfin, il existe des opérateurs « combinés » qui effectuent une opération et une affectation en une
seule étape :
>>>
>>>
>>>
>>>
>>>
>>>
>>>
Les opérateurs -=, *= et /= se comportent de manière similaire pour la soustraction, la
multiplication et la division.
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:
>>>
>>>
>>>
>>>
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. On appelle ce comportement redéfinition des opérateurs.
Les chaines de caractères sont des caractères stockés consécutivement en mémoire et la
mémoire peut être vue comme un tableau. Ainsi, il est possible accéder à chacun des caractères
d’une chaine à l’aide d’un indice qui indique sa position :
>>>
>>>
>>>
Notez que 0 correspond à la première position du mot. Des indices négatifs peuvent être utilisés :
>>>
>>>
>>>
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
L’on peut aussi accéder à des séquences de chaine de caractères :
>>>
>>>
>>>
>>>
2.3.6 Opérations illicites
Attention à ne pas faire d’opération illicite car vous obtiendriez un message d’erreur :
>>>
>>>
La fonction len() permet de déterminer la taille de la chaîne de caractère. Cette fonction est très
utile.
>>>
>>>
2.3.7 La fonction type()
Pour faire apparaître le type d’une variable, on utilise la fonction type().
>>>
>>>
>>>
>>>
>>>
>>>
2.3.8 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().
>>>
>>>
>>>
>>>
>>>
>>>
>>>
On verra plus tard 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.
3. Les opérations d’Entrée/sortie
3.1 Affichage
La fonction print() affiche l’argument qu’on lui passe entre parenthèses et un retour à la ligne.
Ce retour à la 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.
>>>
>>>
La fonction print() peut également afficher le contenu d’une variable quel que soit son type.
>>>
>>>
>>>
On peut aussi modifier l’espace entre les mots en rajoutant l’argument sep dans la fonction
>>>
>>>
>>>
>>>
Affichage formaté
La méthode .format() permet une meilleure organisation de l’affichage des variables (nous
expliquerons à la fin de ce chapitre ce que le terme « méthode » signifie en Python). Si on reprend
l’exemple précédent :
>>>
>>>
>>>
Dans la chaîne de caractères, les accolades vides {} précisent l’endroit où le contenu de la
variable doit être inséré.
Juste après la chaîne de caractères, l’instruction .format(nom, age) fournie la liste des
variables à insérer, d’abord la variable nom puis la variable age.
La méthode .format() agit sur la chaîne de caractères à laquelle elle est attachée par le
point.
Remarque
Il est possible d’indiquer entre les accolades {} dans quel ordre afficher les variables, avec 0 pour
la variable à afficher en premier, 1 pour la variable à afficher en second, etc. (attention, Python
commence à compter à 0). Cela permet de modifier l’ordre dans lequel sont affichées les
variables.
>>>
>>>
>>>
>>>
Imaginez maintenant 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, 4500 bases G et
2575 bases C, pour un total de 14800 bases, vous pourriez procéder comme suit (notez bien
l’utilisation des parenthèses pour gérer les priorités des opérateurs) :
>>>
>>>
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 :
>>>
>>>
Notez enfin que le formatage avec .xf (x étant un entier positif) renvoie un résultat arrondi.
3.2 Lecture
Transmettre une information à l’ordinateur, c’est faire lire à l’ordinateur une information à l’écran.
Pour cela, il peut utiliser la fonction input():
>>>
>>>
>>>
Par défaut, l’information que vous tapez à l’écran est stockée systématiquement en tant que
«string», c’est-à-dire une chaine de caractères. Pour forcer le type de l’information saisi à l’écran il
faut utiliser les fonctions telles que : int(), float(), str(), bool(),…
>>>
>>>
>>>
>>>
>>>
>>>
4. Les listes
4.1 Utilisation
Les listes permettent de regrouper plusieurs objets dans un même objet. Ces objets peuvent être
de types (ou formats) différents, mais généralement les objets sont de même type.
Syntaxe : nom_variable = [ Obj1 , Obj2, … ].
>>>
>>>
Quel est le type de « carre » ?
De la même façon que les listes de caractères, il est possible d’accéder à des éléments ou à des
séquences de la liste de la façon suivante :
>>> # élément à la position 0
>>>
>>> # séquence de la troisième
>>> # position en partant
>>> # de la fin jusqu’à la fin
>>> # tous les éléments de la liste
Il est possible de changer le contenu d’une liste :
>>> # le cube de 4 est 64 et non 65
>>>
>>> # on remplace la valeur fausse
>>>
Les listes supportent la concaténation :
>>>
>>>
>>> # l’ancien contenu est écrasé par le nouveau
>>>
Il est également possible de modifier des séquences dans une liste, de modifier leur taille en
ajoutant ou en supprimant des éléments :
>>>
>>>
>>> # remplace des éléments
>>>
>>> # supprime des éléments
>>>
>>> # vide la liste de son contenu
>>>
>>>
Quelle est la taille de la liste « lettres » ? Quel est le type de « lettres » ?
Il est possible de construire des listes imbriquées, par exemple :
>>>
>>>
>>>
>>>
>>>
>>> # accès aux éléments des listes imbriquées
4.2 Les méthodes
Il existe plusieurs fonctions, appelées méthode, qui sont associées aux listes, voici quelques unes
d’entre elles :
>>>[Link](x) # ajout d’éléments (x) à la fin de la liste
>>>
>>>[Link](i, x) # insertion d’éléments (x)à une position (i)
>>>
>>>[Link](x) # suppression du premier élément de la liste correspondant (x)
>>>
>>>[Link]() # vide la liste de son contenu
>>>
>>>[Link](x) # retourne la position du premier élément de la liste
>>>
>>> #correspondant à (x)
>>>[Link](x) #retourne le nombre de fois
>>> # où (x) apparait dans la liste
>>>[Link]() #tri les éléments d’une liste
>>>[Link]() #Inverse la position des éléments de la liste
Exemples
>>> nombres = [5, 1, 9 ,30, 18]
>>>[Link]()
>>>[Link](10)
>>>[Link]()
>>>[Link](18)
>>>[Link](30)
4.3 Initialisations
>>>chose = []
>>>trucMuch = [2]*4
>>>range(5)
>>>range(5,8)
>>>range(2, 11, 2)
>>>chose = range(7)
>>>print 3 in chose