Python 生物信息学：用字典键匹配列表项并打印匹配键

家庭作业辅助

我需要写一个函数，它能够从用户那里接收包含DNA密码子的字符串，例如

'ACATTTGCTTCTGACACAACTGTGTTCACTAGCAACCTCAAAC'

将字符串分成3组，然后将每组与字典项相匹配。但是程序必须只打印出键，而不是值

输入：

attghiatgttctyu

分离：

[ATT][GHI][ATG][TTT][TTC][TYU]

输出：

IMFF

这就是我目前所拥有的

dna_codons = {'I': 'ATT' 'ATC' 'ATA',
              'L': 'CTT' 'CTC' 'CTA' 'CTG' 'TTA' 'TTG',
              'V': 'GTT' 'GTC' 'GTA' 'GTG',
              'F': 'TTT' 'TTC',
              'M': 'ATG',
              }
def translate(sequence):
    n = 3
    MyList = [sequence[i:i+n] for i in range(0, len(sequence), n)]
    for codon in MyList:
        for slc in dna_codons.keys():
            if codon == slc:
                print slc

print translate(raw_input('type in DNA sequence: '))

---

使用列表理解和生成器将输入字符串拆分为块，可以更轻松地实现这一目标

试着这样做：

in_seq = 'ATTGHIATGTTTTTCTYU'  # change this to input()

_codes = {  # your original dict is incorrect
    'ATT': 'I', 'ATC': 'I', 'ATA': 'I',
    'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'TTA': 'L', 'TTG': 'L',
    'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
    'TTT': 'F', 'TTC': 'F',
    'ATG': 'M',
}


def split_seq(s, n=2):
    """ split string to chunks of size n """
    i = 0
    while i < len(s):
        yield s[i:i + n]
        i += n

out_codes = [_codes[z.upper()] for z in split_seq(in_seq, 3) if z.upper() in _codes]
result = ''.join(out_codes)
print(result)

---

使用列表理解和生成器将输入字符串拆分为块，可以更轻松地实现这一目标

试着这样做：

in_seq = 'ATTGHIATGTTTTTCTYU'  # change this to input()

_codes = {  # your original dict is incorrect
    'ATT': 'I', 'ATC': 'I', 'ATA': 'I',
    'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L', 'TTA': 'L', 'TTG': 'L',
    'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
    'TTT': 'F', 'TTC': 'F',
    'ATG': 'M',
}


def split_seq(s, n=2):
    """ split string to chunks of size n """
    i = 0
    while i < len(s):
        yield s[i:i + n]
        i += n

out_codes = [_codes[z.upper()] for z in split_seq(in_seq, 3) if z.upper() in _codes]
result = ''.join(out_codes)
print(result)

---

代码的主要问题是，

'I'：“ATT”“ATC”“ATA'，

不起作用。字符串只是集中在一起（

attattata

）。您需要将这些字符串转换为列表：

'I'：['ATT'，'ATC'，'ATA'，

。然后，可以使用嵌套循环在字典和列表上进行迭代：

for slc in dna_codons.keys():
    for item in dna_codons[slc]:
        if codon == item:
            print slc

最后，末尾的print语句将始终打印

none

，因为函数不返回任何要打印的内容。理想情况下，您的函数应该返回所需的输出，而不是作为副作用打印：

aa_seq =''
for codon in MyList:  
    for slc in dna_codons.keys():
        for item in dna_codons[slc]:
            if codon == item:
                aa_seq += slc
return aa_seq

当然，如果必须循环每个密码子的所有值，那么使用字典并不会带来太多好处。以密码子为键，以氨基酸为值，效率会更高。这样，您就可以使用：

aa_seq = ''
for codon in MyList:
    aa_seq += dna_codons[codon]
return aa_seq

---

代码的主要问题是，

'I'：“ATT”“ATC”“ATA'，

不起作用。字符串只是集中在一起（

attattata

）。您需要将这些字符串转换为列表：

'I'：['ATT'，'ATC'，'ATA'，

。然后，可以使用嵌套循环在字典和列表上进行迭代：

for slc in dna_codons.keys():
    for item in dna_codons[slc]:
        if codon == item:
            print slc

最后，末尾的print语句将始终打印

none

，因为函数不返回任何要打印的内容。理想情况下，您的函数应该返回所需的输出，而不是作为副作用打印：

aa_seq =''
for codon in MyList:  
    for slc in dna_codons.keys():
        for item in dna_codons[slc]:
            if codon == item:
                aa_seq += slc
return aa_seq

当然，如果必须循环每个密码子的所有值，那么使用字典并不会带来太多好处。以密码子为键，以氨基酸为值，效率会更高。这样，您就可以使用：

aa_seq = ''
for codon in MyList:
    aa_seq += dna_codons[codon]
return aa_seq

---

首先，您必须更改您的

dna\u密码子

以将值作为列表或元组。目前，三元组的字符串将被连接成一个字符串

dna_codons = {
    'I': ['ATT', 'ATC', 'ATA'],
    'L': ['CTT', 'CTC', 'CTA', 'CTG', 'TTA', 'TTG'],
    'V': ['GTT', 'GTC', 'GTA', 'GTG'],
    'F': ['TTT', 'TTC'],
    'M': ['ATG'],
}

现在可以使用@heathobrien的嵌套循环，但是这些循环效率很低。我认为你应该修改字典，这样它就可以从密码子映射到氨基酸。您可以通过以下方式完成：

def transpose(d):
    out = {}
    for key, values in d.items():
        for val in values:
            out[val] = key
    return out

codon_to_aa = transpose(dna_codons)

这将生成一个字典

{'ATG'：'M'，'ATT'：'I'，'ATC'：'I'，…}

。 在那之后，剩下的就很简单了。您只需要拆分序列并找到适当的映射。重用代码：

def translate(sequence):
    n = 3
    codons = (sequence[i:i+n] for i in range(0, len(sequence), n))
    for codon in codons:
        print codon_to_aa.get(codon, ''),
    print

translate(raw_input('type in DNA sequence: '))

第一个

打印

后的逗号确保下一个字符打印在同一行上。空的

打印将结束该行。但是，我建议您将输出聚合到一个变量中，并一次将其全部打印出来

或者：

def translate(sequence):
    n = 3
    return ''.join(codon_to_aa.get(codon, '') for codon in   
                      (sequence[i:i + n] for i in xrange(0, len(sequence), n)))

print translate(raw_input('type in DNA sequence: '))

首先，您必须更改您的
dna\u密码子
以将值作为列表或元组。目前，三元组的字符串将被连接成一个字符串

dna_codons = {
    'I': ['ATT', 'ATC', 'ATA'],
    'L': ['CTT', 'CTC', 'CTA', 'CTG', 'TTA', 'TTG'],
    'V': ['GTT', 'GTC', 'GTA', 'GTG'],
    'F': ['TTT', 'TTC'],
    'M': ['ATG'],
}

现在可以使用@heathobrien的嵌套循环，但是这些循环效率很低。我认为你应该修改字典，这样它就可以从密码子映射到氨基酸。您可以通过以下方式完成：

def transpose(d):
    out = {}
    for key, values in d.items():
        for val in values:
            out[val] = key
    return out

codon_to_aa = transpose(dna_codons)

这将生成一个字典
{'ATG'：'M'，'ATT'：'I'，'ATC'：'I'，…}
。
在那之后，剩下的就很简单了。您只需要拆分序列并找到适当的映射。重用代码：

def translate(sequence):
    n = 3
    codons = (sequence[i:i+n] for i in range(0, len(sequence), n))
    for codon in codons:
        print codon_to_aa.get(codon, ''),
    print

translate(raw_input('type in DNA sequence: '))

第一个
打印
后的逗号确保下一个字符打印在同一行上。空的
打印将结束该行。但是，我建议您将输出聚合到一个变量中，并一次将其全部打印出来

或者：

def translate(sequence):
    n = 3
    return ''.join(codon_to_aa.get(codon, '') for codon in   
                      (sequence[i:i + n] for i in xrange(0, len(sequence), n)))

print translate(raw_input('type in DNA sequence: '))

这里有一种方法可以使用名为的生成器函数的
itertools
配方来实现

这里有一种方法可以使用名为的生成器函数的
itertools
配方来实现

您在
def transponse（d）中有一个输入错误：
您在
def transponse（d）中有一个输入错误：
谢谢，伙计。我还没有学会“收益率”。这对我来说是新鲜事。这有什么用呢？不客气：）
收益率与
收益率有点类似。它用于称为生成器的特殊函数中。您可以在此处了解更多信息-。更新了答案。您可以用普通函数替换生成器，该函数返回一个表示拆分输入字符串的
列表。谢谢。我还没有学会“收益率”。这对我来说是新鲜事。这有什么用呢？不客气：）
收益率与
收益率有点类似。它用于称为生成器的特殊函数中。您可以在此处了解更多信息-。更新了答案。您可以使用普通函数替换生成器，该函数返回表示拆分输入字符串的
列表。