Bioinformatique M1 - TD1 / TP1 : guide de survie avec Python

Bioinformatique M1 - TD1 / TP1 : guide de survie avec Python
(adoptez un serpent !)
Jean-Baptiste Lamy /
Table des mati`eres
1 Introduction : pourquoi Python ? 1
2 D´emarrer Python 2
3 Syntaxe 2
3.1 Commentaires...................................................... 2
3.2 ´ Ecrire`al’´ecran ..................................................... 2
3.3 Aide ........................................................... 2
3.4 Variables ........................................................ 2
4 Types de donn´ee 3
4.1 Les nombres entiers (integer en anglais, abr´eg´e en int)............................... 3
4.2 Les nombres flottant (float enanglais) ........................................ 3
4.3 Les chaˆınes caract`eres (string en anglais, abr´eg´e en str ) .............................. 3
4.4 Les listes (list enanglais) ............................................... 4
4.5 Les dictionnaires (dictionary en anglais, abr´eg´e en dict) .............................. 5
4.6 Conversion entre types de donn´ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5 Conditions 6
5.1 Op´erateur logique ET et OU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5.2 Conditionsimbriqu´ees ................................................. 6
6 Boucles 6
6.1 Programme-type n°1 : compter les ´el´ements d’une liste satisfaisant certains crit`eres . . . . . . . . . . . . . . . 7
6.2 Programme-type n°2 : garder seulement les ´el´ements d’une liste satisfaisant certains crit`eres . . . . . . . . . . 7
6.3 Programme-type n°3 : cr´eer une nouvelle liste (ou chaˆıne de caract`eres) `a partir d’une liste existante . . . . . 7
6.4 Boucler sur plusieurs listes avec zip() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6.5 Boucler sur plusieurs listes avec des boucles imbriqu´ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
7 Importer des modules Python 8
7.1 Modulemath ...................................................... 8
7.2 Module Bio : chargement de s´equences biologique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
7.2.1 ` Apartird’unfichierFASTA.......................................... 9
7.2.2 ` ApartirduserveurEntrez .......................................... 9
7.3 Installationdesmodules................................................ 9
8 Exercices 9
1 Introduction : pourquoi Python ?
Python est un langage de programmation facile et polyvalent. C’est un logiciel libre ; il est disponible gratuitement et
tourne sur diff´erent syst`eme (PC Linux, PC Windows, Mac). Vous pouvez le t´el´echarger ici : http://python.org/ si vous
voulez l’installer chez vous.
Python est de plus en plus utilis´e pour la bioinformatique et nous l’utiliserons au premier semestre pour le traitement
des s´equences biologiques et au second semestre pour l’analyse des r´esultats de s´equen¸cage `a tr`es haut d´ebit (NGS).
Il existe actuellement deux versions de Python : la version 2.x et la version 3.x. Pour la bioinformatique, nous utiliserons
la version 2 car les modules n´ecessaire n’existent pas encore en version 3. Cependant, les diff´erences entre les deux versions
sont minimes.
1

2 D´emarrer Python
Pour d´emarrer Python sous Linux, commencez par lancer un terminal (en double-cliquant sur l’icˆone du terminal : icˆone
avec un petit ´ecran noir). Python peut s’utiliser de deux mani`eres diff´erentes :
1. en ligne de commande : le programmeur (c’est `a dire vous !) donne des ordres en saisissant des commandes au clavier.
Les ordres sont ex´ecut´es au fur et `a mesure qu’ils sont saisis. Pour d´emarrer l’interpr´eteur en ligne de commande,
ex´ecuter la commande suivante dans un terminal :
python2
Le signe >>> en d´ebut de ligne est “l’invite de commande” de Python : l’ordinateur vous demande d’entrer une
commande.
Astuce lorsque l’on utilise un terminal, il est possible de reprendre la ligne de commande saisie pr´ec´edemment en
appuyant sur la fl`eche du haut du clavier. Appuyer plusieurs fois permet de r´ecup´erer des lignes plus anciennes.
2. sous forme de programme : le programmeur saisit l’ensemble des ordres dans un fichier de code Python (fichier .py).
L’ensemble du fichier est alors ex´ecut´e dans un terminal de la mani`ere suivante :
python2 nom_du_fichier.py
Sous Windows, on pourra utiliser le logiciel IDLE. La fenˆetre “Shell” ouverte par d´efaut correspond `a une ligne de commande.
Pour faire un programme, ouvrir un nouveau fichier avec le menu “File >New file”. On pourra l’ex´ecuter avec le menu “Run
>Run module”.
3 Syntaxe
3.1 Commentaires
Dans Python, tout ce qui suit le caract`ere # (= di`ese) est un commentaire et n’est pas pris en compte par Python :
>>> # Ceci est du texte en fran¸cais qui n’est pas pris en compte par Python !
3.2 ´ Ecrire `a l’´ecran
La fonction print() permet d’´ecrire `a l’´ecran :
>>> print("Bonjour !")
Bonjour !
3.3 Aide
Python d´efinit un grand nombre de fonctions. La fonction help() permet d’obtenir de l’aide sur une fonction (par exemple
la fonction len()) :
help(len)
3.4 Variables
Une variable est un nom auquel on associe une valeur. La valeur est souvent connu seulement `a l’ex´ecution du programme
(par exemple elle r´esulte d’un calcul).
Le nom commence par une lettre, il peut contenir des lettres, des chiffres et des ; en revanche on ´evitera les accents et
les espace ! L’op´erateur = est utilis´e pour d´efinir (ou red´efinir) la valeur d’une variable ; il peut se lire “prend la valeur de”
(NB attention ce n’est pas le sens usuel du = en math´ematique).
>>> age = 28
Pour ´ecrire la valeur d’une variable `a l’´ecran, on peut utiliser la fonction print() :
>>> print(age)
28
Lorsque l’on utilise Python en ligne de commande, le print() peut ˆetre omis (mais pas dans un programme) :
>>> age
28
Dans un calcul, les noms des variables sont remplac´es par leur valeur :
>>> age + 1
29
Le = peut aussi ˆetre utilis´e pour red´efinir la valeur d’une variable :
>>> age = age + 1
2

4 Types de donn´ee
Python peut manipuler diff´erents types de donn´ees : des nombres entiers (integer en anglais, abr´eg´e en int), des nombres
`a virgule (souvent appel´e flottants ou float en anglais), des chaˆınes de caract`ere (string en anglais, abr´eg´e en str) et des
bool´eens (valeur vraie ou fausse, bool) :
> age = 31 # Entier
> poids = 64.5 # Flottant
> nom = "Jean-Baptiste Lamy" # Cha^ıne de caract`ere
> enseignant = TRUE # Bool´een
> etudiant = FALSE # Bool´een
> telephone = "01 48 38 73 34" # Cha^ıne de caract`ere !
4.1 Les nombres entiers (integer en anglais, abr´eg´e en int)
Les nombres entiers sont les nombres sans virgule.
> age = 31
4.2 Les nombres flottant (float en anglais)
Les nombres flottant sont les nombres avec virgule. On utilise un point pour la virgule.
> poids = 64.4
Attention, 10.0 est un flottant alors que 10 est un entier !
Op´eration num´erique (entier ou flottant) Exemples
Addition >>> 2 + 2
Soustraction >>> 4 - 2
Multiplication >>> 3 * 4
Division >>> 10 / 3
3
>>> 10.0 / 3.0
3.3333333333333
Puissance >>> 3 ** 2
9
Modulo (reste de la division enti`ere) >>> 10 % 3
1
4.3 Les chaˆınes caract`eres (string en anglais, abr´eg´e en str )
Les chaˆınes de caract`eres correspondent `a des textes ou des portions de texte. Il n’y a pas de limite sur le nombre de
caract`eres (z´ero, un ou plusieurs). Les chaˆınes de caract`eres sont toujours plac´ees entre guillemets.
> nom = "Jean-Baptiste Lamy"
> chaine_vide = ""
> telephone = "01 48 38 73 34" # C’est une cha^ıne car on ne fait pas d’op´eration
# sur des num´eros de t´el´ephone !
3

Op´eration sur les chaˆınes Exemples
>>> arn = "GCCUGCUUA"
Obtenir la longueur d’une chaˆıne
(= le nombre de caract`eres)
>>> len(arn)
9
Obtenir un caract`ere de la chaˆıne (attention, on compte `a
partir de z´ero et non de un)
>>> arn[0]
"G" # Premier ´el´ement
>>> arn[-1]
"A" # Dernier ´el´ement
Obtenir une partie de la chaˆıne >>> arn[0:3]
"GCC"
Rechercher si une chaˆıne est incluse dans une autre >>> "GCCUGCUUA".find("UGC")
3 # Trouv´e en position 3 (-1 si pas trouv´e)
Passer une chaˆıne en minuscule ou en majuscule >>> "AttCgcG".lower()
"attcgcg"
>>> "AttCgcG".upper()
"ATTCGCG"
Demander `a l’utilisateur de saisir une chaˆıne >>> saisie = raw_input("Entrez un nom : ")
D´efinir une chaˆıne avec des guillemets `a l’int´erieur >>> """Il dit "Bonjour"."""
>>> "Il dit ’Bonjour’."
>>> "Il dit \"Bonjour\"."
D´efinir une chaˆıne avec des caract`eres sp´eciaux `a l’aide
d’un antislash (\)
>>> "retour `a la ligne : \n"
>>> "tabulation : \t"
>>> "antislash : \\"
Concat´ener deux chaˆınes (= les mettre bout `a bout) ;
attention il faut ajouter un espace si vous en souhaitez un
>>> "JB" + "LAMY"
"JBLAMY"
>>> nom = "LAMY"
>>> prenom = "JB"
>>> pr´enom + " " + nom
"JB LAMY"
R´ep´eter une chaˆıne >>> "A" * 3
"AAA"
4.4 Les listes (list en anglais)
Les listes contiennent z´eros, un ou plusieurs ´el´ements (elles ressemblent aux tableaux d’autres langages de programmation).
Les ´el´ements peuvent ˆetre de types diff´erents (entiers, chaˆınes de caract`ere,...). Les listes sont cr´e´ees avec des crochets, les
´el´ements sont donn´es `a l’int´erieur des crochets et s´epar´es par des virgules :
>>> ma_liste = [0, "Lamy", True]
>>> liste_vide = [ ]
Pour une liste `a n ´el´ement, les ´el´ements sont num´erot´es de z´ero `a n - 1.
Note les chaˆınes de caract`eres peuvent souvent ˆetre consid´er´ees comme des listes de caract`eres.
4

Op´eration sur les listes Exemples
>>> animaux = ["´el´ephant", "girafe",
"rhinoc´eros", "gazelle"]
Obtenir la longueur d’une liste
(= le nombre d’´el´ement)
>>> len(animaux)
4
Obtenir un ´el´ement de la liste (attention, on compte `a
partir de z´ero et non de un)
>>> animaux[0]
"´el´ephant" # Premier ´el´ement
>>> animaux[-1]
"gazelle" # Dernier ´el´ement
Obtenir une partie de la liste >>> animaux[0:2]
["´el´ephant", "girafe"]
Ajouter un ´el´ement `a la fin >>> animaux.append("lion")
Ajouter un ´el´ement `a une position donn´ee (0 : premi`ere
position, etc)
>>> animaux.insert(0, "hippopotame")
Ajouter deux listes >>> [1, 2] + [3, 4, 5]
[1, 2, 3, 4, 5]
Enlever un ´el´ement >>> animaux.remove("gazelle")
Enlever l’´el´ement `a une position donn´ee >>> del animaux[-2]
Rechercher si un ´el´ement est pr´esent dans une liste >>> "lion" in animaux
True
Trier une liste (ordre croissant / alphab´etique) >>> animaux.sort()
Obtenir le plus grand ´el´ement d’une liste, ou le plus petit >>> max([2, 1, 4, 3])
4
>>> min([2, 1, 4, 3])
1
4.5 Les dictionnaires (dictionary en anglais, abr´eg´e en dict)
Un dictionnaire (ou tableau associatif, ou hashtable ou hashmap en anglais) fait correspondre `a chaque ´el´ement un autre
´el´ement. Par exemple, un dictionnaire peut faire correspondre `a un mot sa d´efinition (d’o`u le nom de dictionnaire). Un
dictionnaire est cr´e´e avec des accolades, au sein desquelles sont plac´es z´ero, un ou plusieurs couples “clef : valeur” s´epar´es par
“ :”.
>>> dico = {
"pomme" : "la pomme est le fruit du pommier",
"pommier" : "le pommier est un arbre du genre botanique Malus",
"fruit" : "un aliment v´eg´etal, `a la saveur sucr´ee",
}
Dans l’exemple pr´ec´edent les clefs sont ”pomme”, ”pommier” et ”fruit” et les valeurs sont les d´efinitions. ` A chaque clef
correspond une et une seule valeur.
Op´eration sur les dictionnaires Exemples
Obtenir le nombre de clef (ou de valeur) dans le
dictionnaire
>>> len(dico)
3
Obtenir la valeur associ´ee `a une clef >>> dico["pomme"]
"la pomme est le fruit du pommier"
Ajouter un couple clef : valeur >>> dico["clef"] = "valeur"
Supprimer une clef (et la valeur associ´ee) >>> del dico["clef"]
Rechercher si une clef est pr´esente dans le dictionnaire >>> "pomme" in dico
True
4.6 Conversion entre types de donn´ees
Il est parfois n´ecessaire de convertir d’un type de donn´ee vers une autre. Les fonctions int(), float() et str() permettent
de convertir une valeur vers un entier, un flottant et une chaˆıne de caract`ere.
>>> int("8")
8
>>> str(8)
"8"
La fonction raw input() retourne toujours une chaˆıne de caract`eres ; il faut penser `a la transformer en entier ou en flottant
si l’on demande la saisie d’un nombre !
>>> age = int(raw_input("Entrez votre ^age : "))
>>> poids = float(raw_input("Entrez votre poids : "))
5