匹配序列的开始和结束索引从索引计数中跳过“-”或特殊字符答案

【问题标题】：Start and end indices of the matched sequences skipping the '-' or special characters from index counting匹配序列的开始和结束索引从索引计数中跳过“-”或特殊字符
【发布时间】：2021-12-28 15:14:30
【问题描述】：

我正在使用一个函数，我需要匹配的大写字母的开始和结束索引。但要记住的一件事是，如果任何字符串中有任何“-”，我们需要跳过索引进行计数。例如：

str1 = 'ATCGATCGATCG------ATCGATCG'
str2 = 'CGcgCGCGCGCG---CGCCGCGcgCG'

这里其实应该算字符串的长度：
str1：20（而不是 26）
和 str2：23（而不是 26）。
这里的开始和结束索引应该是：

matched_str: 'CG', 'CG', 'CG', 'CG'
start = [6, 10, 14, 18]
end= [7, 11, 18, 22]

现在我得到了以下函数，它在两个字符串中的任何一个中遇到“-”时都不会跳过索引。如何修改以下代码来做到这一点？

str1 = 'ggtacTGAGGTCCCCTGGGTACTGAGATCTCCTCGGTACTGAAGTCTCCTCGGTGCTGAGGTCGCCTCGGTGCTGAGACCTCCTAGGTATTGAGGTCGCCTCGGTACTGAGGTTGCCTC----------------------------GGTGCTGAGGT-----CGCCACGGTGCTGAGACCTCCTAGATACTGAGG----TCTCCTAGGCACGGAGATCTCCTATGTACAGAGACCTCGTCGGTACTGAGGTCGCCTAGGTACTGAGACCTTCTAGGTCCTGAGGT--------CTAGGTACTGAGG-CCTTCTCC\n'
str2 = 'GATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTT-CCTCTCCCGGGATGCTGAGGTTCCTCTCCCGGGATGCTGAGGTTCCTCTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCTCTCCCAG---------------------------------GATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCTCTCCCAGGATGCTGAGGTTCCTCTCC\n'

matches = []
for i,(letter1, letter2) in enumerate(zip(str1,str2)):#i=index, letter1=str1, letter2=str2
  #  print(letter1, letter2)
    if ((letter1 == letter2) and 
        letter1 in ['A','T','C','G'] and letter2 in ['A','T','C','G']):
        if (not matches or matches[-1][1] != i-1):
            matches.append([i,i])
        else:
            matches[-1][1] += 1

start = [k[0] for k in matches]
end   = [k[1] for k in matches]
print(start, end)

【问题讨论】：

如果您希望像删除破折号一样完成处理，为什么不直接使用删除破折号的字符串副本？
@ScottHunter 抱歉，这不可能！因为我需要比较每个字符串对并且还需要它们的长度。如果我删除了“-”，那么我将无法在确切位置比较每个字符串，并且字符串的长度也不会相同。问题仅在于索引。
旁注：您可以将条件缩短为if letter1 == letter2 and letter1 in ['A','T','C','G']:
您可以保留- 的数量，然后从i 中减去。

标签： python string indexing

【解决方案1】：

我实际上建议对字符串进行一些预处理

str1 = 'ggtacTGAGGTCCCCTGGGTACTGAGATCTCCTCGGTACTGAAGTCTCCTCGGTGCTGAGGTCGCCTCGGTGCTGAGACCTCCTAGGTATTGAGGTCGCCTCGGTACTGAGGTTGCCTC----------------------------GGTGCTGAGGT-----CGCCACGGTGCTGAGACCTCCTAGATACTGAGG----TCTCCTAGGCACGGAGATCTCCTATGTACAGAGACCTCGTCGGTACTGAGGTCGCCTAGGTACTGAGACCTTCTAGGTCCTGAGGT--------CTAGGTACTGAGG-CCTTCTCC'
str2 = 'GATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTT-CCTCTCCCGGGATGCTGAGGTTCCTCTCCCGGGATGCTGAGGTTCCTCTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCTCTCCCAG---------------------------------GATGCTGAGGTTCCCAGGATGCTGAGGTTCCCAGGATGCTGAGGTTCCTCTCCCAGGATGCTGAGGTTCCTCTCC'
str1 = list(str1)
str2 = list(str2)

shortest_len = min(len(str1), len(str2))

for i in range(shortest_len):
    if str1[i] == '-' or str2[i] == '-':
        str1[i] = '-'
        str2[i] = '-'

str1 = '-'.join(str1).replace('-','')
str2 = '-'.join(str2).replace('-','')

这只是确保两个字符串在完全相同的索引处都有“-”，然后您可以将它们从字符串中删除。

【讨论】：

但是，如果其中任何一个字母是“-”，您将删除每个字母。它不应该被关闭，因为在这种情况下两个字符串的长度不一样。
因为如果其中一个字符串在位置 i 有破折号，那么另一个肯定会遇到不匹配的权利，我们可以认为两者在该位置都有破折号
str1 = 'ATCGATCGATCG------ATCGATCG' str2 = 'CGcgCGCGCGCG---CGCCGCGcgCG' 预处理后：str1 = 'ATCGATCGATCG------ATCGATCG' str2 = 'CGcgCGCGCGCG-- ----CGCGcgCG'，然后如果您删除破折号，您将得到与您要求的完全相同的答案。

【解决方案2】：

我不会修改您的代码，而是在进入您编写的代码之前添加几行来准备您的字符串。

假设我们有这两个字符串：

str1 = GCGC----ATGC
str2 = GC----AgcTGG

在这种情况下，如果两个字符串中的一项中有'-'，只需删除'-'和与删除的'-'具有相同索引的字母在这种情况下，您将拥有：

str1_preprocessed = GCATGC (GCGC----ATGC)

str2_preprocessed = GCcTGG (GC----AgcTGG)

然后你就可以为你的函数准备好你的字符串了。

【讨论】：

【解决方案3】：

答案将是以下函数。我使用exclusive1 和exclusive2 变量分别通过跳过'-' 来计算str1 和str2 的索引。但我保持 2 个字符串的长度相同。然后我使用第三个'for循环'来计算匹配字符串的开始和结束索引（考虑到包含'-'的原始字符串）。然后我用这些开始和结束索引作为exclusive1和exclusive2变量的索引。

def matched_indices():
    str1 = 'GGTGGCGGGGACGGACTCGTGGTGACATGTCCGCGTGTGTGCTTTGCTCTCAGGGAGCCACGACACGATGACGTACTGCCTGAACAAGAAGTCCCCCATTTCGCACGAGGAGTCCCGGCTGCTGCAGCTGCTGAACAAGGCCTTGCCCTGCATCACGCGCCCTGTCGTGCTGAAATGGTCCGTCACCCAGGTACGG\n'
    str2 = 'GGCGTCAGGGGCGG---------GATATGACCG-GTGACTTGCGTGTCCCCAGGGAGCCACGACACGATGACATACTGCCTGAACCGTAAGTCTCGGATCTCCCGTGCAAGTTCGTGGCTACTGCACCTGTTGGGCCGGGTCGTGCCATTCATCACCGGGCCCGTGGTGATGAAATGGTCGGTCACACAGGTGAGG\n'
    
    exclusive1 = [] #new indices skipping indels for 1st sequence
    exclusive2 = [] #new indices skipping indels for 2nd sequence
    count=0
    for idx, val in enumerate(str1):
        if (val not in ['-', '\n', '+', '-', '.']) and (idx!=len(str1)-1) and (str1[idx+1] not in ['-', '\n', '+', '-', '.']): #str is not '-' and not the last idx and next is not '-'
            exclusive1.append(count)
            count+=1
        elif (val not in ['-', '\n', '+', '-', '.']) and (idx==len(str1)-1): #str is not '-' and the last idx
            exclusive1.append(count)
        elif (val in ['-', '\n', '+', '-', '.']) and (idx!=len(str1)-1) and (str1[idx+1] not in ['-', '\n', '+', '-', '.']): #str is '-' and not the last idx and next is not '-'
            exclusive1.append(count)
            count+=1        
        else: #str is '-'
            exclusive1.append(count)
    count=0
    for idx, val in enumerate(str2):
        if (val not in ['-', '\n', '+', '-', '.']) and (idx!=len(str2)-1) and (str2[idx+1] not in ['-', '\n', '+', '-', '.']):
            exclusive2.append(count)
            count+=1
        elif (val not in ['-', '\n', '+', '-', '.']) and (idx==len(str2)-1):
            exclusive2.append(count)
        elif (val in ['-', '\n', '+', '-', '.']) and (idx!=len(str2)-1) and (str2[idx+1] not in ['-', '\n', '+', '-', '.']):
            exclusive2.append(count)
            count+=1        
        else:
            exclusive2.append(count)

    matches = []
    for i,(letter1, letter2) in enumerate(zip(str1,str2)):#i=index, letter1=str1, letter2=str2
        if ((letter1 == letter2) and (letter1 in ['A','T','C','G']) and (letter2 in ['A','T','C','G'])):            
            if not matches or matches[-1][1] != i-1:
                matches.append([i,i])
            else:
                matches[-1][1] += 1
    
    start = [k[0] for k in matches]
    end = [k[1] for k in matches]
    
    first_start = [exclusive1[i] for i in start]
    second_end = [exclusive2[i] for i in end]
    first_end = [exclusive1[i] for i in end]
    second_start = [exclusive2[i] for i in start]

    return first_start, first_end, second_start, second_end


first_start = []
first_end = []
second_start = []
second_end = []
for _ in starmap(list.extend, zip([first_start, first_end, second_start, second_end], matched_indices())):
            pass
print(first_start, first_end, second_start, second_end)

输出：

first_start [0, 3, 5, 7, 11, 23, 26, 30, 34, 39, 44, 48, 50, 73, 88, 94, 97, 100, 103, 106, 112, 116, 121, 127, 131, 135, 138, 141, 143, 148, 150, 158, 160, 163, 166, 170, 181, 187, 194] 

first_end [1, 3, 5, 9, 13, 24, 28, 32, 36, 39, 45, 48, 71, 84, 92, 94, 98, 101, 103, 106, 113, 119, 125, 129, 132, 135, 139, 141, 146, 148, 155, 158, 161, 164, 168, 179, 185, 191, 195] 

second_start [0, 3, 5, 7, 11, 14, 17, 21, 24, 29, 34, 38, 40, 63, 78, 84, 87, 90, 93, 96, 102, 106, 111, 117, 121, 125, 128, 131, 133, 138, 140, 148, 150, 153, 156, 160, 171, 177, 184] 

second_end [1, 3, 5, 9, 13, 15, 19, 23, 26, 29, 35, 38, 61, 74, 82, 84, 88, 91, 93, 96, 103, 109, 115, 119, 122, 125, 129, 131, 136, 138, 145, 148, 151, 154, 158, 169, 175, 181, 185]

尽管是相同匹配字符串的一部分，但您可以在两个字符串中看到上述 4 个索引的差异。这就是我今天试图解决并寻求帮助的问题，但似乎没有人正确理解我的问题。因此，我附上解决方案以供将来提供帮助。

【讨论】：