需要有关功能的帮助

Question

func

one_frame

应该解析

chars

，以便以 3 的倍数搜索

chars

，当遇到 ATG 时，应该调用 func

orf

。然后将该结果添加到

chars

中的帧列表中，然后在最后一个 ATG 之后的点上继续，并重复直到到达末尾。此函数应返回

chars

中所有 orf 的列表。

def one_frame(chars):
    start = 'ATG'
    l = []
    y = 0
    while y < len(chars):
        sub = chars[y:y + 3]
        if start in sub:
            l.append(get_orf(chars))
            return l
        else:
            y += 3

one_frame('ATGAGATGAACCATGGGGTAA')

最底层的 func 调用是一个测试用例。它应该等于

['ATGAGA', 'ATGGGG']

，但是我的代码只返回“ATGAGA”。

Answer 1

您有几个问题：

1. 循环内有

   return list_of_codons

   。因此，您一找到第一个匹配项就返回，并且只返回那个匹配项。将其放在函数末尾，而不是循环内部。

2. 您在

   y += 3

   块中有

   else:

   。因此，当您找到匹配的密码子时，您不会增加

   y

   ，并且您将陷入循环。

3. 您需要在从

   get_orf()

   开始的字符串切片上调用

   y

   ，而不是整个字符串（任务 b）。

4. 任务 d 表示您必须跳到任务 b 中返回的 ORF 之后的点，而不仅仅是继续下一个密码子。

def one_frame(seq):
    start_codon = 'ATG'
    list_of_orfs = []
    y = 0
    while y < len(seq):
        subORF = seq[y:y + 3]
        if start_codon = subORF:
            orf = get_orf(seq[y:])
            list_of_orfs.append(orf)
            y += len(orf)
        else:
            y += 3

    return list_of_orfs

one_frame('ATGAGATGAACCATGGGGTAA')

Answer 2

如注释中所述，此代码中存在许多问题。 我认为这确实是你应该做的：

def one_frame(seq):
    start_codon = 'ATG'
    list_of_codons = []
    y = 0
    while y < len(seq):
        if seq[y:y+3] == start_codon:
            orf = get_orf(seq[y:])
            list_of_codons.append(orf)
            y += len(orf)
        else:
            y += 3
    return list_of_codons 
  
one_frame('ATGAGATGAACCATGGGGTAA')

Answer 3

尝试将

seq

拆分为密码子：

def one_frame(seq):                                                                                     
    shift = 3                                                                                           
    codons = [seq[i:i+shift] for i in range(0, len(seq), shift)]                                                
                                                                                                        
    start_codon = "ATG"                                                                                 
    orf_list = []                                                                                       
    for codon in codons:                                                                                
        if codon == start_codon:                                                                        
            orf_list += [get_orf(codon)]                                                                
                                                                                                        
    return orf_list                                                                                     
                                                                                                        
                                                                                                        
seq = 'ATGAGATGAACCATGGGGTAA'                                                                           
one_frame(seq)  

Answer 4

方法略有不同，但由于我对 DNA 测序一无所知，这可能没有意义。无论如何，这里是：

def one_frame(seq):
    start_codon = 'ATG'
    list_of_codons = []
    offset = 0

    while (i := seq[offset:].find(start_codon)) >= 0:
        offset += i
        list_of_codons.append(get_orf(seq[offset:]))
        offset += len(list_of_codons[-1])
    
    return list_of_codons

以这种方式，find() 最初从序列的开头开始搜索，但随后仅从任何先前密码子的末尾开始搜索