J'ai un programme qui analyse les séquences d'allèles. J'essaie d'écrire un code qui détermine si l'allèle est complet ou non. Pour ce faire, je dois compter le nombre de ruptures dans la séquence de référence. Une rupture est signifiée par une chaîne de «-». S'il y a plus d'une pause, je veux que le programme dise "Allèle incomplet".

Comment savoir comment compter le nombre de pauses dans la séquence?

Voici un exemple de séquence "interrompue":

>DQB1*04:02:01
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
--ATGTCTTGGAAGAAGGCTTTGCGGAT-------CCCTGGAGGCCTTCGGGTAGCAACT
GTGACCTT----GATGCTGGCGATGCTGAGCACCCCGGTGGCTGAGGGCAGAGACTCTCC
CGAGGATTTCGTGTTCCAGTTTAAGGGCATGTGCTACTTCACCAACGGGACCGAGCGCGT
GCGGGGTGTGACCAGATACATCTATAACCGAGAGGAGTACGCGCGCTTCGACAGCGACGT
GGGGGTGTATCGGGCGGTGACGCCGCTGGGGCGGCTTGACGCCGAGTACTGGAATAGCCA
GAAGGACATCCTGGAGGAGGACCGGGCGTCGGTGGACACCGTATGCAGACACAACTACCA
GTTGGAGCTCCGCACGACCTTGCAGCGGCGA-----------------------------
-----------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
---GTGGAGCCCACAGTGACCATCTCCCCATCCAGGACAGAGGCCCTCAACCACCACAAC
CTGCTGGTCTGCTCAGTGACAGATTTCTATCCAGCCCAGATCAAAGTCCGGTGGTTTCGG
AATGACCAGGAGGAGACAACTGGCGTTGTGTCCACCCCCCTTATTAGGAACGGTGACTGG
ACCTTCCAGATCCTGGTGATGCTGGAAATGACTCCCCAGCGTGGAGACGTCTACACCTGC
CACGTGGAGCACCCCAGCCTCCAGAACCCCATCATCGTGGAGTGGCGGGCTCAGTCTGAA
TCTGCCCAGAGCAAGATGCTGAGTGG----CATTGGAGGCTTCGTGCTGGGGCTGATCTT
CCTCGGGCTGGGCCTTATTATC--------------CATCACAGGAGTCAGAAAGGGCTC
CTGCACTGA---------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------
------------------------------------------------------------

Le code que j'ai jusqu'à présent est le suivant:

idx=[]
for m in range(len(sequence)):
    for n in re.finditer('-',sequence[0]): 
        idx.append(n.start())
counter=0
min_val=[]
for n in range(len(idx)):
    if counter==idx[n]:
        counter=counter+1
    elif counter !=0:
        min_val.append(idx[n-1])
        counter=0

Mon raisonnement pour le code ci-dessus était de savoir si je pouvais trouver les positions de départ du '-' alors je peux voir combien de fois elles apparaissent dans la séquence et si elles cassaient la séquence. Cependant, je sais qu'il y a quelques défauts dans le code ci-dessus.

4
Gia Constantina 8 août 2016 à 17:46

3 réponses

Meilleure réponse

Il semble que vous puissiez simplement compter les occurrences de -+, c'est-à-dire une séquence de un ou plusieurs - symboles. Le seul problème est les sauts de ligne, mais vous pouvez soit les incorporer dans l'expression régulière, soit diviser et joindre la chaîne avant de les faire correspondre.

>>> sequence = """>DQB1*04:02:01....."""
>>> joined = ''.join(sequence.splitlines())
>>> sum(1 for m in re.finditer("-+", joined))
7

Remarque: cela inclut le - au début et à la fin de la séquence.

Ou inversez l'approche: au lieu de compter les lacunes, comptez les groupes:

>>> sum(1 for m in re.finditer("[GATC]+", joined))
6
0
tobias_k 8 août 2016 à 15:09

Je pense que cela devrait faire:

def test(sequence):
    sequence = ''.join(sequence.splitlines()[1:]) # remove first line (header and line breaks)
    S = [segments for segments in sequence.split('-') if block != '']
    if len(S)>2: # len(S) should be the number of remaining segments
        print "Incomplete Allele."
0
Julien 8 août 2016 à 15:17

Vous pouvez simplement filtrer tous les caractères «-» et déterminer le nombre de ruptures en fonction du nombre de segments restants.

str_list = filter(None, sequence.split('-'))
if len(str_list) > 2:
    return "Incomplete Allele"
else:
    return "Complete Allele"
1
David Lance 8 août 2016 à 15:00