Python 如何找到序列中特定字母旁边的回文？

我有一个脚本，它返回DNA序列中的回文子字符串

sequence="GATCTCTATACCAACTCAAAATGAAGACTCTTCTTTACACTTTCGAGCTCAGCAGGCTTACCGAGAAGAGTCGTCGTTCACATCCCCCCCTGTGCGAGATCAAGAAATTTGGCGACGTCGGCTTATTATCCTCCGCTGTCAATCAGTTGGACACATCTCTCCGGTCACTGCCGGACAAGCCAACCGAAGATTCGATTCTTCAGCAGCTTATCGACATTGCTGGTGGTGAAAAGCCAAGGCACAGCATCATAGTTGCGACCAATACGTCATACGACCGAGAGACATTGGTAAAGATCCTTCAACGATTCCCATACACCATACCTGGTCTGTCAGATTCAGGCTTGGAATCAGAAACACTCGAGGCTCTTGAGCACATCGCTTTTGCATTAGCCGGGCGATTAGCTCATAGATTTGACTACGGGTTCAATCCAGAGGCCAGTATCGTTCAACACCTCGAGATGTTCACCACCCTTTGGCACCAAAGATCTGCATTACCACCTGCGCCTGCCCCGTATCGACTTCCCGTTCCCGTCAATCAAGGAAGAGTCTCCTCATCAGATGATGGCTCTGATACTGAGTCAGAACTGGATGAAAAATACCACAACATCAAGAAGTCAGGACTTTGGAGGTTTCTGGATATGTTCAAAATGAACTTCAAGAGGTCTTAGATAACGGTCTAGTTCTAGTTCTGCAACTCACACTGA"
print(len(sequence))
pairs = {"A":"T", "T":"A", "G":"C", "C":"G"}
for i in range(len(sequence) - 6 + 1):
    pal = True
    for j in range(2):
        if pairs[ sequence[i+j] ] != sequence[i+5-j]:
            pal = False
            break
    if pal:
        print(sequence[i : i+6])

它返回：

704
GATCTC
GAGCTC
GCAGGC
GTTCAC
GAGATC
TCAAGA
AAATTT
GACGTC
CAGTTG
TGGACA
AAGATT
CTTCAG
CCAAGG
CGACCG
TTGGAA
CTCGAG
TCTTGA
CTTGAG
TGAGCA
CGGGCG
ATAGAT
ACGGGT
TCCAGA
CTCGAG
TCGAGA
TGTTCA
GTTCAC
GGCACC
AGATCT
CACCTG
GCCTGC
GACTTC
CAGATG
AGAACT
TCAAGA
GAAGTC
TCAGGA
AGGACT
TCTGGA
TGTTCA
TTCAAA
TCAAGA
GAGGTC
AGGTCT
TAGATA
AGTTCT
AGTTCT

我想知道这些子字符串是否位于“[ATCG]CC”或“[ATCG]GG”旁边 我想找出这些回文在序列中的位置（例如从第I个到第（I+5）个，因为回文的长度为6），然后检查第（I+6）个到第（I+8）个字母是[ATCG]CC还是[ATCG]GG。 你知道我怎么写这样的剧本吗？还是你有更好的逻辑？

---

谢谢你

我不确定我是否能正确回答你的问题，但假设你得到的值是某种基因回文，然后你希望找到每个值的下两个值（如果我弄错了，请纠正我），简单的解决方案是这样的：

sequence="GATCTCTATACCAACTCAAAATGAAGACTCTTCTTTACACTTTCGAGCTCAGCAGGCTTACCGAGAAGAGTCGTCGTTCACATCCCCCCCTGTGCGAGATCAAGAAATTTGGCGACGTCGGCTTATTATCCTCCGCTGTCAATCAGTTGGACACATCTCTCCGGTCACTGCCGGACAAGCCAACCGAAGATTCGATTCTTCAGCAGCTTATCGACATTGCTGGTGGTGAAAAGCCAAGGCACAGCATCATAGTTGCGACCAATACGTCATACGACCGAGAGACATTGGTAAAGATCCTTCAACGATTCCCATACACCATACCTGGTCTGTCAGATTCAGGCTTGGAATCAGAAACACTCGAGGCTCTTGAGCACATCGCTTTTGCATTAGCCGGGCGATTAGCTCATAGATTTGACTACGGGTTCAATCCAGAGGCCAGTATCGTTCAACACCTCGAGATGTTCACCACCCTTTGGCACCAAAGATCTGCATTACCACCTGCGCCTGCCCCGTATCGACTTCCCGTTCCCGTCAATCAAGGAAGAGTCTCCTCATCAGATGATGGCTCTGATACTGAGTCAGAACTGGATGAAAAATACCACAACATCAAGAAGTCAGGACTTTGGAGGTTTCTGGATATGTTCAAAATGAACTTCAAGAGGTCTTAGATAACGGTCTAGTTCTAGTTCTGCAACTCACACTGA"

pairs = {"A":"T", "T":"A", "G":"C", "C":"G"}

keeper = []
for i in range(len(sequence) - 6 + 1):
    pal = True
    for j in range(2):
        if pairs[ sequence[i+j] ] != sequence[i+5-j]:
            pal = False
            break
    if pal:
        the_sequence = sequence[i : i+6]
#         print(the_sequence)
        keeper.append((the_sequence, (i, i+6)))
        
possible_ends = [a+'CC' for a in "ATCG"]
possible_ends.extend([a+'GG' for a in "ATCG"])

final = []

for val in keeper:
    temp = val[0]+sequence[val[1][1]:val[1][1]+3]
    
    temp_list = [temp.endswith(a) for a in possible_ends]
    
    if any(temp_list):
        final.append(temp)
    else:
        pass
    
print(final)

输出：

['GCCTGCCCC', 'GAAGTCAGG']

704
GATCTC (X)
GAGCTC (X)
GCAGGC (X)
GTTCAC (X)
GAGATC (X)
TCAAGA (X)
AAATTT (X)
GACGTC (X)
CAGTTG (X)
TGGACA (X)
AAGATT (X)
CTTCAG (X)
CCAAGG (X)
CGACCG (X)
TTGGAA (X)
CTCGAG (X)
TCTTGA (X)
CTTGAG (X)
TGAGCA (X)
CGGGCG (X)
ATAGAT (X)
ACGGGT (X)
TCCAGA (X)
CTCGAG (X)
TCGAGA (X)
TGTTCA (X)
GTTCAC (X)
GGCACC (X)
AGATCT (X)
CACCTG (X)
GCCTGCCCC
GACTTC (X)
CAGATG (X)
AGAACT (X)
TCAAGA (X)
GAAGTCAGG
TCAGGA (X)
AGGACT (X)
TCTGGA (X)
TGTTCA (X)
TTCAAA (X)
TCAAGA (X)
GAGGTC (X)
AGGTCT (X)
TAGATA (X)
AGTTCT (X)
AGTTCT (X)
Count of answer: 2

---

我希望并相信这是期望的结果。

我不确定是否能够正确回答您的问题，但假设您得到的值是某种基因回文，然后您希望找到每个值的下两个值（如果我弄错了，请更正我），简单的解决方案有点像这样：

sequence="GATCTCTATACCAACTCAAAATGAAGACTCTTCTTTACACTTTCGAGCTCAGCAGGCTTACCGAGAAGAGTCGTCGTTCACATCCCCCCCTGTGCGAGATCAAGAAATTTGGCGACGTCGGCTTATTATCCTCCGCTGTCAATCAGTTGGACACATCTCTCCGGTCACTGCCGGACAAGCCAACCGAAGATTCGATTCTTCAGCAGCTTATCGACATTGCTGGTGGTGAAAAGCCAAGGCACAGCATCATAGTTGCGACCAATACGTCATACGACCGAGAGACATTGGTAAAGATCCTTCAACGATTCCCATACACCATACCTGGTCTGTCAGATTCAGGCTTGGAATCAGAAACACTCGAGGCTCTTGAGCACATCGCTTTTGCATTAGCCGGGCGATTAGCTCATAGATTTGACTACGGGTTCAATCCAGAGGCCAGTATCGTTCAACACCTCGAGATGTTCACCACCCTTTGGCACCAAAGATCTGCATTACCACCTGCGCCTGCCCCGTATCGACTTCCCGTTCCCGTCAATCAAGGAAGAGTCTCCTCATCAGATGATGGCTCTGATACTGAGTCAGAACTGGATGAAAAATACCACAACATCAAGAAGTCAGGACTTTGGAGGTTTCTGGATATGTTCAAAATGAACTTCAAGAGGTCTTAGATAACGGTCTAGTTCTAGTTCTGCAACTCACACTGA"

pairs = {"A":"T", "T":"A", "G":"C", "C":"G"}

keeper = []
for i in range(len(sequence) - 6 + 1):
    pal = True
    for j in range(2):
        if pairs[ sequence[i+j] ] != sequence[i+5-j]:
            pal = False
            break
    if pal:
        the_sequence = sequence[i : i+6]
#         print(the_sequence)
        keeper.append((the_sequence, (i, i+6)))
        
possible_ends = [a+'CC' for a in "ATCG"]
possible_ends.extend([a+'GG' for a in "ATCG"])

final = []

for val in keeper:
    temp = val[0]+sequence[val[1][1]:val[1][1]+3]
    
    temp_list = [temp.endswith(a) for a in possible_ends]
    
    if any(temp_list):
        final.append(temp)
    else:
        pass
    
print(final)

输出：

['GCCTGCCCC', 'GAAGTCAGG']

704
GATCTC (X)
GAGCTC (X)
GCAGGC (X)
GTTCAC (X)
GAGATC (X)
TCAAGA (X)
AAATTT (X)
GACGTC (X)
CAGTTG (X)
TGGACA (X)
AAGATT (X)
CTTCAG (X)
CCAAGG (X)
CGACCG (X)
TTGGAA (X)
CTCGAG (X)
TCTTGA (X)
CTTGAG (X)
TGAGCA (X)
CGGGCG (X)
ATAGAT (X)
ACGGGT (X)
TCCAGA (X)
CTCGAG (X)
TCGAGA (X)
TGTTCA (X)
GTTCAC (X)
GGCACC (X)
AGATCT (X)
CACCTG (X)
GCCTGCCCC
GACTTC (X)
CAGATG (X)
AGAACT (X)
TCAAGA (X)
GAAGTCAGG
TCAGGA (X)
AGGACT (X)
TCTGGA (X)
TGTTCA (X)
TTCAAA (X)
TCAAGA (X)
GAGGTC (X)
AGGTCT (X)
TAGATA (X)
AGTTCT (X)
AGTTCT (X)
Count of answer: 2

---

我希望并相信这是理想的输出。

只需添加一些额外的检查

sequence="GATCTCTATACCAACTCAAAATGAAGACTCTTCTTTACACTTTCGAGCTCAGCAGGCTTACCGAGAAGAGTCGTCGTTCACATCCCCCCCTGTGCGAGATCAAGAAATTTGGCGACGTCGGCTTATTATCCTCCGCTGTCAATCAGTTGGACACATCTCTCCGGTCACTGCCGGACAAGCCAACCGAAGATTCGATTCTTCAGCAGCTTATCGACATTGCTGGTGGTGAAAAGCCAAGGCACAGCATCATAGTTGCGACCAATACGTCATACGACCGAGAGACATTGGTAAAGATCCTTCAACGATTCCCATACACCATACCTGGTCTGTCAGATTCAGGCTTGGAATCAGAAACACTCGAGGCTCTTGAGCACATCGCTTTTGCATTAGCCGGGCGATTAGCTCATAGATTTGACTACGGGTTCAATCCAGAGGCCAGTATCGTTCAACACCTCGAGATGTTCACCACCCTTTGGCACCAAAGATCTGCATTACCACCTGCGCCTGCCCCGTATCGACTTCCCGTTCCCGTCAATCAAGGAAGAGTCTCCTCATCAGATGATGGCTCTGATACTGAGTCAGAACTGGATGAAAAATACCACAACATCAAGAAGTCAGGACTTTGGAGGTTTCTGGATATGTTCAAAATGAACTTCAAGAGGTCTTAGATAACGGTCTAGTTCTAGTTCTGCAACTCACACTGA"
print(len(sequence))
pairs = {"A":"T", "T":"A", "G":"C", "C":"G"}
ans = []
for i in range(len(sequence) - 9 + 1):
    pal = True
    for j in range(2):
        if pairs[ sequence[i+j] ] != sequence[i+5-j]:
            pal = False
            break
    if not pal:
        continue

    if (sequence[i+7] == sequence[i+8]) and (sequence[i+7] in ('C', 'G')):
        print(sequence[i : i+9])
        ans.append(sequence[i : i+9])
    else:
        print(sequence[i : i+6] + " (X)")
print("Count of answer: %d" % len(ans))

输出：

['GCCTGCCCC', 'GAAGTCAGG']

704
GATCTC (X)
GAGCTC (X)
GCAGGC (X)
GTTCAC (X)
GAGATC (X)
TCAAGA (X)
AAATTT (X)
GACGTC (X)
CAGTTG (X)
TGGACA (X)
AAGATT (X)
CTTCAG (X)
CCAAGG (X)
CGACCG (X)
TTGGAA (X)
CTCGAG (X)
TCTTGA (X)
CTTGAG (X)
TGAGCA (X)
CGGGCG (X)
ATAGAT (X)
ACGGGT (X)
TCCAGA (X)
CTCGAG (X)
TCGAGA (X)
TGTTCA (X)
GTTCAC (X)
GGCACC (X)
AGATCT (X)
CACCTG (X)
GCCTGCCCC
GACTTC (X)
CAGATG (X)
AGAACT (X)
TCAAGA (X)
GAAGTCAGG
TCAGGA (X)
AGGACT (X)
TCTGGA (X)
TGTTCA (X)
TTCAAA (X)
TCAAGA (X)
GAGGTC (X)
AGGTCT (X)
TAGATA (X)
AGTTCT (X)
AGTTCT (X)
Count of answer: 2

---

只要加上一些额外的支票

sequence="GATCTCTATACCAACTCAAAATGAAGACTCTTCTTTACACTTTCGAGCTCAGCAGGCTTACCGAGAAGAGTCGTCGTTCACATCCCCCCCTGTGCGAGATCAAGAAATTTGGCGACGTCGGCTTATTATCCTCCGCTGTCAATCAGTTGGACACATCTCTCCGGTCACTGCCGGACAAGCCAACCGAAGATTCGATTCTTCAGCAGCTTATCGACATTGCTGGTGGTGAAAAGCCAAGGCACAGCATCATAGTTGCGACCAATACGTCATACGACCGAGAGACATTGGTAAAGATCCTTCAACGATTCCCATACACCATACCTGGTCTGTCAGATTCAGGCTTGGAATCAGAAACACTCGAGGCTCTTGAGCACATCGCTTTTGCATTAGCCGGGCGATTAGCTCATAGATTTGACTACGGGTTCAATCCAGAGGCCAGTATCGTTCAACACCTCGAGATGTTCACCACCCTTTGGCACCAAAGATCTGCATTACCACCTGCGCCTGCCCCGTATCGACTTCCCGTTCCCGTCAATCAAGGAAGAGTCTCCTCATCAGATGATGGCTCTGATACTGAGTCAGAACTGGATGAAAAATACCACAACATCAAGAAGTCAGGACTTTGGAGGTTTCTGGATATGTTCAAAATGAACTTCAAGAGGTCTTAGATAACGGTCTAGTTCTAGTTCTGCAACTCACACTGA"
print(len(sequence))
pairs = {"A":"T", "T":"A", "G":"C", "C":"G"}
ans = []
for i in range(len(sequence) - 9 + 1):
    pal = True
    for j in range(2):
        if pairs[ sequence[i+j] ] != sequence[i+5-j]:
            pal = False
            break
    if not pal:
        continue

    if (sequence[i+7] == sequence[i+8]) and (sequence[i+7] in ('C', 'G')):
        print(sequence[i : i+9])
        ans.append(sequence[i : i+9])
    else:
        print(sequence[i : i+6] + " (X)")
print("Count of answer: %d" % len(ans))

输出：

['GCCTGCCCC', 'GAAGTCAGG']

704
GATCTC (X)
GAGCTC (X)
GCAGGC (X)
GTTCAC (X)
GAGATC (X)
TCAAGA (X)
AAATTT (X)
GACGTC (X)
CAGTTG (X)
TGGACA (X)
AAGATT (X)
CTTCAG (X)
CCAAGG (X)
CGACCG (X)
TTGGAA (X)
CTCGAG (X)
TCTTGA (X)
CTTGAG (X)
TGAGCA (X)
CGGGCG (X)
ATAGAT (X)
ACGGGT (X)
TCCAGA (X)
CTCGAG (X)
TCGAGA (X)
TGTTCA (X)
GTTCAC (X)
GGCACC (X)
AGATCT (X)
CACCTG (X)
GCCTGCCCC
GACTTC (X)
CAGATG (X)
AGAACT (X)
TCAAGA (X)
GAAGTCAGG
TCAGGA (X)
AGGACT (X)
TCTGGA (X)
TGTTCA (X)
TTCAAA (X)
TCAAGA (X)
GAGGTC (X)
AGGTCT (X)
TAGATA (X)
AGTTCT (X)
AGTTCT (X)
Count of answer: 2

---

---

这回答了你的问题吗@LeonardusChen我找到了回文，但我需要在这些回文中选择那些放在[TACG]CC或[TACG]GG旁边的回文。你能详细说明回文在这方面的含义吗

AGGTCT

似乎不是回文，但它存在于列表中。我遗漏了什么吗？似乎你需要记录回文的位置，而不仅仅是它是什么。@AkshaySehgal这是一个DNA回文。如果反向读取，则另一条链上的匹配序列相同。这是否回答了您的问题@LeonardusChen我找到了回文，但我需要在这些回文中选择那些放在[TACG]CC或[TACG]GG旁边的回文。你能详细说明回文在这方面的含义吗

AGGTCT

似乎不是回文，但它存在于列表中。我遗漏了什么吗？似乎你需要记录回文的位置，而不仅仅是它是什么。@AkshaySehgal这是一个DNA回文。如果反向阅读，则另一条链上的匹配序列相同。谢谢您的回答。我要找的是脚本，看看它找到的GATCC是否放在ACC、TCC、GCC、CCC、AGG、TGG、CGG或GGG的旁边，然后打印这9个字母（例如GATCTCTCC），所以让我澄清一下：你只需要找到每个回文，后面的三个字母？这意味着，对于GATCC->GATCTCC和GAGCTC->GAGCTCAGC等等？这就是全部？或者您只想要某个特定的类型，还是只想要GATCC类型。实际上，我还在努力理解你的问题。例如，对于GATCC，我只希望它后面跟[ATCG]CC或[ATCG]GG，意思是GATCTCCC或GATCTCTCC或GATCTCCCC或GATCTCCCC等等。哦，我想我现在理解了这个问题。让我再试一次。你能检查一下新的解决方案吗。这就是你要找的吗？此外，如果这是期望的结果，那么优化此代码是下一步要尝试的事情。我的意思是，如果这将在一个巨大的长序列上运行，那么可能会优化此代码，或者您知道更好的方法（更快、更高效）来处理此类数据。谢谢您的回答。我要找的是脚本，看看它找到的GATCC是否放在ACC、TCC、GCC、CCC、AGG、TGG、CGG或GGG的旁边，然后打印这9个字母（例如GATCTCTCC），所以让我澄清一下：你只需要找到每个回文，后面的三个字母？这意味着，对于GATCC->GATCTCC和GAGCTC->GAGCTCAGC等等？这就是全部？或者您只想要某个特定的类型，还是只想要GATCC类型。实际上，我还在努力理解你的问题。例如，对于GATCC，我只希望它后面跟[ATCG]CC或[ATCG]GG，意思是GATCTCCC或GATCTCTCC或GATCTCCCC或GATCTCCCC等等。哦，我想我现在理解了这个问题。让我再试一次。你能检查一下新的解决方案吗。这就是你要找的吗？此外，如果这是期望的结果，那么优化此代码是下一步要尝试的事情。我的意思是，如果这将在一个巨大的长序列上运行，那么可能会优化此代码，或者您知道更好的方法（更快、更高效）来处理此类数据。非常感谢。是的，这就是我想要的。打印后是否可以找到符合条件的子字符串的数量，以防我的序列变长，视觉上难以跟踪它们。@当然，您可以通过添加两行代码来实现这一点。查看我的最新编辑。我尝试使用此代码获取长度为18的回文，但它不会返回与最后三个字母相同的结果。你知道我怎样才能解决这个问题吗？非常感谢。是的，这就是我想要的。打印后是否可以找到符合条件的子字符串的数量，以防我的序列变长，视觉上难以跟踪它们。@当然，您可以通过添加两行代码来实现这一点。查看我的最新编辑。我尝试使用此代码获取长度为18的回文，但它不会返回与最后三个字母相同的结果。你知道我怎样才能解决这个问题吗？