Discussion :

[glageosa]

Bonjour,
Alors voilà comme dit dans le titre mon objectif est de couper une séquence nucléotidique (chaîne de caractères avec que des A,T,G ou C). Le problème c'est qu'il faudrait couper en deux la séquence mais par un multiple de 3 afin de ne pas couper un codon (représenté par 3 de ces 4 lettres). De plus, j'aimerais ne pas couper des suites de 'AAA' ou 'AAG' ou les deux en même temps, s'ils se retrouvent au milieu de la séquence. En revanche, s'il n'y a pas ces lettres au milieu de la séquence, il faudrait la couper en deux.
Voici une partie de mon code qui sert à regarder si un AAA, AAG ou les 2 en même temps sont au milieu de la séquence :

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
 
if 'AAA' in seq[i-2:i+3] or 'AAG' in seq[i-2:i+3]:
            l = 0
            for i in range(i-2, i+1):
                j = i
                while True:
                    if seq[i:j+3] in s:
                        j += 3
                    else:
                        if j > l:
                            l = j
                        break
            print(str(seq[:l]))
        else:
            if len(seq) % 2 == 0:
                print(seq[:len(seq) // 2])
            else:
                print(seq[:(len(seq) + 4) // 2])

Input :
ATGTGAGTCAAAAAATGCCTATGA
Output :
ATGTGAGTC AAAAAATGCCTATGA ou ATGTGAGTCAAAAAA TGCCTATGA
La longueur des suites successives de AAA ou AAG varie en fonction des séquences, on peut trouver des AAAAAA, des AAGAAG ou des AAAAAG (ou AAGAAA).

[wiztricks]

Salut,

Un truc comme çà peut être:

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
>>> seq = 'ATGTGAGTCAAAAAATGCCTATGA'
>>> frag = []
>>> cutoff = False
>>> for i in range(0, len(seq), 3):
...     s = seq[i:i+3]
...     if s in ('AAA', 'AAG'):
...         frag.append(s)
...         cutoff = True
...     else:
...         if cutoff:
...             print (''.join(frag))
...             cutoff = False
...             frag = []
...         frag.append(s)
...
ATGTGAGTCAAAAAA
>>> print(''.join(frag))
TGCCTATGA
>>>

- W

[glageosa]

Merci beaucoup, je crois que cela devrait le faire.

[glageosa]

Ah non en fait c'est pas tout à fait ça excuse moi, l'idée c'est de juste couper la séquence en deux et s'il y a un ployA alors il faut le mettre de coté, là ton algo coupe à chaque fois qu'il en voit un.

[BufferBob]

salut,

un truc dans ce style fait peut-être l'affaire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import re
 
def cut (seq, liste):
   middle = int(len(seq)/6)*3                            # le milieu de la sequence, aligné sur 3 nucléotides
   reg = re.compile(r'({})+'.format(r'|'.join(liste)))   # regex créée dynamiquement pour capter les codons à ne pas séparer
   for i in reg.finditer(seq):
      start = i.start()
      end = i.end()
      if start < middle < end:                           # le milieu calculé tombe en plein dans une suite de codons
         if (middle - start) <= (end - middle):          # on équilibre la taille des sous-séquences à renvoyer
            return (seq[:start], seq[start:])
         else:
            return (s[:end], s[end:])
   return (seq[:middle], seq[middle:])

on détermine le milieu (aligné sur 3 nucléotides) de la séquence initiale, et on compare ensuite avec la liste des (début,fin) de chaque suite de codons à ne pas séparer dans la séquence ("AAAAATAAA" par exemple)
si le milieu de la séquence qu'on a calculé tombe au milieu d'une séquence de codons, alors on s'arrange pour équilibrer le plus possible la taille des sous-séquences retournées

et le résultat :

Code :

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

1
2
3
4
5
6
7
8
>>> liste = ['AAA', 'AAT']
>>> cut('', liste)                              -->      ('', '')
>>> cut('AAA', liste)                           -->      ('', 'AAA')
>>> cut('TTC', liste)                           -->      ('', 'TTC')
>>> cut('TTCGAC', liste)                        -->      ('TTC', 'GAC')
>>> cut('AATAAA', liste)                        -->      ('', 'AATAAA')
>>> cut('ATGTGAGTCAAAAAATGCCTATGA', liste)      -->      ('ATGTGAGTC', 'AAAAAATGCCTATGA')
>>> cut('ATGTGAAAAAAAGTCTGCCTATGA', liste)      -->      ('ATGTGAAAAAAA', 'GTCTGCCTATGA')

[glageosa]

Merci tu as très bien compris ce que je voulais faire, cependant il reste un minuscule hic, est-ce qu'il cherche la regex en prenant compte du fait que c'est 3 par 3 ? Parce que j'ai un problème avec une séquence, il coupe 2 fois, une fois mal en voyant un AAG mais qui n'est pas dans le cadre de lecture (c'est-à-dire pas multiple de 3) et une dernière fois bien. Je m'en suis rendu compte en mettant un print à la place du return, et lorsque l'on met return il ne coupe cette séquence qu'une seule fois mais de la mauvaise façon. J'ai ensuite regardé l'exécution sur python tutor parce que je ne comprenais pas et j'ai remarqué que la première fois lorsqu'il coupe mal, il execute l'étape de rééquilibrage (print(seq[:start], seq[start:])) et quand il coupe bien il execute le dernier print (print(seq[:middle], seq[middle:]))
Merci à toi.