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ères
1 Introduction : pourquoi Python ?
1
2 Démarrer Python
2
3 Syntaxe
3.1 Commentaires .
3.2 Écrire à l’écran
3.3 Aide . . . . . .
3.4 Variables . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
2
2
2
4 Types de donnée
4.1 Les nombres entiers (integer en anglais, abrégé en int) .
4.2 Les nombres flottant (float en anglais) . . . . . . . . . .
4.3 Les chaı̂nes caractères (string en anglais, abrégé en str )
4.4 Les listes (list en anglais) . . . . . . . . . . . . . . . . .
4.5 Les dictionnaires (dictionary en anglais, abrégé en dict)
4.6 Conversion entre types de données . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
3
3
4
5
5
5 Conditions
5.1 Opérateur logique ET et OU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Conditions imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
6
6
6 Boucles
6.1 Programme-type n°1 : compter les éléments d’une liste satisfaisant certains critères . . . . . . . . . .
6.2 Programme-type n°2 : garder seulement les éléments d’une liste satisfaisant certains critères . . . . .
6.3 Programme-type n°3 : créer une nouvelle liste (ou chaı̂ne de caractères) à partir d’une liste existante
6.4 Boucler sur plusieurs listes avec zip() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5 Boucler sur plusieurs listes avec des boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
7
7
7
7
8
7 Importer des modules Python
7.1 Module math . . . . . . . . . . . . . .
7.2 Module Bio : chargement de séquences
7.2.1 À partir d’un fichier FASTA . .
7.2.2 À partir du serveur Entrez . .
7.3 Installation des modules . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
8
8
9
9
9
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . .
biologique
. . . . . .
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8 Exercices
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
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érent système (PC Linux, PC Windows, Mac). Vous pouvez le télécharger ici : http://python.org/ si vous
voulez l’installer chez vous.
Python est de plus en plus utilisé pour la bioinformatique et nous l’utiliserons au premier semestre pour le traitement
des séquences biologiques et au second semestre pour l’analyse des résultats de séquençage à très haut débit (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écessaire n’existent pas encore en version 3. Cependant, les différences entre les deux versions
sont minimes.
1
2
Démarrer Python
Pour démarrer Python sous Linux, commencez par lancer un terminal (en double-cliquant sur l’icône du terminal : icône
avec un petit écran noir). Python peut s’utiliser de deux manières différentes :
1. en ligne de commande : le programmeur (c’est à dire vous !) donne des ordres en saisissant des commandes au clavier.
Les ordres sont exécutés au fur et à mesure qu’ils sont saisis. Pour démarrer l’interpréteur en ligne de commande,
exécuter la commande suivante dans un terminal :
python2
Le signe >>> en début 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écédemment en
appuyant sur la flèche du haut du clavier. Appuyer plusieurs fois permet de récupérer 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écuté dans un terminal de la manière suivante :
python2 nom_du_fichier.py
Sous Windows, on pourra utiliser le logiciel IDLE. La fenêtre “Shell” ouverte par défaut correspond à une ligne de commande.
Pour faire un programme, ouvrir un nouveau fichier avec le menu “File > New file”. On pourra l’exécuter avec le menu “Run
> Run module”.
3
Syntaxe
3.1
Commentaires
Dans Python, tout ce qui suit le caractère # (= dièse) est un commentaire et n’est pas pris en compte par Python :
>>> # Ceci est du texte en français qui n’est pas pris en compte par Python !
3.2
Écrire à l’écran
La fonction print() permet d’écrire à l’écran :
>>> print("Bonjour !")
Bonjour !
3.3
Aide
Python définit 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 à l’exécution du programme
(par exemple elle résulte d’un calcul).
Le nom commence par une lettre, il peut contenir des lettres, des chiffres et des ; en revanche on évitera les accents et
les espace ! L’opérateur = est utilisé pour définir (ou redéfinir) 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ématique).
>>> age = 28
Pour écrire la valeur d’une variable à l’écran, on peut utiliser la fonction print() :
>>> print(age)
28
Lorsque l’on utilise Python en ligne de commande, le print() peut être omis (mais pas dans un programme) :
>>> age
28
Dans un calcul, les noms des variables sont remplacés par leur valeur :
>>> age + 1
29
Le = peut aussi être utilisé pour redéfinir la valeur d’une variable :
>>> age = age + 1
2
4
Types de donnée
Python peut manipuler différents types de données : des nombres entiers (integer en anglais, abrégé en int), des nombres
à virgule (souvent appelé flottants ou float en anglais), des chaı̂nes de caractère (string en anglais, abrégé en str ) et des
booléens (valeur vraie ou fausse, bool ) :
>
>
>
>
>
>
4.1
age
poids
nom
enseignant
etudiant
telephone
=
=
=
=
=
=
31 # Entier
64.5 # Flottant
"Jean-Baptiste Lamy" # Cha^
ıne de caractère
TRUE # Booléen
FALSE # Booléen
"01 48 38 73 34" # Cha^
ıne de caractère !
Les nombres entiers (integer en anglais, abrégé 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ération numérique (entier ou flottant)
Addition
Soustraction
Multiplication
Division
Exemples
>>> 2 + 2
>>> 4 - 2
>>> 3 * 4
>>> 10 / 3
3
>>> 10.0 / 3.0
3.3333333333333
>>> 3 ** 2
9
>>> 10 % 3
1
Puissance
Modulo (reste de la division entière)
4.3
Les chaı̂nes caractères (string en anglais, abrégé en str )
Les chaı̂nes de caractères correspondent à des textes ou des portions de texte. Il n’y a pas de limite sur le nombre de
caractères (zéro, un ou plusieurs). Les chaı̂nes de caractères sont toujours placées 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ération
# sur des numéros de téléphone !
3
Opération sur les chaı̂nes
Exemples
>>> arn = "GCCUGCUUA"
>>> len(arn)
9
>>> arn[0]
"G" # Premier élément
>>> arn[-1]
"A" # Dernier élément
>>> arn[0:3]
"GCC"
>>> "GCCUGCUUA".find("UGC")
3 # Trouvé en position 3 (-1 si pas trouvé)
>>> "AttCgcG".lower()
"attcgcg"
>>> "AttCgcG".upper()
"ATTCGCG"
>>> saisie = raw_input("Entrez un nom : ")
>>> """Il dit "Bonjour"."""
>>> "Il dit ’Bonjour’."
>>> "Il dit \"Bonjour\"."
>>> "retour à la ligne : \n"
>>> "tabulation : \t"
>>> "antislash : \\"
>>> "JB" + "LAMY"
"JBLAMY"
Obtenir la longueur d’une chaı̂ne
(= le nombre de caractères)
Obtenir un caractère de la chaı̂ne (attention, on compte à
partir de zéro et non de un)
Obtenir une partie de la chaı̂ne
Rechercher si une chaı̂ne est incluse dans une autre
Passer une chaı̂ne en minuscule ou en majuscule
Demander à l’utilisateur de saisir une chaı̂ne
Définir une chaı̂ne avec des guillemets à l’intérieur
Définir une chaı̂ne avec des caractères spéciaux à l’aide
d’un antislash (\)
Concaténer deux chaı̂nes (= les mettre bout à bout) ;
attention il faut ajouter un espace si vous en souhaitez un
>>> nom = "LAMY"
>>> prenom = "JB"
>>> prénom + " " + nom
"JB LAMY"
>>> "A" * 3
"AAA"
Répéter une chaı̂ne
4.4
Les listes (list en anglais)
Les listes contiennent zéros, un ou plusieurs éléments (elles ressemblent aux tableaux d’autres langages de programmation).
Les éléments peuvent être de types différents (entiers, chaı̂nes de caractère,...). Les listes sont créées avec des crochets, les
éléments sont donnés à l’intérieur des crochets et séparés par des virgules :
>>> ma_liste = [0, "Lamy", True]
>>> liste_vide = [ ]
Pour une liste à n élément, les éléments sont numérotés de zéro à n - 1.
Note les chaı̂nes de caractères peuvent souvent être considérées comme des listes de caractères.
4
Opération sur les listes
Exemples
>>> animaux = ["éléphant", "girafe",
"rhinocéros", "gazelle"]
>>> len(animaux)
4
>>> animaux[0]
"éléphant" # Premier élément
>>> animaux[-1]
"gazelle" # Dernier élément
>>> animaux[0:2]
["éléphant", "girafe"]
>>> animaux.append("lion")
>>> animaux.insert(0, "hippopotame")
Obtenir la longueur d’une liste
(= le nombre d’élément)
Obtenir un élément de la liste (attention, on compte à
partir de zéro et non de un)
Obtenir une partie de la liste
Ajouter un élément à la fin
Ajouter un élément à une position donnée (0 : première
position, etc)
Ajouter deux listes
Enlever un élément
Enlever l’élément à une position donnée
Rechercher si un élément est présent dans une liste
Trier une liste (ordre croissant / alphabétique)
Obtenir le plus grand élément d’une liste, ou le plus petit
4.5
>>> [1, 2] + [3, 4, 5]
[1, 2, 3, 4, 5]
>>> animaux.remove("gazelle")
>>> del animaux[-2]
>>> "lion" in animaux
True
>>> animaux.sort()
>>> max([2, 1, 4, 3])
4
>>> min([2, 1, 4, 3])
1
Les dictionnaires (dictionary en anglais, abrégé en dict)
Un dictionnaire (ou tableau associatif, ou hashtable ou hashmap en anglais) fait correspondre à chaque élément un autre
élément. Par exemple, un dictionnaire peut faire correspondre à un mot sa définition (d’où le nom de dictionnaire). Un
dictionnaire est créé avec des accolades, au sein desquelles sont placés zéro, un ou plusieurs couples “clef : valeur” séparés par
“ :”.
>>> dico = {
"pomme"
: "la pomme est le fruit du pommier",
"pommier" : "le pommier est un arbre du genre botanique Malus",
"fruit"
: "un aliment végétal, à la saveur sucrée",
}
Dans l’exemple précédent les clefs sont ”pomme”, ”pommier” et ”fruit” et les valeurs sont les définitions. À chaque clef
correspond une et une seule valeur.
Opération sur les dictionnaires
Exemples
Obtenir le nombre de clef (ou de valeur) dans le
>>> len(dico)
dictionnaire
3
Obtenir la valeur associée à 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ée)
>>> del dico["clef"]
Rechercher si une clef est présente dans le dictionnaire
>>> "pomme" in dico
True
4.6
Conversion entre types de données
Il est parfois nécessaire de convertir d’un type de donnée 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ère.
>>> int("8")
8
>>> str(8)
"8"
La fonction raw input() retourne toujours une chaı̂ne de caractères ; il faut penser à 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
5
Conditions
Les conditions permettent d’exécuter des commandes seulement dans certaines situations (déterminée à l’exécution du
programme).
if condition1 :
commande exécutée si la condition1 est vraie
commande exécutée si la condition1 est vraie...
elif condition2 :
commande exécutée si la condition1 est fausse et la condition2 est vraie...
else :
commande exécutée si la condition1 et la condition2 sont fausses...
suite du programme (exécutée que les conditions soient vraies ou fausses)
Les parties “elif” et “else” sont optionnelles. Il faut faire attention à l’indentation (= les espaces blancs en début
de ligne) car ce sont eux qui indiquent à quel endroit la condition se termine. Le nombre d’espace est au choix
du programmeur mais doit resté constant.
Une condition est une comparaison utilisant l’un des opérateurs suivants :
— Inférieur à : <
— Supérieur à : >
— Inférieur ou égal à : <=
— Supérieur ou égal à : >=
— Égal à : == (ne pas confondre avec le = simple qui définit les variables)
— Différent de : !=
Exemple de condition :
age = int(raw_input("veuillez saisir votre ^
age : "))
if age >= 65 :
print("Vous ^
etes une personne ^
agée.")
print("L’année prochaine vous aurez " + str(age + 1) + " ans.")
Lorsqu’il n’y a qu’une seule commande à exécuté si la condition est vraie, il est possible de tout mettre sur une seule ligne :
if age >= 65 : print("Vous ^
etes une personne ^
agée.")
5.1
Opérateur logique ET et OU
Les opérateurs and (ET logique) et or (OU logique) permettent de combiner plusieurs conditions entre elles :
if (age < 18) or (age > 65) :
print("Vous ne travaillez probablement pas.")
5.2
Conditions imbriquées
Les conditions peuvent aussi être imbriquées (en utilisant plusieurs niveaux d’indentation) :
age = int(raw_input("veuillez saisir votre ^
age : "))
poids = float(raw_input("veuillez saisir votre poids : "))
if age == 0 :
print("Vous ^
etes un nouveau-né.")
if poids > 10.0 :
print("Je pense qu’il y a une erreur sur le poids !")
6
Boucles
Une boucle permet d’exécuter plusieurs fois les mêmes commandes. La boucle parcourt une liste, et exécute une série de
commande pour chaque élément de la liste. L’élément en cours est placé dans une variable de votre choix.
for variable in liste :
commande répétée plusieurs fois
commande répétée plusieurs fois
suite du programme (exécutée une seule fois)
La liste parcourue peut être une variable, mais aussi une liste d’indice générée avec la fonction range() :
>>> range(4)
[0, 1, 2, 3]
Exemples : afficher un animal par ligne :
6
animaux = ["éléphant", "biche", "rhinocéros", "brochet"]
for animal in animaux :
print(animal)
print("C’est fini !")
6.1
Programme-type n°1 : compter les éléments d’une liste satisfaisant certains critères
Exemple : compter les acides aminés aromatiques d’une protéine :
proteine = "MIWRAVHRF..."
nb_aromatique = 0
for aa in proteine :
if (aa == "F") or (aa == "Y") or (aa == "W") or (aa == "H"):
nb_aromatique = nb_aromatique + 1
print(str(nb_aromatique) + " acides aminés aromatiques dans la protéine")
On définit une variable “compteur” (appelé “nb aromatique” dans l’exemple ci-dessus) qui vaut zéro. Puis on parcourt la
liste (ici, la chaı̂ne de caractères “proteine” est utilisée comme liste) et on augmente de 1 le compteur pour chaque élément
satisfaisant les critères désirés.
6.2
Programme-type n°2 : garder seulement les éléments d’une liste satisfaisant certains
critères
Exemple : garder seulement les nombres pairs d’une liste :
nombres = [1, 4, 7, 8, 12, 15]
nombres_pairs = [ ]
for nombre in nombres :
if nombre % 2 == 0 : # Teste si le nombre est pair
nombres_pairs.append(nombre)
print(nombres_pairs)
On définit une nouvelle liste (appelée “nombres pairs” dans l’exemple ci-dessus) qui est initialement vide. Puis on parcourt
la liste et on ajoute les éléments satisfaisant les critères désirés dans la nouvelle liste.
6.3
Programme-type n°3 : créer une nouvelle liste (ou chaı̂ne de caractères) à partir d’une
liste existante
Exemple : calculer un ADN complémentaire :
adn = "GCATTC" # Placer ici l’ADN dont on veut calculer le complément
adn_complementaire = "" # Cha^
ıne vide
for base in adn :
if
base == "A" : base_complementaire = "T"
elif base == "T" : base_complementaire = "A"
elif base == "C" : base_complementaire = "G"
elif base == "G" : base_complementaire = "C"
adn_complementaire = adn_complementaire + base_complementaire
print(adn_complementaire)
On définit une nouvelle liste ou chaı̂ne de caractère (une chaı̂ne appelée “adn complémentaire” dans l’exemple ci-dessus) qui
est initialement vide. Puis on parcourt la liste et on complète la nouvelle liste ou chaı̂ne au fur et à mesure.
6.4
Boucler sur plusieurs listes avec zip()
La fonction zip() permet de boucler sur deux (ou plusieurs) listes, lorsque les listes sont appariées. Dans l’exemple suivant
nous avons une liste d’animaux et une liste d’environnements appariées, c’est-à-dire que l’animal n°1 va avec l’environnement
n°1, le n°2 avec le n°2, etc.
animaux = ["éléphant", "biche", "rhinocéros", "brochet"]
environnements = ["savane", "for^
et", "savane", "rivière"]
for animal, envir in zip(animaux, environnements):
print(animal + " vit dans " + envir)
Ce qui donne :
éléphant vit dans savane
biche vit dans for^
et
rhinocéros vit dans savane
brochet vit dans rivière
7
6.5
Boucler sur plusieurs listes avec des boucles imbriquées
Les boucles imbriquées permettent de parcourir tous les couples possibles issus de deux listes (couple (a,b) où les a
proviennent d’une liste et les b d’une autre). Par exemple pour parcourir tous les couples (animal, environnement) possible :
animaux = ["éléphant", "biche", "rhinocéros", "brochet"]
environnements = ["savane", "for^
et", "rivière"]
for animal in animaux:
for envir in environnements:
print(animal + " dans " + envir)
Ce qui donne :
éléphant dans savane
éléphant dans for^
et
éléphant dans rivière
biche dans savane
biche dans for^
et
biche dans rivière
rhinocéros dans savane
rhinocéros dans for^
et
rhinocéros dans rivière
brochet dans savane
brochet dans for^
et
brochet dans rivière
7
Importer des modules Python
Les modules Python définissent des fonctions additionnelles dans des domaines spécifiques (tels que les mathématiques, la
bioinformatique,...). Ces fonctions ne sont pas disponibles par défaut, il est nécessaire “d’importer” le module correspondant
pour y avoir accès.
Il existe deux méthodes pour importer les modules, par exemple sur le module math :
1. Importation du module avec son nom :
import math
print(math.cos(0.0))
Avec cette méthode, il est nécessaire de taper le nom du module suivi d’un . devant chacune des fonctions du module.
2. Importation du contenu du module :
from math import *
print(cos(0.0))
Avec cette méthode, il n’est plus nécessaire de taper le nom du module devant chaque fonction ; en revanche si plusieurs
modules définissent des fonctions ayant le même nom, cela peut poser problème !
Note si l’on utilise plusieurs fonctions du même module, on ne l’importe qu’une seule fois ! Les importations se mettent
en général au tout début des programmes.
7.1
Module math
Le module math contient des fonctions mathématiques de bases :
>>>
>>>
>>>
>>>
>>>
7.2
import math
math.sqrt(4) # Racine carrée
math.cos(0.0), math.sin(0.0), math.tan(0.0)
math.log(2.0) # ln
math.log(2.0, 10) # log de base 10
Module Bio : chargement de séquences biologique
Le module BioPython (abrégé en Bio) permet de charger des séquences biologiques à partir de fichiers FASTA ou de
serveurs Internet. Bien d’autres fonctions sont disponibles, nous en verrons quelques-unes dans les prochains TP.
8
7.2.1
À partir d’un fichier FASTA
from Bio.Seq import *
from Bio.SeqIO import *
seq = read("fichier.fasta", format = "fasta").seq
Où l’on remplace ”fichier.fasta” par le nom du fichier FASTA à ouvrir.
7.2.2
À partir du serveur Entrez
from Bio.Seq import *
from Bio.SeqIO import *
from Bio import Entrez
Entrez.email = "[email protected]"
seq = read(Entrez.efetch(db="<DB>", id="<ID>", rettype="gb", retmode="text"), "genbank").seq
Où l’on remplace <DB> par le nom de la base à interrogée (par exemple ”nucleotide” ou ”protein”) et <ID> par l’identifiant
de la séquence recherchée (par exemple ”CAA11404”).
Note il est nécessaire de donner un email au serveur Entrez, afin de pouvoir être prévenu en cas de problème.
7.3
Installation des modules
Tous les modules nécessaires aux TP sont installés à l’université. Pour les installer chez vous, sous Linux, exécuter la ligne
de commande suivante dans un terminal :
pip2 install biopython setuptools six numpy pandas scipy matplotlib graphviz seaborn
fisher mygene pysam DGEclust mgkit goatools
Ou en Python (souvent plus facile sous Windows, par exemple dans IDLE) :
>>> import pip
>>> pip.main(["biopython", "setuptools", "six", "numpy", "pandas", "scipy", "matplotlib",
"graphviz", "seaborn", "fisher", "mygene", "pysam", "DGEclust", "mgkit", "goatools"])
8
Exercices
Exercice 1 (conditions) : identification des champignons
On souhaite réaliser un programme Python permettant d’identifier des champignons. Afin de rester simple, nous nous
limiterons au petit nombre d’espèces de champignon suivant :
— Les Ascomycètes (sans chapeau), comprenant :
— Les morilles (avec pied)
— Les truffes (sans pied)
— Les Basidiomycètes (avec chapeau), comprenant :
— Les bolets (sans lamelle)
— Les autres champignons (avec lamelles)
Le programme posera à l’utilisateur des questions de la forme “Le champignon a-t-il un chapeau (o/n) ?”, via la fonction
raw input().
On commencera par faire la distinction entre Ascomycètes et Basidiomycètes, puis entre morilles et truffes (pour les
Ascomycètes) et enfin entre bolets et autres champignons (pour les Basidiomycètes).
Exercice 2 (boucles) : calculer le pourcentage de GC
Écrire un programme Python qui calcule le pourcentage de GC dans une séquence d’ADN (on testera le programme sur
la séquence suivante : ACTTGCATGGCC).
Exercice 3 : générer un Dotplot
Nous allons écrire un programme Python pour effectuer le Dotplot entre deux séquences. Le Dotplot sera écrit avec la
fonction print(), et chaque valeur sera séparée de la suivante par une virgule, par exemple :
,A,C,T,T,G,C,A,T,G,G,C,C,
T, , ,X,X, , , ,X, , , , ,
T, , ,X,X, , , ,X, , , , ,
G, , , , ,X, , , ,X,X, , ,
9
C, ,X,
A,X, ,
A,X, ,
G, , ,
G, , ,
C, ,X,
C, ,X,
,
,
,
,
,
,
,
, ,X, ,
, , ,X,
, , ,X,
,X, , ,
,X, , ,
, ,X, ,
, ,X, ,
, , ,X,X,
, , , , ,
, , , , ,
,X,X, , ,
,X,X, , ,
, , ,X,X,
, , ,X,X,
Cela correspond au format CSV (column-separated value, valeur séparée par des virgules), ce qui permettra ensuite de charger
le fichier dans un tableur pour l’observer plus facilement. On utilisera dans un premier temps les séquences suivantes :
seq1 = "TTGCAAGGCC"
seq2 = "ACTTGCATGGCC"
1. Écrire un programme qui affiche la première ligne du Dotplot ci-dessous (qui compare la séquence 2 à la première
base de la séquence 1 : T). Pour l’instant, nous laisserons de côté l’affichage des séquences pour afficher seulement :
, ,X,X, , , ,X, , , , ,
Conseil : on utilisera une boucle sur la séquence 2. On commencera avec une ligne vide (ligne = ””) que l’on remplira
progressivement. Lorsque la ligne est terminée, on l’écrit avec print().
2. Modifier le programme précédent pour qu’il écrive toutes les lignes (on ajoutera une seconde boucle).
3. Modifier le programme précédent pour faire apparaı̂tre les séquences en haut et à gauche du Dotplot.
4. Modifier le programme pour effectuer un Dotplot comparant les séquences peptidiques de la thiorédoxine provenant
des organismes Staphylococcus aureus (identifiants Entrez : CAA11404) et Helicobacter pylori 51 (ACX97712).
On enregistrera la sortie du programme dans un fichier .csv de la manière suivante :
python2 dotplot.py > dotplot_thioredoxine.csv
5. Ouvrir le fichier .csv obtenu (dans OpenOffice) et interpréter le Dotplot.
6. Modifier le programme pour effectuer un Dotplot comparant la séquence “minisatellite” de la drosophile (Drosophila
mauritiana) à elle-même (identifiants Entrez : M62837).
7. Interpréter le Dotplot obtenu.
Exercice 4 : mettre une séquence en couleur
Écrire un programme qui met en couleur une séquence d’ADN, avec les couleurs suivantes : A : vert, T : rouge, C : bleu,
G : jaune.
Pour cela, le programme écrira (avec print()) une page HTML avec la séquence colorisée. On pourra s’aider de la page
HTML minimaliste suivante :
<html><head></head><body>
Texte <font color=’red’>en couleur</font>
</body></html>
On “redirigera” ensuite la sortie du programme vers un fichier .html puis on ouvrira ce fichier dans un navigateur web.
10