decoupage des sequences de fichier fasta

Version imprimable

Bonjour,
je veux connaitre comment programmer en python ce probleme?
Si j'ai un fichier fasta qui contient des sequences d'ADN et je veux appliquer quelque operations sur ce dernier.
je swuppose que mon fichier contient 100 sequences d'ADN , à chaque fois je prend 3 sequences et j'applique des fonctions sur les 3 sequences.lorsque je termine je prend autre 3 sequences, c'est à dire:de 1 à 100 je fait la meme chose por 100 sequences. sachant que chaque sequence a une longueur L.
n=100 (nombre de sequences).
Code:

1 2 3 4 5 6 7 8 9 10 11 pour i=1 à 100 faire: prendre 3 sequences pour j=1 à 3 faire: decouper la longuer chaque sequence pour obtenir des sous-sequences (par example L= 15, 15/3=5,on obtient 5 sous-sequences) prendre le premier sous-sequence de chaque sequence appliquer les fonctions faire la meme chose pour le reste des sous-sequences fin pour fin pour fin pour
aidez moi

Il manque beaucoup de données pour pouvoir vraiment répondre ...
Notamment : tu prends quelles 3 séquences à chaque fois ? Tu fais quoi de tes séquences auquelles tu as appliqué tes fonctions ? Voire : quelles fonctions tu appliques sur tes séquences, que retournent tes fonctions, etc.

Je peux proposer ça vite fait (non vérifié) :

Code:

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
# On récupère les séquences, en supposant que ton fichier "fasta" est en ascii
# et qu'il y a une séquence par ligne
liste_adn = list()
with open("fichier_fasta", "r") as fichier :
    for ligne in fichier :
        liste_adn.append(ligne)
 
# On boucle sur tes fonctions       
for i in range(100) :
    # Là t'es pas clair. Tu veux prendre quelles 3 séquences ?
    # Je pars du principe que tu prends la ième et les 2 suivantes à chaque fois
    # et pour les 2 dernières que tu combines avec le début
    if i < 98 :
        triple_sequence = liste_adn[i:i+3]
    elif i == 98 :
        triple_sequence = liste_adn[i:i+1]
        triple_sequence.append(liste_adn[0])
    else :
        triple_sequence = liste_adn[i]
        triple_sequence.append(liste_adn[0])
        triple_sequence.append(liste_adn[1])
 
    sous_sequence = list()
    for j in triple_sequence :
        for k in range(5) :
            # On découpe en 5 morceaux qu'on place dans une liste (si la longueur est de 15)
            sous_sequence.append(j[3*k+1:3*k+4))
    for k in range(5) :
        Ta_fonction(sous_sequence(k), sous_sequence(k+5), sous_sequence(k+10))
    # Je sais pas ce que tu veux faire de tes sous-séquences mélangées ...
    # Tu les remets dans les séquences du début ?

11/09/2013, 22h39
rosef

OK, merci pour la reponse

voici un example:
je suppose que mon fichier fasta contient ces sequences:
tatctattaccc
gctgcgataagc
tcctacttttgt
caggaaaagaaa
actgaatccctt
ctgaagttgact
aggtttgaagtg
aacttccaactc
gaaaagcaccct

d'abord je prend les trois premier sequences
tatctattaccc
gctgcgataagc
tcctacttttgt
je decoupe ces sequences en sous-sequences:
tat cta tta ccc
gct gcg ata agc
tcc tac ttt tgt

Ensuite, je prend par example les deux premier sous-sequences de chaque ligne comme suit:
tat cta
gct gcg
tcc tac
par example la fonction à appliquer est: de comparer les sous-sequences(similarité) tat est similaire à cta gct gcg
tcc tac ou non ; si je termine je prend le reste de sous-sequences
tta ccc
tta agc
tcc tac

j'applique les meme etapes .

Puis,je prend le reste de sequences:
caggaaaagaaa
actgaatccctt
ctgaagttgact
aggtttgaagtg
aacttccaactc
gaaaagcaccct

je prend 3 sequences et faire la meme chose, refaire ça avec le reste de sequences.

Ok, du coup, le nouveau code reste sensiblement similaire. Une nouvelle version :

Code:

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
35
36
37
38
# On récupère les séquences, en supposant que ton fichier "fasta" est en ascii
# et qu'il y a une séquence par ligne
liste_adn = list()
with open("fichier_fasta", "r") as fichier :
    for ligne in fichier :
        liste_adn.append(ligne)
 
# On boucle sur tes fonctions       
for i in range(33) :
    # Sauf que 100 divisé par 3 ... A la fin tu vas avoir une sequence toute seule.
    # Tu veux la gérer comment ? La comparer avec quoi ?
    if i < 99 :
        triple_sequence = liste_adn[3*i:3*i+3]
    else :
        # Donc là, à toi de voir ce que tu veux faire de la dernière
        pass
 
    sous_sequence = list()
    for j in triple_sequence :
        for k in range(4) :
            # On découpe en 4 morceaux qu'on place dans une liste (si la longueur est de 12)
            sous_sequence.append(j[3*k+1:3*k+4))
    is_similar_rouge = [["rouge", i, i+1, i+2]] # Pour la comparaison des rouges
    is_similar_vert = [["vert", i, i+1, i+2]] # Pour la comparaison des verts
    # Je te mets en premier élement de la liste les numéros des séquences comparées
    for k in [1, 4, 5, 8, 9] :
        if sous_sequence[0] == sous_sequence[k] :
            is_similar_rouge.append(True)
        else :
            is_similar_rouge.append(False)
    for k in [3, 6, 7, 10, 11] :
        if sous_sequence[2] == sous_sequence[k] :
            is_similar_vert.append(True)
        else :
            is_similar_vert.append(False)
 
    print is_similar_rouge
    print is_similar_vert

24/09/2013, 09h22
Aegim

Je maintiens mon dernier exemple. Il y a de légères modifications à y apporter selon les fonctions que tu veux appliquer, ou la taille de ton fichier, mais dans l'architecture globale, il correspond à ce que tu veux (ou alors j'ai mal compris). A toi après de faire ces modifications minimes (la plupart du temps, juste un indice à changer) et spécifiques à ton vrai fichier. Même avec de faibles connaissances en python, ce ne devrait pas être un gros problème je pense.
24/09/2013, 11h16
fred1599

Vous connaissez le module textwrap, ça peut être sympa dans votre exercice.
24/09/2013, 11h23
Aegim

Je ne connaissais pas, et après avoir survolé la doc que tu nous a link, ça pourrait en effet s'avérer pratique ici. Merci :)