翻译我的序列？

Question

我必须编写一个脚本来翻译这个序列：

dict = {"TTT":"F|Phe","TTC":"F|Phe","TTA":"L|Leu","TTG":"L|Leu","TCT":"S|Ser","TCC":"S|Ser",
              "TCA":"S|Ser","TCG":"S|Ser", "TAT":"Y|Tyr","TAC":"Y|Tyr","TAA":"*|Stp","TAG":"*|Stp",
              "TGT":"C|Cys","TGC":"C|Cys","TGA":"*|Stp","TGG":"W|Trp", "CTT":"L|Leu","CTC":"L|Leu",
              "CTA":"L|Leu","CTG":"L|Leu","CCT":"P|Pro","CCC":"P|Pro","CCA":"P|Pro","CCG":"P|Pro",
              "CAT":"H|His","CAC":"H|His","CAA":"Q|Gln","CAG":"Q|Gln","CGT":"R|Arg","CGC":"R|Arg",
              "CGA":"R|Arg","CGG":"R|Arg", "ATT":"I|Ile","ATC":"I|Ile","ATA":"I|Ile","ATG":"M|Met",
              "ACT":"T|Thr","ACC":"T|Thr","ACA":"T|Thr","ACG":"T|Thr", "AAT":"N|Asn","AAC":"N|Asn",
              "AAA":"K|Lys","AAG":"K|Lys","AGT":"S|Ser","AGC":"S|Ser","AGA":"R|Arg","AGG":"R|Arg",
              "GTT":"V|Val","GTC":"V|Val","GTA":"V|Val","GTG":"V|Val","GCT":"A|Ala","GCC":"A|Ala",
              "GCA":"A|Ala","GCG":"A|Ala", "GAT":"D|Asp","GAC":"D|Asp","GAA":"E|Glu",
              "GAG":"E|Glu","GGT":"G|Gly","GGC":"G|Gly","GGA":"G|Gly","GGG":"G|Gly"}

seq = "TTTCAATACTAGCATGACCAAAGTGGGAACCCCCTTACGTAGCATGACCCATATATATATATATA"
a=""

for y in range( 0, len ( seq)):
    c=(seq[y:y+3])
    #print(c)
    for  k, v in dict.items():
        if seq[y:y+3] == k:
            alle_amino = v[::3] #alle aminozuren op rijtje, a1.1 -a2.1- a.3.1-a1.2 enzo
            print (v)

通过这个脚本，我从彼此下面的 3 个帧中获取氨基酸，但是我如何对其进行排序并从第 1 帧中获取彼此相邻的所有氨基酸，以及所有第 2 帧中的氨基酸彼此相邻，第 3 帧中的氨基酸也相同吗？

例如，我的结果必须是：

+3 SerIleLeuAlaStpProLysTrpGluProProTyrValAlaStpProIleTyrIleTyrTle

+2 PheAsnThrSerMetThrLysValGlyThrProLeuArgSerMetThrHisIleTyrIleTyr

+1 PheGlnTyrStpHisAspGlnSerGlyAsnProLeuThrStpHisAspProTyrIleTyrIle

TTTCAATACTAGCATGACCAAAGTGGGAACCCCCTTACGTAGCATGACCCATATATATATATATA

我使用 Python 3。

<块引用>

我还有一个问题：我可以通过对自己的脚本进行一些更改来得到这个结果吗？

Answer 1

你可以使用（注意，使用biopython翻译方法这会更容易）：

dictio = {your dictionary here}

def translate(seq):
    x = 0
    aaseq = []
    while True:
        try:
            aaseq.append(dicti[seq[x:x+3]])
            x += 3
        except (IndexError, KeyError):
            break
    return aaseq

seq = "TTTCAATACTAGCATGACCAAAGTGGGAACCCCCTTACGTAGCATGACCCATATATATATATATA"

for frame in range(3):
    print('+%i' %(frame+1), ''.join(item.split('|')[1] for item in translate(seq[frame:])))

注意我用dicti更改了你的字典的名称（不是覆盖dict）。

---

一些帮助您理解的注释：

translate 获取序列并以列表的形式返回它，其中每个项目对应于编码该位置的三联体的氨基酸翻译。例如：

aaseq = ["L|Leu","L|Leu","P|Pro", ....]

您可以在 translate 中处理更多此数据（仅获取一到三个字母代码），或者像我一样在稍后处理时返回它。

都会调用 translate

''.join(item.split('|')[1] for item in translate(seq[frame:]))

每帧 。对于帧值为 0、1 或 2 的情况，它发送 seq[frame:] 作为要转换的参数。也就是说，您正在发送与串行处理它们的三个不同阅读框架相对应的序列。然后，

   ''.join(item.split('|')[1]

我将每个氨基酸的一字母代码和三字母代码分开，并取索引 1 处的代码（第二个）。然后将它们连接成一个字符串

Answer 2

不太漂亮，但能达到你想要的效果

dct = {"TTT":"F|Phe","TTC":"F|Phe","TTA":"L|Leu","TTG":"L|Leu","TCT":"S|Ser","TCC":"S|Ser", 
"TCA":"S|Ser","TCG":"S|Ser", "TAT":"Y|Tyr","TAC":"Y|Tyr","TAA":"*|Stp","TAG":"*|Stp", 
"TGT":"C|Cys","TGC":"C|Cys","TGA":"*|Stp","TGG":"W|Trp", "CTT":"L|Leu","CTC":"L|Leu", 
"CTA":"L|Leu","CTG":"L|Leu","CCT":"P|Pro","CCC":"P|Pro","CCA":"P|Pro","CCG":"P|Pro", 
"CAT":"H|His","CAC":"H|His","CAA":"Q|Gln","CAG":"Q|Gln","CGT":"R|Arg","CGC":"R|Arg", 
"CGA":"R|Arg","CGG":"R|Arg", "ATT":"I|Ile","ATC":"I|Ile","ATA":"I|Ile","ATG":"M|Met", 
"ACT":"T|Thr","ACC":"T|Thr","ACA":"T|Thr","ACG":"T|Thr", "AAT":"N|Asn","AAC":"N|Asn", 
"AAA":"K|Lys","AAG":"K|Lys","AGT":"S|Ser","AGC":"S|Ser","AGA":"R|Arg","AGG":"R|Arg", 
"GTT":"V|Val","GTC":"V|Val","GTA":"V|Val","GTG":"V|Val","GCT":"A|Ala","GCC":"A|Ala", 
"GCA":"A|Ala","GCG":"A|Ala", "GAT":"D|Asp","GAC":"D|Asp","GAA":"E|Glu", 
"GAG":"E|Glu","GGT":"G|Gly","GGC":"G|Gly","GGA":"G|Gly","GGG":"G|Gly"}


seq = "TTTCAATACTAGCATGACCAAAGTGGGAACCCCCTTACGTAGCATGACCCATATATATATATATA"

def get_amino_list(s):
    for y in range(3):
        yield [s[x:x+3] for x in range(y, len(s) - 2, 3)]

for n, amn in enumerate(get_amino_list(seq), 1):
    print ("+%d " % n + "".join(dct[x][2:] for x in amn))

print(seq)

Answer 3

这是我的解决方案。我将你的“dict”变量称为“aminos”。函数method3 返回“|”右侧的值列表。要将它们合并为一个字符串，只需将它们连接到“”上即可。

通过查看您的代码，我相信您的氨基字典包含所有可能的三字母组合。因此，我删除了验证这一点的检查。结果它应该运行得更快。

def overlapping_groups(seq, group_len=3):
    """Returns `N` adjacent items from an iterable in a sliding window style
    """
    for i in range(len(seq)-group_len):
        yield seq[i:i+group_len]

def method3(seq, aminos):
    return [aminos[k][2:] for k in overlapping_groups(seq, 3)]

for i in range(3):
    print("%d: %s" % (i, "".join(method3(seq[i:], aminos))))