在 Python 中使用正则表达式查找重叠匹配和子匹配

Question

我有一个字符串（一个 DNA 序列）和一个正则表达式，用于过滤掉可能的匹配，(?:ATA|ATT)[ATCGN]{144,16563}(?:AGA|AGG|TAA|TAG)。后来我应用了两个过滤条件：

1. 序列必须能被 3 整除，len(match) % 3 == 0，并且
2. 在字符串结尾 not any(substring in list(sliced(match[:-3], 3)) for substring in [x.replace("U", "T") for x in stop_codons]) 之前不能有终止密码子 (['AGA', 'AGG', 'TAA', 'TAG'])。

但是，当我应用这些过滤器时，我根本没有得到任何匹配项（在过滤器之前我得到大约 200 个匹配项。我在完整序列中搜索子字符串的方式是运行 re.findall(regex, genome_fasta, overlapped=True)，因为匹配项可以是其他匹配的子匹配。

我对正则表达式有什么误解吗？据我所知，在过滤器之后，我应该还有匹配项。

如果还有什么我需要补充的，请告诉我！ （我使用 Python 3.4 的 regex 包，而不是标准的 re 包，因为它不支持重叠）。

编辑 1：

根据评论：我正在寻找线粒体基因组中的 ORF，但只考虑长度至少为 150 个核苷酸（字符）的 ORF。考虑重叠很重要，因为匹配可能包括字符串中的第一个起始密码子和字符串中的最后一个终止密码子，但中间可能有另一个起始密码子。例如：

• 鉴于“ATAAAGCCATTTACCGTACATAGCACATTATAACCAACAAACCTACCCACCCTTAACTAG”，匹配项应该是“ATAAAGCCATTTACCGTACATAGCACATTATAACCAACAAACCTACCCACCCTTAACTAG”，但也应该是“ATAAAGCCATTTACCGTACATAGCACATTATAA”，因为“TAG”和“TAA”都是终止密码子。

编辑 2：

完全误解了评论，方法的完整代码是：

typical_regex = r"%s[ATCGN]{%s,%s}%s" % (proc_start_codons, str(minimum_orf_length - 6), str(maximum_orf_length - 6), proc_stop_codons)

typical_fwd_matches = []
    if re.search(typical_regex, genome_fasta, overlapped=True):
        for match in re.findall(typical_regex, genome_fasta, overlapped=True):
            if len(match) % 3 == 0:
                if not any(substring in list(sliced(match[:-3], 3)) for substring in [x.replace("U", "T") for x in stop_codons]):
                    typical_fwd_matches.append(match)

print(typical_fwd_matches)

typical_fwd_matches 数组为空，正则表达式在打印到控制台/文件时呈现为 (?:ATA|ATT)[ATCGN]{144,16563}(?:AGA|AGG|TAA|TAG)。

Answer 1

我认为你可以这样做。
子集将包含不断减小的先前匹配的大小。
这就是您所要做的一切。
因此，设计正则表达式相当简单。

正则表达式只会匹配 3 个字符的倍数。
开始和中间被捕获在第 1 组中。
这用于新的 text 值，它只是最后一个匹配项
减去最后 3 个字符。

正则表达式解释：

 (                             # (1 start), Whole match minus last 3 chars
      (?: ATA | ATT )               # Starts with one of these 3 char sequence
      (?:                           # Cluster group
           [ATCGN]{3}                    # Any 3 char sequence consisting of these chars
      )+                            # End cluster, do 1 to many times
 )                             # (1 end)
 (?: AGA | AGG | TAA | TAG )   # Last 3 char sequence, one of these

Python 代码示例：

Demo

import re

r = re.compile(r"((?:ATA|ATT)(?:[ATCGN]{3})+)(?:AGA|AGG|TAA|TAG)")
text = "ATAAAGCCATTTACCGTACATAGCACATTATAACCAACAAACCTACCCACCCTTAACTAG"

m = r.search(text)
while m:
    print("Found:  " + m.group(0))
    text = m.group(1)
    m = r.search(text)

输出：

Found:  ATAAAGCCATTTACCGTACATAGCACATTATAACCAACAAACCTACCCACCCTTAACTAG
Found:  ATAAAGCCATTTACCGTACATAGCACATTATAA
Found:  ATTTACCGTACATAG

---

使用这种方法，被测试的子集是：

ATAAAGCCATTTACCGTACATAGCACATTATAACCAACAAACCTACCCACCCTTAACTAG
ATAAAGCCATTTACCGTACATAGCACATTATAACCAACAAAACCTACCCACCCTTAAC
ATAAAGCCATTTACCGTACATAGCACATTA
ATTTACCGTACA

我们可以对正则表达式匹配这些所需的时间进行基准测试。

Regex1:   ((?:ATA|ATT)(?:[ATCGN]{3})+)(?:AGA|AGG|TAA|TAG)
Completed iterations:   50  /  50     ( x 1000 )
Matches found per iteration:   3
Elapsed Time:    1.63 s,   1627.59 ms,   1627594 µs
Matches per sec:   92,160