How to detect Start Codon and Stop Codon in a nucleotide sequence using Python?

Question

I am trying to solve an exercise in which a function with a start and a stop, where the start should occur when you find "ATG" and the stop when you find the "TAA", "TAG", "TGA".

With the help of the comments, I was able to adjust the code a little, but the stop is limited to only what I put in the s.find(). I’d like help getting him to look for one of the three stop codons proposed in the exercise.

Follows the statement of the exercise that generated the question:

Do a function contacodon in Python receiving a sequence of letters representing nucleotides (e. g., A, C, G, T), check whether the sequence is valid (i.e. contains only As, Cs, Gs, and Ts) and return with the number of occurrences of each Odon counting from the start Codon "ATG" up to one of the stop codons, "TAA", "TAG", "TGA"

Input example:

contacodon("AGCGATCGAGATGAGCATCGCATCGCGGACTACCGCGCGCGCGCGCGGGAGATGAGCATCGACGACTCGACTAG")

Exit to the above entrance:

{
'ATG': 1,
'AGC': 1,
'ATC': 1,
'GCA': 1,
'TCG': 1,
'CGG': 1,
'ACT': 1,
'ACC': 1,
'GCG': 2,
'CGC': 2,
'GGG': 1,
'AGA': 1,
'TGA': 1
} 

My code:

def verificar (s):
    s = s.upper()
    for ent in s:
        if not ent in "ACGT":
                return False
    return True
   
while True:
    s = str(input("Entre com a seq: \n")).upper()
    if verificar(s):
        break
    print("Seq inválida")
  
count={}
for i in range(s.find('ATG'),s.rfind('TAA')+1,3):
    codon = s[i:i+3]
    if codon in count:
        count[codon] += 1
    else:
        count[codon] = 1
print('\n', count, '\n',)

Answer 1

With the help of the native module re it is possible to create a regular expression validating its nucleotide sequence and separating the portion of the sequence containing the codons. With an object of the class Collection. Counter count the nucleotides.

import re
from collections import Counter

pattern = r"^[ACGT]*(?<=ATG)(?P<codons>([ACGT]{3})+?)(?=TAA|TAG|TGA)[ACGT]*$"

#Define a função contacodon(entrada). O parâmetro regex é inicializado na primeira chamada da função e não deve ser utilizado.
def contacodon(entrada, regex= re.compile(pattern)):
  #Verifica se houver correspondência...
  if m:= re.match(regex, s):
      #se houver correspondência separa o grupo contendo os códons e retorna o dicionário contendo a contagem dos códons.
      cdns = m["codons"]                    
      return dict(Counter([cdns[i:i+3] for i in range(0, len(cdns), 3)]))
  else:
      #se não houver correspondência retorna um dicionário vazio.
      return dict()

#s = input("Entre com a seq: \n").upper()
s = "GCGATCGAGATGAGCATCGCATCGCGGACTACCGCGCGCGCGCGCGGGAGATGAGCATCGACGACTCGACTAG"

print(contacodon(s))

^{Test the code on Repl.it}

The regular expression ^[ACGT]*(?<=ATG)(?P<codons>([ACGT]{3})+?)(?=TAA|TAG|TGA)[ACGT]*$ can be understood as:

• ^[ACGT]* the string must start with zero or more characters between A,C,G or T.
• (?<=ATG) the group(?P<codons>([ACGT]{3})+?) will only be captured if it is preceded by the start codon ATG.
• (?P<codons>([ACGT]{3})+?) defines the catch group codons which consists of one or more groups of three characters between A,C,G or T.
• (?=TAA|TAG|TGA) the group(?P<codons>([ACGT]{3})+?) will only be captured if succeeded by one of the stop codes TAA, TAG or TGA.
• [ACGT]*$ the string must end with zero or more characters between A,C,G or T.

EDIT
As reported in the comments, by Luiz Felipe, the same behavior can also be obtained from the function contacodon() using the following regular expression pattern:

pattern = r"^[ACGT]*ATG(?P<codons>(?:[ACGT]{3})+)(TAA|TAG|TGA)[ACGT]*$"

where:

• ^[ACGT]* the string must start with zero or more characters between A,C,G or T.
• ATG corresponds to the start codon ATG.
• (?P<codons>([ACGT]{3})+?) defines the catch group codons which consists of one or more groups of three characters between A,C,G or T.
• (TAA|TAG|TGA) corresponds to stop codons TAA, TAG or TGA.
• [ACGT]*$ the string must end with zero or more characters between A,C,G or T.

EDIT
Another relevant hint of pattern reported in the comments, by Hkotsubo:

pattern = "^[ACGT]*?ATG(?P<codons>([ACGT]{3})+?)T(?:A[AG]|GA)[ACGT]*$"

• ^[ACGT]*? the string must start with zero or more characters between A,C,G or T.
• ATG corresponds to the start codon ATG.
• (?P<codons>([ACGT]{3})+?) defines the catch group codons which consists of one or more groups of three characters between A,C,G or T.
• T(?:A[AG]|GA) corresponds to stop codons TAA, TAG or TGA.
• [ACGT]*$ the string must end with zero or more characters between A,C,G or T.

Answer 2

The code works, so that will carry out the count from the codon ATG up to the TAA.

The problem is there are three stop codons and the program only recognizes the TAA. See, the problem is where you create the interval for iterations:

range(s.find('ATG'), s.find('TAA') + 1, 3)

You are basically creating an interval, which increases by three, of the substring’s first occurrence index "ATG" up to the index of the first occurrence of the substring "TAA".

I see two problems when specifying a final index as a result of s.find('TAA'):

1. You run the risk of creating a crease running over a sequence with an invalid number of codons (there may be only 5 characters between ATG and TAA, for example).
2. You don’t recognize the other two codons of completion, "TAG" and "TGA".

To fix these two problems, simply do not set an upper limit on range. Simply scroll to the full length of the string.

In that sense, you can do the stop Codon within the loop itself, so as to use the break to interrupt repetitions if you have found a finishing codon.

Sort of like this:

# Lista de stop codons:
stops = ["TAA", "TAG", "TGA"]

count = {}
for i in range(s.find('ATG'), len(s) + 1, 3):
    codon = s[i: i + 3]
    if codon in count:
        count[codon] += 1
    else:
        count[codon] = 1

    # Se tiver encontrado um stop codon, pare de iterar:
    if codon in stops:
        break
print(count)

^{I have briefly omitted the rest of the code. See it working on Ideone.}

Remember that although it works with a common dictionary, Python offers other better approaches to count, such as the class Counter, available in the module collections. Behold:

from collections import Counter

stops = ["TAA", "TAG", "TGA"]
count = Counter()
for i in range(seq.find('ATG'), len(seq) + 1, 3):
    codon = seq[i: i + 3]
    count.update([codon])
    if codon in stops:
        break

print(dict(count))

^{See it working on Ideone.}

Another alternative is to use the defaultdict(int). Though less powerful than the Counter, already makes implicit the initialization of values 0 in the dictionary, what is done manually in the first example of code. See more about them in the Soen.

It is worth noting, finally, that the two codes presented in this reply will print the result of the count even if one stop Codon is not found. Moreover, if the last "codon" of this unfinished string has one or two characters (not three as expected), it will also be accounted for. To prevent this, you can implement some kind of verification. An example is to use a regular expression, as excellently demonstrated by answer by Augusto Vasques, in order to invalidate sequences that deviate from the expected pattern. I leave another example in Ideone.