Regex, чтобы найти несколько комбинаций из строки с конкретными символами в качестве начала и конца

Question

Я пытаюсь найти совпадения возможных строк с начальными символами: «ATG» и конечными символами «TAA» или «TGA» или «TAG». Например, если моя строка:

seq = 'GATGATCGATGCTGACGTATAGGTTAAC'

Я хочу использовать регулярные выражения для соответствия этим 3:

match1 = 'ATGATCGATGCTGA'

match2 = 'ATGATCGATGCTGACGTATAG'

match3 = 'ATGATCGATGCTGACGTATAGGTTAA'

И то же самое, если вы используете второй «ATG»:

MATCH4 = 'ATGCTGA'

MATCH5 = 'ATGCTGACGTATAG'

MATCH6 = 'ATGCTGACGTATAGGTTAA'

Пока я написал это:

Frame1_ORF = re.match(\r '(^(ATG)?:(TGA|TAA|TAG)$)',Frame1) 

Но у меня неправильный синтаксис или символы. Не могли бы вы помочь мне найти эти 6 матчей?

Спасибо.

Answer 1

Другая возможность состоит в том, чтобы создать список комбинаций последовательности, которые следуют правилам желаемой последовательности, и отфильтровать конечный результат так, чтобы все оставшиеся последовательности существовали во входной последовательности:

seq = 'G**ATG**ATCG**ATG**C**TGA**CGTA**TAG**GT**TAA**C'
def new_data(f):
  def wrapper():
    full = map('**'.join, f(seq.split('**')))
    return list(filter(lambda x:x in seq, full)))
  return wrapper

@new_data
def outer(data):
  def combinations(d, current = []):
    if current and current[0] == 'ATG' and current[-1] in ['TAA', 'TGA', 'TAG']:
      yield current
    else:
      for i in d:
        if i in ['TAA', 'TGA', 'TAG'] and current:
          yield current + [i]
        else:
          if not current and i == 'ATG':
             yield from combinations(d, [i]+current)
          elif current and current.count(i) < seq.split('**').count(i):
             yield from combinations(d, current+[i])
  return list(combinations(data))


results = list(map(lambda x:'**'+x+'**', outer()))

Выход:

['**ATG**ATCG**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**C**TGA**', '**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**ATCG**ATG**C**TGA**', '**ATG**C**TGA**', '**ATG**C**TGA**']

Изменить: относительно вашего недавнего изменения формата данных, вы можете создать функцию для поиска общих группировок:

def combinations():
  groupings = {'G', 'ATG', 'ATCG', 'ATG', 'C', 'TGA', 'CGTA', 'TAG', 'GT', 'TAA', 'C'}
  seq = 'GATGATCGATGCTGACGTATAGGTTAAC'
  while seq:
    possibilities = [i for i in groupings if seq.startswith(i)]
    seq = seq[len(max(possibilities, key=len)):]
    yield max(possibilities, key=len)

seq = '**'.join(combinations())
results = list(map(lambda x:'**'+x+'**', outer()))

Answer 2

Чтобы построить ответ, предоставленный @Arount:

matches = (
    '**ATG**ATCG**ATG**C**TGA**',
    '**ATG**ATCG**ATG**C**TGA**CGTA**TAG**',
    '**ATG**ATCG**ATG**C**TGA**CGTA**TAG**GT**TAA**'
)
for string in matches:
    print(re.findall('(\*\*(?:ATG)(?:.*)(?:TGA|TAA|TAG)\*\*)', string)[0])

Это выводит:

**ATG**ATCG**ATG**C**TGA**
**ATG**ATCG**ATG**C**TGA**CGTA**TAG**
**ATG**ATCG**ATG**C**TGA**CGTA**TAG**GT**TAA**

2 изменения, которые я сделал:

• Добавление и добавление \*\*
• Внутренние группы теперь не захватывают (?:). Больше не нужно делать [0][0]. Просто [0] сейчас.

Answer 3

Это должно сделать это:

import re

resp =[]
seq = 'G**ATG**ATCG**ATG**C**TGA**CGTA**TAG**GT**TAA**C'


while re.findall(r'(?<=ATG)(.*)(?=(TGA|TAA|TAG))',seq):
    seq = re.findall(r'(?<=ATG)(.*)(?=(TGA|TAA|TAG))', seq)
    resp.append("ATG"+seq[0][0]+seq[0][1])
    seq="ATG"+seq[0][0]
print(resp)

Answer 4

Если вы пытаетесь извлечь строки, как определено в большей строке, это может сделать работу

matches = (
    '**ATG**ATCG**ATG**C**TGA**',
    '**ATG**ATCG**ATG**C**TGA**CGTA**TAG**',
    '**ATG**ATCG**ATG**C**TGA**CGTA**TAG**GT**TAA**'
)
for string in matches:
    print(re.findall('((ATG)(.*)(TGA|TAA|TAG))', string)[0][0])

выход

ATG**ATCG**ATG**C**TGA
ATG**ATCG**ATG**C**TGA**CGTA**TAG
ATG**ATCG**ATG**C**TGA**CGTA**TAG**GT**TAA