Python 计算模式在字符串中连续出现的最大数量

我真的不知道如何修复，以便我的代码计算模式在字符串中的行中出现的最大次数。我试过谷歌等，但所有的答案都不符合我的要求。也许我只是在谷歌上搜索错误的东西。无论如何，这是我的问题：

我有一个包含随机DNA序列的长文本文件，我把它转换成一个字符串，用它我应该找到某些不同的DNA序列，并计算每个序列连续出现的最高次数。为了更好地解释这个问题，我正在粘贴我目前试图使用的代码

# Opening sequence.txt and making it to a string
seqfile = open(sequence, "r")
seqfile = seqfile.read().replace("\n", "")

# Regex for each STR
pattern1 = r"AGATC"
pattern2 = r"TTTTTTCT"
pattern3 = r"AATG"
pattern4 = r"TCTAG"
pattern5 = r"GATA"
pattern6 = r"TATC"
pattern7 = r"GAAA"
pattern8 = r"TCTG"

# 3 lists to store value for the loop. Whereas outercount is the final value of each amount of STR corresponding data list

outercount = [0, 0, 0, 0, 0, 0, 0, 0]
innercount = [0, 0, 0, 0, 0, 0, 0, 0]
secondcount = [0, 0, 0, 0, 0, 0, 0, 0]

# Looping through the sequence and checking if pattern matches, if it does update secondcounter by 1 and continue...
for i in seqfile:
    if re.match(pattern1, seqfile):
        secondcount[0] += 1
    elif re.match(pattern2, seqfile):
        secondcount[1] += 1
    elif re.match(pattern3, seqfile):
        secondcount[2] += 1
    elif re.match(pattern4, seqfile):
        secondcount[3] += 1
    elif re.match(pattern5, seqfile):
        secondcount[4] += 1
    elif re.match(pattern6, seqfile):
        secondcount[5] += 1
    elif re.match(pattern7, seqfile):
        secondcount[6] += 1
    elif re.match(pattern8, seqfile):
        secondcount[7] += 1

# Looping through outercount and checking if certain value at innercount is less than secondcount update values.
for i in outercount:
        if secondcount[i] > innercount[i]:
        #stop counting
        innercount[i] = secondcount[i]
    # Reset secondcounts value so that it doesn't continue counting if it is not consecutively
    secondcount[i] = 0
    # Checking if innercount is greater than outercount, if it is set outercount[i] to equal innercount[i] value
    if innercount[i] > outercount[i]:
        outercount[i] = innercount[i]

下面是sequencetext文件的外观示例：

TGGTTTAGGGCCTATAATTGCAGGACCACTGGCCCTTGTCGAGGTGTACAGGTAGGGAGCTAAGTTCGAAACGCCCCTTGGTCGGGATTACCGCCAGATCAGATC...

请注意，这是比这更多的文字，但这只是供参考。 所以在这篇文章中，我要找出多达8种不同的DNA序列，以及它们在一行中出现的数量。例如，再次查找模式，然后计算它在一行中出现的最高次数。如果它在文本的某个地方先出现了3次，然后又出现了6次，那么我的AGATC计数器应该是6，因为它是一行中的最高值

因此，为了解释我的代码：我想有3个不同的数组，我想这不是最具可伸缩性的解决方案，因为文本中可以有3个或8个不同的模式。但我认为，从最大的数量开始，可能更容易计算出其余的。 所以我试着为每个不同的模式创建一个正则表达式，然后检查文本中是否可以找到每个模式，如果可以，我会将第二个计数列表更新到每个对应的索引

然后与另一个循环进行比较，如果secondcount[i]处的数量大于innercount[i]，如果是，则将该值更新为innercount，然后重置secondcount[i]，因为这可能是它出现的连续次数的结束，然后，如果它稍后再次出现在字符串中，那么它将从0开始计数，等等。。。我想代码不是很难理解，但它不工作，所以。。。XD

---

有人对我如何实现这一点有什么想法吗

假设一个模式可以在一行中出现多次，我将按照以下步骤计算所有序列中一个序列中模式的最大连续重复次数

import re

with open(sequence_file, 'rt') as f:
    rows = f.readlines()

patterns = { 
    re.compile("AGATC"): 0,
    re.compile("TCTAG"): 0,
    ... 
}

for r in rows:
    for p in patterns:
        prev_end = 0
        freq = 0
        for m in p.finditer(r):
            span = m.span()
            if span[0] != prev_end:
                patterns[p] = max(freq, patterns[p])
                freq = 0

            prev_end = span[1]
            freq += 1

        if freq:
            patterns[p] = max(freq, patterns[p])

注意：我还没有测试这段代码。因此，请在使用之前使用已知的输入进行测试。

以下是我的解决方案：

import re

patterns = {"AGATC": 0, "TTTTTTCT": 0, "AATG": 0, "TCTAG": 0, ...}

with open(sequence, 'rt') as file:
    rows = file.readlines()

    for row in rows:
        for pattern in patterns:
            regex = r"({0}(?:{0})+)".format(pattern) # any consecutive sequence
            results = re.findall(regex, value) # list of consecutive sequences
            if results:
                longest_sequence = sorted(results, reverse=True)[0]
                count = len(longest_sequence) / len(pattern) # count the number of ocurrences
                patterns[pattern] = max(int(count), patterns [pattern])

---

regex的一个例子是

（AGATC（？：AGATC）+

，意思是：查找单词

AGATC

，然后按

AGATC

进行一次或多次（

+

）。

？：

是，因此只返回一组-整个匹配。

天哪，非常感谢！这个程序运行得很好，我唯一需要添加的就是在字典中列出一个值，现在这个程序运行得很好。再见！祝您度过愉快的一天：）编辑：只列出了这些值，以便在code@Mango88很高兴这有帮助。如果某个解决方案对您有效，则接受/支持提供该解决方案的答案，以表明该答案/解决方案有效。这有助于其他有类似问题/寻找类似解决方案的人。我建议有两个字典，一个用于模式，一个用于计数，都用字符串索引；这通常比通过正则表达式模式索引字典更有用，因为在这种情况下，您无法通过键轻松查找值。@Venkatesh PrasadRanganath ah yes！但是我不确定是否会显示upvote，因为我只有不到15个rep:7有趣的，我没有意识到：）出于好奇，接受答案怎么样？

+

不应该是

*

来解释模式孤立发生的情况吗？不，因为它至少需要另一个序列才能连续，一行中有两个序列。正则表达式

r'（a（？：a）+'）

将报告字符串

'a'

的空匹配。因此，如果我们要查找孤立事件或连续事件，则需要

*

。我怀疑这里的情况就是这样；也许是，我错了。OP可以澄清。最后一行不应该是

patterns[pattern]=max（int（count），patterns[pattern]）

。如果没有

max

，将报告第3行中的4次出现，而不是第2行中的40次出现。