Вчера я написал первый ответ.

Затем я прочитал ответ ATOzTOA, в котором у него была очень хорошая идея: использовать положительное ретроспективное утверждение.
Я подумал, что мой ответ полностью не соответствует действительности, и что его идея была правильным путем.
Но после этого я понял, что в коде ATOzTOA есть изъян.

Скажем, в проверяемой строке есть часть 'ATGxzyxyzyyxyATGxzxzyxyzxxzzxzyzyxyzTGA': положительное совпадение будет иметь место для 'xzyxyzyyxyATGxzxzyxyzxxzzxzyzyxyzTGA', а утвердительное совпадение — для предшествующего 'ATG', так что часть будет представлять собой совпадение; это нормально.
Но это означает, что сразу после этого сопоставления механизм регулярных выражений располагается в конце этой части 'xzyxyzyyxyATGxzxzyxyzxxzzxzyzyxyzTGA' .
Поэтому, когда механизм регулярных выражений будет искать следующее совпадение, он не найдет начала соответствия при этом 'ATG' присутствует в этой порции, так как она снова запускается с позиции намного позже нее.

.

Таким образом, единственный способ добиться того, что требуется по вопросу, - это эффективно написать первый алгоритм, который я написал, а затем я его публикую.

Работа выполняется функцией find_ORF_seq().

Если вы передадите True в качестве второго аргумента второму параметру messages функции find_ORF_seq(), она выведет сообщения, помогающие понять алгоритм.
Если нет, параметр messages принимает значение по умолчанию None.

Шаблон написан '(atg).+?(?:TAA|TGA|TAG)' с некоторыми буквами в верхнем регистре и другими в нижнем регистре, но это не причина, по которой части захватываются правильно относительно букв верхнего и нижнего регистра. Потому что, как вы увидите, используется флаг re.IGNORECASE: этот флаг необходим, поскольку часть, соответствующая (?:TAA|TGA|TAG), может попасть как в нижнюю, так и в верхнюю часть.

Суть алгоритма заключается в цикле while, который необходим из-за того, что исследуемые участки могут перекрываться, как я объяснял выше (насколько я правильно понял и приведенные вами примеры и пояснения верны).
Итак. нет возможности использовать findall() или finditer() и я делаю цикл.

Чтобы избежать повторения в последовательности fdna одного основания за другим, я использую метод ma.start(), который дает позицию начала совпадения ma в строке, и я увеличиваю значение s на s = s + p + 1. ( +1, чтобы не начинать поиск снова в начале найденного совпадения!)

Моему алгоритму не нужна информация start_positions, потому что я использую не обратное утверждение, а реальное совпадение по первым 3 буквам: совпадение объявляется неподходящим с ограничениями, когда начало совпадения находится в верхнем регистре, что сказать, когда ma.group(1), который улавливает первые три базы (это может быть 'ATG' или 'atg', так как случай игнорирования регулярного выражения), равен 'ATG'

Я был вынужден поставить s = s + p + 1 вместо s = s + p + 3, потому что кажется, что части, которые вы ищете, не разделены интервалом, кратным трем основаниям.

import re

sequence_list = ['atgttttgatgATGTTTTGATTT',
                 'atggggtagatggggATGGGGTGA',
                 'atgaaataatggggATGAAATAA',
                 'aaggtacttctcggctaACTTTTTCCAAGT']

pat = '(atg).+?(?:TAA|TGA|TAG)'
reg = re.compile(pat,re.IGNORECASE)

def find_ORF_seq(fdna,messages=None,s=0,reg=reg):
    ORF_sequences = []
    if messages:
        print 's before == ',s
    while True:
        if messages:
            print ('---------------------------\n'
                   's == %d\n'
                   'fdna[%d:] == %r' % (s,s,fdna[s:]))
        ma = reg.search(fdna[s:])
        if messages:
            print 'reg.search(fdna[%d:]) == %r' % (s,ma)
        if ma:
            if messages:
                print ('ma.group() == %r\n'
                       'ma.group(1) == %r'
                       % (ma.group(),ma.group(1)))
            if ma.group(1)=='ATG':
                if messages:
                    print "ma.group(1) is uppercased 'ATG' then I break"
                break
            else:
                ORF_sequences.append(ma.group().upper())
                p = ma.start()
                if messages:
                    print (' The match is at position p == %d in fdna[%d:]\n'
                           ' and at position s + p == %d + %d == %d in fdna\n'
                           ' then I put s = s + p + 1 == %d'
                           % (p,s, s,p,s+p, s+p+1))
                s = s + p + 1
        else:
            break
    if messages:
        print '\n==== RESULT ======\n'
    return ORF_sequences

for fdna in sequence_list:
    print ('\n============================================')
    print ('fdna == %s\n'
           'ORF_sequences == %r'
           % (fdna, find_ORF_seq(fdna,True)))

###############################

print '\n\n\n######################\n\ninput sample'
fdna = 'atgttttgatggATGTTTGATTTATTTTAG'
print '  fdna == %s' % fdna
print '  **atgttttga**tggATGTTTGATTTATTTTAG'
print '  atgttttg**atggATGTTTGA**TTTATTTTAG'
print 'output sample'
print "  ORF_sequences = ['ATGTTTTGA','ATGGATGTTTGA']"

print '\nfind_ORF_seq(fdna) ==',find_ORF_seq(fdna)

.

Та же функция без print инструкций, чтобы лучше видеть алгоритм.

import re

pat = '(atg).+?(?:TAA|TGA|TAG)'
reg = re.compile(pat,re.IGNORECASE)

def find_ORF_seq(fdna,messages=None,s =0,reg=reg):
    ORF_sequences = []
    while True:
        ma = reg.search(fdna[s:])
        if ma:
            if ma.group(1)=='ATG':
                break
            else:
                ORF_sequences.append(ma.group().upper())
                s = s + ma.start() + 1
        else:
            break
    return ORF_sequences

.

Я сравнил две функции, ATOzTOA и мою, с последовательностью fdna, обнаружившей недостаток. Это оправдывает то, что я описал.

from find_ORF_sequences import find_ORF_seq
from ATOz_get_sequences import getSequences

fdna = 'atgggatggtagatggatgggATGGGGTGA'

print 'fdna == %s' % fdna
print 'find_ORF_seq(fdna)\n',find_ORF_seq(fdna)
print 'getSequences(fdna)\n',getSequences(fdna)

результат

fdna == atgggatggtagatggatgggATGGGGTGA
find_ORF_seq(fdna)
['ATGGGATGGTAG', 'ATGGTAG', 'ATGGATGGGATGGGGTGA', 'ATGGGATGGGGTGA']
getSequences(fdna)
['ATGGGATGGTAG', 'ATGGATGGGATGGGGTGA']

.

Но в конце концов, может быть, интересно.... :
вам нужны совпадения, которые являются внутренними частями другого соответствия, например 'ATGGGATGGGGTGA' в конце 'ATGGATGGGATGGGGTGA' ?

Если нет, то подойдет и ответ АТОзТОА.

Обновление 2 – Полный код

import re

def getSequences(fdna):
    start = re.search("[A-Z]", fdna).start()
    fdna = fdna.upper()

    ORF_sequences = re.finditer(r'(?<=ATG)(.*?)(?:TAA|TAG|TGA)',fdna)

    sequences = []

    for match in ORF_sequences:
        s = match.start()
        if s < start:
            sequences.append("ATG" + match.group(0))

    print sequences

    return sequences

sequence_list = ['atgttttgatggATGTTTGATTAG','atggggtagatggggATGGGGTGA','atgaaataatggggATGAAATAA']

for fdna in sequence_list:
    getSequences(fdna)

Вывод

>>> 
['ATGTTTTGA', 'ATGGATGTTTGA']
['ATGGGGTAG', 'ATGGGGATGGGGTGA']
['ATGAAATAA', 'ATGGGGATGA']

Обновить

Если вам нужно re, попробуйте следующее:

ORF_sequences = re.finditer(r'(?<=ATG)(.*?)(?:TAA|TAG|TGA)',fdna)

for match in ORF_sequences:
    print match.span()
    print "ATG" + match.group(0)

Вывод

>>> 
(3, 9)
ATGTTTTGA
(11, 20)
ATGGATGTTTGA

Примечание

Это не всегда будет работать. Но вы можете сравнить значение match.start() с cds_start_position и удалить ненужные последовательности.

Попробуйте это, не re, но работает...

def getSequences(fdna, start):
    """Find the sequence fully to left of start and
    laying over the start"""

    i = 0
    j = 0
    f = False
    while True:
        m = fdna[i:i+3]
        if f is False:
            if m == "ATG":
                f = True
                j = i
                i += 2
        else:
            if m in ["TAA", "TAG", "TGA"]:
                i += 2
                seq1 = fdna[j: i+1]
                break

        i += 1

    i = 1
    j = 0
    f = False
    while True:
        m = fdna[i:i+3]
        if f is False:
            if m == "ATG" and i < start:
                f = True
                j = i
                i += 2
        else:
            if m in ["TAA", "TAG", "TGA"] and i > start:
                i += 2
                seq2 = fdna[j: i+1]
                break

        i += 1

    print "Sequence 1 : " + seq1
    print "Sequence 2 : " + seq2

Тест

fdna = 'atgttttgatggATGTTTGATTAG'

cds_start_positions = []
cds_start_positions.append(re.search("[A-Z]", fdna).start())

fdna = fdna.upper()

getSequences(fdna, cds_start_positions[0])

Вывод

>>> 
Sequence 1 : ATGTTTTGA
Sequence 2 : ATGGATGTTTGA