correction. - Enseignements informatiques et mathématiques en

Module LV348
Version enseignant
TD 1 – page 1/7
TD 1 Biais de codons
Revu dernièrement par Mathilde Carpentier, Cyril Gallut et Joël Pothier
Version du 15 janvier 2014
L’objectif de ce TP est de prendre en main le langage python et de revoir quelques notions fondamentales sur l’ADN (complémentarité, phase de lecture, traduction et usage du code génétique.
La question biologique posée porte sur l’usage du code génétique.
1
Les données
Nous allons travailler sur le génome complet de la bactérie Escherichia coli. Nous allons télécharger son génome complet sur le site ftp du NCBI ftp://ftp.ncbi.nlm.nih.gov/.
Ce serveur propose les génomes de très nombreux organismes. Il y a en effet maintenant environ
1000 génomes complets séquencés, et des millions de séquences dispersées. Différents fichiers sont
proposés pour chaque génome, ils correspondent à différents formats des données. Nous allons utiliser
le fichier .fna, c’est-à-dire la séquence nucléique du génome complet au format fasta. L’adresse du fichier est : ftp://ftp.ncbi.nlm.nih.gov/genomes/Bacteria/Escherichia_coli_
K_12_substr__MG1655/NC_000913.fna 1
Le format fasta est un format texte pour les séquences nucléiques (ADN) ou protéiques. Une
séquence de ce format comporte une ligne de description commençant par un ">" puis les lignes de
la séquence. La fin d’une séquence est atteinte lorsque la fin du fichier est atteinte ou lorsqu’une autre
séquence commence, c’est-à-dire que l’on rencontre une ligne commençant par un ">". La ligne de
description comporte un identifiant de la séquence dans la banque d’où elle provient.
Exemple de séquence au format fasta :
>NC_010473|:163816-163951|small RNA| [gene=tff] [locus_tag=ECDH10B_0148]
CGGACTTCCGATCCATTTCGTATACACAGACTGGACGGAAGCGACAATCTCACTTTGTGTAACAACACAC
ACGTATCGGCACATATTCCGGGGTGCCCTTTGGGGTCGGTAATATGGGATACGTGGAGGCATAACC
2
Exercices
Tous les exercices sont à faire en python.
2.1
Lecture des fichiers
Ecrivez une fonction python permettant de lire un fichier fasta ne contenant qu’une séquence et
qui retourne la séquence lue sous la forme d’une chaî,e de caractères..
Solution :
Présentation de python : fonction, for, ouverture, fermeture et lecture de fichier.
1. Il vaut mieux ne pas prendre ...Escherichia_coli_K_12_substr__DH10B/NC_010473.fna car elle
contient un Y
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014
Module LV348
1
2
3
4
5
6
7
8
9
10
Version enseignant
TD 1 – page 2/7
# lecture d’un fichier au format fasta
# version 1: la sequence est
#recuperee sous la forme d’une chaine de caracteres
#-----------------------------------------------------------------------def readFasta(file):
infile=open(file, ’r’)
seq=""
name = ""
tmp=infile.readlines()
infile.close()
11
#name =tmp[0][1:-1] # pour eliminer le > du debut et le \n de fin
for x in tmp[1:] :
seq=seq+x[:-1]
12
13
14
15
#return (name,seq) # la fonction retourne le nom et la sequence
return seq # la fonction retourne la sequence
16
17
./code/lecture.py
2.2
Le brin complémentaire
Comme vous l’avez peut être remarqué, il n’y a qu’un seul des deux brins d’ADN dans le fichier fasta. Ecrivez une fonction python retournant le brin complémentaire d’une séquence nucléique
donnée en argument.
Solution :
Python : while et dictionnaire
Bio : complémentarité des brins
1
2
3
4
5
6
7
8
9
# donne le complementaire inverse de la sequence seq
def complement(seq):
compl = {’A’:’T’,’C’:’G’,’G’:’C’,’T’:’A’}
cseq=’’
i = len(seq) -1
while i >= 0 :
cseq = cseq + compl.get(seq[i], ’N’)
i -= 1
return cseq
./code/complementaire.py
2.3
Détection des CDS
Ecrivez une fonction python qui retourne la liste de toutes les sous séquences commençant par le
codon "start" et se terminant par un codon "stop" en phase (n’oubliez pas le brin complémentaire).
Ces séquences sont nommées CDS (Coding sequences).
Note : Si plusieurs start sont trouvés dans la même phase de lecture avant un stop, le CDS débute au
premier start ; les CDS peuvent se chevaucher (sur différentes phases, et éventuellement sur le brin
d’ADN complémentaire),
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014
Module LV348
Version enseignant
TD 1 – page 3/7
Solution :
Encore des dico, introduction des autres types énumérés : liste et tuple .
Question plus bio : les phases de lectures, détection des CDS.
Pour info, les ORFs sont les séquences entre 2 STOP en phase et non un START et un STOP
C’est le premier algo un peu compliqué, bien y réfléchir.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Retourne la liste des orf de la seq
#
def findorf(seq):
start = ("ATG")
stop = ("TAA","TAG","TGA")
startlist = [-1,-1,-1]
orflist = []
for i in range(len(seq)-2):
if seq[i:i+3] in start:
if startlist[i%3] == -1:
startlist[i%3] = i
elif seq[i:i+3] in stop:
if startlist[i%3] != -1:
# Attention n’inclus pas le stop
orflist.append(seq[startlist[i%3]:i])
startlist[i%3] = -1
return orflist
./code/orf.py
2.4
Traduction
Ecrivez une fonction python qui à partir d’une séquence nucléique retourne la séquence protéique
correspondante (en utilisant le code génétique à une lettre qui vous a été donné et qui se trouve au lien
suivant : http://www.snv.jussieu.fr/bmedia/codegenet/CodeGenet.htm).
Solution :
Cette fonction ne nous servira pas vraiment mais elle permet d’introduire le code génétique et de
parler de redondance.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# effectue la traduction de la sequence seq
def traduction(seq):
code = {"TTT":"F","TTC":"F","TTA":"L","TTG":"L","TCT":"S","TCC":"S",
"TCA":"S","TCG":"S","TAT":"Y","TAC":"Y","TAA":"*","TAG":"*",
"TGT":"C","TGC":"C","TGA":"*","TGG":"W","CTT":"L","CTC":"L",
"CTA":"L","CTG":"L","CCT":"P","CCC":"P","CCA":"P","CCG":"P",
"CAT":"H","CAC":"H","CAA":"Q","CAG":"Q","CGT":"R","CGC":"R",
"CGA":"R","CGG":"R","ATT":"I","ATC":"I","ATA":"I","ATG":"M",
"ACT":"T","ACC":"T","ACA":"T","ACG":"T","AAT":"N","AAC":"N",
"AAA":"K","AAG":"K","AGT":"S","AGC":"S","AGA":"R","AGG":"R",
"GTT":"V","GTC":"V","GTA":"V","GTG":"V","GCT":"A","GCC":"A",
"GCA":"A","GCG":"A","GAT":"D","GAC":"D","GAA":"E","GAG":"E",
"GGT":"G","GGC":"G","GGA":"G","GGG":"G"}
tradseq = ’’
for i in range(0,len(seq)-2,3):
tradseq += code.get(seq[i:i+3], ’X’)
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014
Module LV348
Version enseignant
TD 1 – page 4/7
return tradseq
17
./code/traduction.py
2.5
Usage des codons
Ecrivez un programme python qui calcule la fréquence d’utilisation de chaque codon pour chaque
acide aminé d’une liste de séquences nucléiques donnée en argument. Appliquez là aux CDS détectées.
Par exemple, l’usage des codons pour les cds détectées sur le génome d’E. coli que vous avez
téléchargé est
A
GCA: 22.47% GCC: 26.81% GCG: 33.03% GCT: 17.70%
Solution :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# calcul la frequence de chaque codon par acide amine
def calcul_freq_codon_aa(lesSeq):
freq_par_aa = {
"A":{"GCT":0,"GCC":0,"GCA":0,"GCG":0},
"C":{"TGT":0,"TGC":0},
"D":{"GAT":0,"GAC":0},
"E":{"GAA":0,"GAG":0},
"F":{"TTT":0,"TTC":0},
"G":{"GGT":0,"GGC":0,"GGA":0,"GGG":0},
"H":{"CAT":0,"CAC":0},
"I":{"ATT":0,"ATC":0,"ATA":0},
"K":{"AAA":0,"AAG":0},
"L":{"CTT":0,"CTC":0,"CTA":0,"CTG":0,"TTA":0,"TTG":0},
"M":{"ATG":0},
"N":{"AAT":0,"AAC":0},
"P":{"CCT":0,"CCC":0,"CCA":0,"CCG":0},
"Q":{"CAA":0,"CAG":0},
"R":{"AGA":0,"AGG":0},
"R":{"CGT":0,"CGC":0,"CGA":0,"CGG":0},
"S":{"TCT":0,"TCC":0,"TCA":0,"TCG":0,"AGT":0,"AGC":0},
"T":{"ACT":0,"ACC":0,"ACA":0,"ACG":0},
"V":{"GTT":0,"GTC":0,"GTA":0,"GTG":0},
"W":{"TGG":0},
"Y":{"TAT":0,"TAC":0}}
#1) compter les codons
codon={}
for s in lesSeq:
for i in range(0,len(s)-2,3):
if s[i:i+3] in codon :
codon[s[i:i+3]]+=1
else :
codon[s[i:i+3]]=1
#2) Calculer les frequences par aa
for aa in freq_par_aa :
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014
Module LV348
Version enseignant
TD 1 – page 5/7
freqtotal = 0.0
# calcul la frequence cumulee des codon par aa pour normaliser
for cod in freq_par_aa[aa] :
freqtotal += codon[cod]
# calcul la frequence de chaque codon par acide amine
for cod in freq_par_aa[aa] :
freq_par_aa[aa][cod] = (codon[cod]/freqtotal)*100
return freq_par_aa
35
36
37
38
39
40
41
42
./code/usage_codon.py
3
Bonus
Ecrivez un programme python qui calcul le Nc (effective number of codons) pour les CDS détec-
tés.
Ecrivez un programme python qui calcul le CAI (codon adaptation index) pour les CDS détectés.
Comparez les valeurs.
3.1
Conclusion
Observez la distribution globale des codons, la composition globale des séquences en acides aminés (faire des graphiques à l’aide de gnuplot ou d’un tableur). Sachant que le code génétique est
redondant, nous voulons analyser si les codons codant pour un même acide aminé sont utilisés de manière aléatoire ou non. Calculez aussi l’usage global des codons pour chaque acide aminé, c’est-à-dire
le pourcentage de chaque codon possible pour un acide aminé. L’usage des codons vous semble-t-il
uniforme pour chaque acides aminé ? Question subsidiaire : comment vérifieriez-vous statistiquement
cette hypothèse de non-uniformité ? Faites le si possible.
Pour conclure, il est conseillé de lire la page : http://fr.wikipedia.org/wiki/Biais_
d’usage_du_code
Solution :
Toutes les fonctions python sont dans TD1_Corrections.py dans le répertoire code
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
import getopt
import sys # permet la lecture des arguments de la ligne de commande.
import math # permet d’utiliser les fonctions math (pow)
7
8
9
10
11
12
13
14
from
from
from
from
from
from
from
ORF import *
complementaire import *
compoAA import *
compte_codon import *
lecture import *
traduction import *
usage_codon import *
15
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014
Module LV348
16
Version enseignant
TD 1 – page 6/7
#
###############################################################################
17
18
################################### main
#######################################
def main():
19
20
21
22
23
24
#
#
#
#
25
26
27
opt, args = getopt.getopt(sys.argv[1:], "h", ["help"])
for o, a in opt:
if o in (’-h’, ’--help’):
print aide
return 0
if len(sys.argv) <= 1:
print "Veuillez donner un fichier fasta en entree"
return 0
28
29
30
31
32
33
#
#
#
#
#
if len(sys.argv) == 1:
c
print "Bienvenue. Veuillez indiquer le nom d’une banque de sÃquences
au format FASTA (nom du fichier ) :"
banque_nom = raw_input()
else:
banque_nom = sys.argv[1]
34
35
infile = sys.argv[1]
la ligne de commande
# recupere le nom du fichier a partir de
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#QUESTION 1
ns = readFasta(infile)
# lit la sequence dans le fichier fasta
#QUESTION 2
c_ns = complement(ns)
# calcul la sequence inverse
complementaire
#QUESTION 3
orfs = findorf(ns)
# recherche les orfs dans la sequence
orfs.extend(findorf(c_ns))
# recherche les orfs dans la sequence
inverse complementaire
print "Nombre d’orfs : direct, inverse"
print len(orfs)
#print orfs
#QUESTION 4
print "Exemple d’une orf traduite"
print traduction(orfs[1])
#QUESTION 5
freq_codon_aa=calcul_freq_codon_aa(orfs)
print
53
54
55
56
57
58
59
60
61
print "Usage des codons par acide amine :"
for aa in sorted(freq_codon_aa.keys()):
tmp = ’’
for codon in sorted(freq_codon_aa[aa]):
tmp = tmp + ’ %s: %.2f%s’ % (codon, freq_codon_aa[aa][codon], ’%’)
print aa, tmp
print
62
63
64
if __name__ == "__main__":
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014
Module LV348
65
Version enseignant
TD 1 – page 7/7
sys.exit(main())
./code/TD1_CorrectionExos.py
Solution :
Il y a aussi des calculs de CAI dans /code/CAI.py.
c
2013-2014
(by UPMC/Licence de biologie/LV348)
15 janvier 2014