cours

Thème: Génomique et Analyse de séquences biologiques (Semaines 6 à
7)
L'analyse des séquences biologiques a connu ces dix dernières années un essor considérable avec
l’apparition du séquençage massif d'organismes, et de grandes bases de données génomiques.
L’exploitation de ces gigantesques bases a motivé le développement de modèles mathématiques ou
informatiques pour l’analyse automatique de ces séquences. Après une présentation des principales
macromolécules biologiques et leur fonction dans la cellule, ce cours décrit les méthodes et les outils
les plus communément utilisés pour analyser les séquences biologiques : recherche de signaux et de
zones codantes, techniques d’alignement (programmation dynamique), recherche de similarités
locales entre séquences. L’utilisation de ces outils sera illustrée sur des problèmes types comme la
comparaison de séquences, la recherche d’homologies, la prédiction. Différents programmes
d’analyse sont aujourd’hui accessibles par le web et seront utilisés aux TP.
Le cours illustrera quelques-uns des développements informatiques nouveaux nécessaires au
traitement et à la manipulation des données correspondantes.
PréTP (initiation à python)
(note: passer sous tcsh au CICRP !!!)
Générer un tableau de distance entre villes (plusieurs catégories de villes)
Programmation dynamique – Camions (tranches)
Présentation du langage Python – langage interprété interactif
Variables: type implicite
liste, tuple et string sont des séquences.
Indentation délimite les blocs d'instructions – instruction vide "pass"
Listes:
a = [] # déclaration d'une liste
Les listes commencent à 0, coordonnées négatives == permutations circulaires –1 == dernière case
(maximum négatif = -longueur, dernière case +1 : erreur,, types différents autorisés. Donc les
coordonnées vont de –longueur à +(longueur –1)
>>> a.append(3)
>>> a.append("toto")
>>> a.append("tutu")
>>> a.append("titi")
>>> a
[3, 'toto','tutu','titi']
a[1:3] # extrait sous liste éléments 1 à 3
['toto','tutu']
a = {} # création d'un tableau associatif qui peut être indexé par string,
entier ou tuple
a["toto"] = "TITI"
a[("toto","titi")] = "TOTOTITI"
a[("toto","tutu")] = "TOTOTUTU"
for i in liste: # i prend successivement les valeurs de la liste

for i in xrange(debut, fin, step):
# i prend les valeurs de "debut à ("fin"-1) par pas de "step".
>>> for i in xrange(1,6,2):
... print i
...
1
3
5
while <test> :
def foo(arguments):
# indentation nécessaire
def plus(a,b):
return a+b
def carre(a):
return a*a
liste=range(4)
liste
[0, 1, 2, 3]
# lister les methodes liees a un objet
dir(liste)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__eq__',
'__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__',
'__hash__', '__iadd__', '__imul__', '__init__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__repr__', '__rmul__',
'__setattr__', '__setitem__', '__setslice__', '__str__', 'append', 'count',
'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
reduce(plus,liste) # f(f(f(liste[0],liste[1]),liste[2]), liste[3])..etc
6
map(carre,liste)
[0, 1, 4, 9]
map(plus, liste,liste)
[0, 2, 4, 6]
map(None, liste1,liste2): applique None aux doublets d'une liste constituée de
chacune des paires des éléments de liste1 et liste2
filter(f,liste): retourne la sous liste de liste constituée de chacun des
éléments pour lesquels f est vraie.
## Lecture fichiers:
>>>f=open('nom_fichier','r') # ouvre le fichier en lecture avec descripteur f
>>>l=f.readlines() # lit toutes les lignes et crée une liste
## Ecriture fichiers:
f=open("nom_fichier","w")
f.write("%d %f " % (1, random.random()))

## Librairie "string"
>>>import string
>>>l = "toto titi tutu"
>>> string.split(l)
['toto', 'titi', 'tutu']
## Nombres aléatoires
>>> import random
>>> random.random()
0.0119499521299
# préparation du fichier de villes
g=open("villes","w")
lv=string.split("a b1 b2 b3 b4 c1 c2 c3 c4 d1 d2 d3 e1 e2 e3 e4 e f1 f2 f3 g")
c={}
c["a"]=1
c["b"]=2
c["c"]=3
c["d"]=4
c["e"]=5
c["f"]=6
c["g"]=7
for x in lv:
for y in lv:
if c[x[0]]==c[y[0]]-1:
g.write("%s %s %f " % (x,y,int(100*random.random()))
g.close()
bubble, mergesort
ouvrir un texte (nedit) pour le programme "tri.py"
import tri # la première fois
reload(tri) # les autres fois
import random # création du fichier de nombres aléatoires
f=open("random","w")
i = 0
while i < 100:
f.write("%d %f " % (i, random.random()))
i=i+1
f.close()
f=open("random","r") # lecture du fichier de nombres aléatoires
ll=f.readline() # ll est une string avec toutes les valeurs
t=[] # création du tableau de valeurs
for x in string.split(ll):
t.append(string.atof(x))
Excercice: programmation dynamique
camions (programmation dynamique). liens avec les séquences

fichier "lv"
paris lyon 23
paris dijon 32
paris clermont 29
paris bordeaux 34
lyon valence 13
dijon valence 34
clermont valence 29
bordeaux valence 22
lyon cahors 22
dijon cahors 14
clermont cahors 19
bordeaux cahors 17
lyon millau 22
dijon millau 16
clermont millau 23
bordeaux millau 19
valence marseille 21
cahors marseille 27
millau marseille 18

#!/usr/local/bin/python2.1
import string
import copy
def camion():
f=open('lv','r')
lignes=f.readlines() # lignes: liste de string
t=[]
for l in lignes:
t.append(string.split(l))
distance={}
for i in t:
distance[(i[0],i[1])]=int(i[2])
print distance
tranche=[]
vd=string.split(l[0])[0]
tranche=[[vd]]
print tranche
courant=tranche[0]
while len(courant)!=0:
tmp=[]
for x in distance.keys():
if x[0]==courant[0]:
tmp.append(x[1])
if len(tmp)!=0:
tranche.append(tmp)
courant=tmp
print tranche
chemin=[(0,[vd])]
for x in tranche[1:]: # x: tranches successives
newchem=[]
for k in x: # k: villes successives
mini=distance[(chemin[0][1][-1],k)]+chemin[0][0]
for z in chemin: # z: chemins successifs
if (distance[(z[1][-1],k)]+z[0]<=mini):
mini=distance[(z[1][-1],k)]+z[0]
y=copy.deepcopy(z)
y[1].append(k)
newchem.append((mini,y[1]))
chemin=newchem
print newchem
Cours 1 (2 heures):
1ère partie: le problème biologique (1h15)
Cellules procaryotes et eucaryotes : différences, ressemblances, chromosomes, machinerie cellulaire
Les macromolécules biologiques (polymères), structure, forme et information : reconnaissance
moléculaire (acides nucléiques, protéines), localisation cellulaire, fonctions.
Mécanismes génétiques fondamentaux :
- ADN support de l'information génétique : structure de l'ADN,
- polymère de nucléotides