decoupage des sequences de fichier fasta

**rosef** · 11/09/2013, 00h04

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Aegim** · 11/09/2013, 13h55

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

**rosef** · 11/09/2013, 22h39

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.

**Aegim** · 12/09/2013, 10h17

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Aegim** · 24/09/2013, 09h22

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.