Question

所以最近我一直试图编写一个程序来检测和删除基于起始和终止密码子的DNA序列的编码部分。

最终的目标是比较两个长度为240个核苷酸的2个序列，但是其中一个会引起镰状细胞病，因此您希望看到两者之间的差异。

这是我到目前为止编写的代码，它实际上与它附带的序列一起使用。

sequence = "CCATGCTTGATCA"
sequence_list = list(sequence)
codon_list = ["ATG", "TAA", "TAG", "TGA"]
position_list = []

length_sequence = len(sequence)
length_codon = len(codon_list)
length_position = len(position_list)

n = length_sequence-1
while n >= 0:

    for i in range(0, len(codon_list)):
        codon_sub_list = list(codon_list[i])

        if sequence_list[n] == codon_sub_list[2] and sequence_list[n-1] == codon_sub_list[1] and sequence_list[n-2] == codon_sub_list[0]:
            position_list.append(n-2)
            print(sequence_list[n], "@", n)
            print(sequence_list[n-1], "@", n-1)
            print(sequence_list[n-2], "@", n-2)  

    n-=1

print(len(position_list))
print(sequence[position_list[length_position-1]:(position_list[0]+3)])

现在，我两天前做的结果非常有希望。正如预期的那样，它给出了以下结果：

位置9

G位于第8位

位于第7位

G位于第4位

位于第3位

A位置2

[7,2]

ATGCTTGA

然而，今天我尝试通过尝试不同的序列来继续这项工作，这次是240个核苷酸长的序列之一。下面是两个序列，它是哪一个。

镰状细胞病序列：GAGCCATCTATTGCTTACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGTGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATGTGGAGACAGAGAAGACTCTTGGGTTTCT

正常序列：GAGCCATCTATTGCTTACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATGTGGAGACAGAGAAGACTCTTGGGTTTCT

然而，这是我从执行它得到的结果，我将快速列出核苷酸及其位置，因为它们中的大多数是无关紧要的，并且它主要是最后一个重要的。

[G，211] [T，210] [A，209] [G，199] [A，198] [T，197] [A，187] [A，186] [T，185] [A [145,13] [G，144] [T，143] [A，133] [G，132] [T，131] [G，132] [T，131] [A，130] [A，123] [G ，122] [T，121] [A，78] [G，77] [T，76] [G，68] [T，67] [A，66] [G，47] [A，46] [T ，45] [A，29] [G，28] [T，27] [A，1] [G，0] [T，-1]

[209,197,185,143,131,130,121,76,66,45,27，-1]

没有序列，只是一个空行

现在很明显问题出现在最后一个密码子，TGA时，它注意到T的位置为-1，但我不知道是什么导致这种情况并尝试调整几个值以某种方式让它工作，它没有＆在任何情况下都要这样做。

我想知道是什么导致了这个以及如何处理它？另外，我两天前做的主要是作为一个开始的草案，并且可能有其他更好的事情，所以如果有什么看起来有点草率的借口，在我看来整个while循环可以做得更好，但在那我选择它的那一刻是因为一种不同的循环方法无法正常工作，因此无法真正记住它到底是什么。

注意：我制作了IDLE输出的屏幕截图，为您提供了一个想法：

Answer 1

我发现您的原始代码有点不清楚（从搜索的右边开始对我来说是违反直觉的），所以我尝试编写替代方案。最重要的变化是我现在从左到右遍历序列，并通过一次性将它们与子序列进行比较来搜索密码子，而不是核苷酸 - 核苷酸。这是我的代码，有一些希望有用的评论。这样做你需要的吗？如果没有，请告诉我。

sequence = "GAGCCATCTATTGCTTACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGTGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATGTGGAGACAGAGAAGACTCTTGGGTTTCT"
codon_list = ["ATG", "TAA", "TAG", "TGA"]

# store the starting positions of the codons
found_codon_positions = []

# note that we can use len() and [] with strings as well, no need to
# convert to list first
n = len(sequence)
k = 0
while k < n-2:
    # extract a three-nucleotide subsequence
    possible_codon = sequence[k:k+3]
    if possible_codon in codon_list:
        found_codon_positions.append(k)
    k += 1

print('found codons at indices {}'.format(found_codon_positions))

print('extracted sequence:')
print(sequence[found_codon_positions[0]:found_codon_positions[-1]+3])

输出：

found codons at indices [27, 45, 66, 76, 121, 130, 131, 143, 185, 197, 209]
extracted sequence:
TGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGTGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATG

Answer 2

不确定我是否遵循了所有逻辑，但是如果您想存储所有索引并找到开始的第一个和最后一个匹配的子序列：

def find_seq(s, cd):
    od = dict((s, []) for s in codon_list)
    mn, mx = None, None
    for n in range(len(s) - 1):
        seq = sequence[n:n + 3]
        if seq in od:
            od[seq].append((seq, n))
            if  mn is None:
                mn = n
            mx = n + 3
    return mn, mx, od

dict将找到所有子序列以及每个子序列开始的索引：

In [54]: sequence = "CCATGCTTGATCA"

In [55]: codon_list = ["ATG", "TAA", "TAG", "TGA"]

In [56]: mn,mx,od = find_seq(sequence,codon_list)

In [57]: sequence[mn:mx]
Out[57]: 'ATGCTTGA'

In [58]: od
Out[58]: {'ATG': [('ATG', 2)], 'TAA': [], 'TAG': [], 'TGA': [('TGA', 7)]}

In [59]: sequence = """GAGCCATCTATTGCTTACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGTGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATGTGGAGACAGAGAAGACTCTTGGGTTTCT"""

In [60]: mn,mx,od = find_seq(sequence,codon_list)

In [61]: sequence[mn:mx]
Out[61]: 'TGACACAACTGTGTTCACTAGCAACCTCAAACAGACACCATGGTGCACCTGACTCCTGTGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGCAGGTTGGTATCAAGGTTACAAGACAGGTTTAAGGAGACCAATAGAAACTGGGCATG'

In [62]: od
Out[62]: 
{'ATG': [('ATG', 66), ('ATG', 130), ('ATG', 209)],
 'TAA': [('TAA', 185)],
 'TAG': [('TAG', 45), ('TAG', 197)],
 'TGA': [('TGA', 27), ('TGA', 76), ('TGA', 121), ('TGA', 131), ('TGA', 143)]}

Python代码，用于查找带有起始密码子和终止密码子的编码DNA

2 个答案: