Question

这个问题与生物学有关，所以对于那些知道氨基酸和密码子是什么的人来说，这太棒了！对于那些不这样做的人，我尽力说出来，以便你能理解我在说什么。

所以我有一个密码子列表，也可以称为3个字母的字符串，它由以下四个字母的组合组成：A，G，C，T即AAT，GAT，GCT等。每个密码子对应于特定的氨基酸，但有多个密码子可以对应于相同的氨基酸。为了说明这一点，请查看以下链接：http://www.cbs.dtu.dk/courses/27619/codon.html。这应该说清楚。

对于我名单上的每个密码子，我想最终找出它对应的氨基酸。因此，我必须使程序首先将该密码子与我发布链接的密码子列表（总共64个可能的密码子）进行比较，然后我必须要求程序查看该密码子对应的氨基酸。然而，我无法找到一种快捷方法，无需为与给定氨基酸相对应的所有密码子列出并比较它们，或者编写20种不同的if语句。

我所拥有的密码子列表叫做mutated_codon。因此，我需要生成一个'for'，程序将mutated_codon列表中的每个密码子进行比较，并将其与字典进行比较并输出相应的氨基酸字母。为了做到这一点，我必须编写什么代码？我不熟悉用于检查字典中的值的语法。

以下是基于建议我到目前为止所做的事情：

codon_lookup = {'GCT'：'A'，'GCC'：'A'，'GCA'：'A'，'GCG'：'A'，'TGT'：'C'，'TGC'： 'C'，'GAT'：'D'，'GAC'：'D'，'GAA'：'E'，'GAG'：'E'，'TTT'：'F'，'TTC'：'F '，'GGT'：'G'，'GGC'：'G'，'GGA'：'G'，'GGG'：'G'，'CAT'：'H'，'CAC'：'H'， 'ATT'：'我'，'ATC'：'我'，'ATA'：'我'，'AAA'：'K'，'AAG'：'K'，'TTA'：'L'，'TTG '：'L'，'CTT'：'L'，'CTC'：'L'，'CTA'：'L'，'CTG'：'L'，'ATG'：'M'，'AAT'： 'N'，'AAC'：'N'，'CCT'：'P'，'CCC'：'P'，'CCA'：'P'，'CCG'：'P'，'CAA'：'Q '，'CAG'：'Q'，'CGT'：'R'，'CGC'：'R'，'CGA'：'R'，'CGG'：'R'，'AGA'：'R'， 'AG'：'R'，'TCT'：'S'，'TCC'：'S'，'TCA'：'S'，'TCG'：'S'，'AGT'：'S'，'AGC '：'S'，'ACT'：'T'，'ACC'：'T'，'ACA'：'T'，'ACG'：'T'，'GTT'：'V'，'GTC'： 'V'，'GTA'：'V'，'GTG'：'V'，'TGG'='W'，'TAT'：'Y'，'TAC'：'Y'，'TAA'：'Z '，'TAG'：'Z'，'TGA'：'Z'}

for c in mutated_codon:
   print codon_lookup[c]

HOwever，在我的输出中，我只获得与列表中最后一个密码子相对应的氨基酸的输出，最重要的是，我得到KeyError：4。任何想法可能是错的？

Answer 1

您可以像这样设置字典：

codon_lookup = {
    'ATT':'Isoleucine',
    'ATC':'Isoleucine', 
    'ATA':'Isoleucine',
    'CTT':'Leucine',
    'CTC':'Leucine', 
    'CTA':'Leucine',
     # ... etc
}

然后你可以进行像

这样的查询

codon_lookup['ATT']

哪个会给你

'Isoleucine'

修改

您可以像这样设置字典：

codon_lookup = { 'ATT':'I', 'ATC':'I', 'ATA':'I', 'CTT':'L', 'CTC':'L', 'CTA':'L', # ... etc }

然后你可以进行像
这样的查询
codon_lookup['ATT']

哪个会给你

'I'

如果您想查看此词典的mutated_condons列表，可以像这样循环播放。如果您的mutated_condons列表看起来像['ACA','GTT',...]，那么：

for mutated_codon in mutated_condons: print codon_lookup[mutated_codon]

Answer 2

根据另外两个答案，这是构建它的另一种方式，我认为这可能是最好的。

这将为您提供两个方向的查找词典：SLC到Codon（s）和Codon到SLC。

slc_codon = {
    'I': ['ATT', 'ATC', 'ATA'],
    'L': ['CTT', 'CTC', 'CTA', 'CTG', 'TTA', 'TTG'],
    'V': ['GTT', 'GTC', 'GTA', 'GTG'],
    'F': ['TTT', 'TTC'],
    'M': ['ATG'],
    'C': ['TGT', 'TGC'],
    'A': ['GCT', 'GCC', 'GCA', 'GCG'],
    'G': ['GGT', 'GGC', 'GGA', 'GGG'],
    'P': ['CCT', 'CCC', 'CCA', 'CCG'],
    'T': ['ACT', 'ACC', 'ACA', 'ACG'],
    'S': ['TCT', 'TCC', 'TCA', 'TCG', 'AGT', 'AGC'],
    'Y': ['TAT', 'TAC'],
    'W': ['TGG'],
    'Q': ['CAA', 'CAG'],
    'N': ['AAT', 'AAC'],
    'H': ['CAT', 'CAC'],
    'E': ['GAA', 'GAG'],
    'D': ['GAT', 'GAC'],
    'K': ['AAA', 'AAG'],
    'R': ['CGT', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'],
    '*': ['TAA', 'TAG', 'TGA'],
}

codon_slc = dict((x, k) for k, v in slc_codon.items() for x in v)

>>> print codon_slc
>>> {'CTT': 'L', 'ATG': 'M', 'AAG': 'K', 'AAA': 'K', 'ATC': 'I', 'AAC': 'N', 'ATA': 'I', 'AGG': 'R', 'CCT': 'P', 'ACT': 'T', 'AGC': 'S', 'ACA': 'T', 'AGA': 'R', 'CAT': 'H', 'AAT': 'N', 'ATT': 'I', 'CTG': 'L', 'CTA': 'L', 'CTC': 'L', 'CAC': 'H', 'ACG': 'T', 'CAA': 'Q', 'AGT': 'S', 'CAG': 'Q', 'CCG': 'P', 'CCC': 'P', 'TAT': 'Y', 'GGT': 'G', 'TGT': 'C', 'CGA': 'R', 'CCA': 'P', 'TCT': 'S', 'GAT': 'D', 'CGG': 'R', 'TTT': 'F', 'TGC': 'C', 'GGG': 'G', 'TAG': '*', 'GGA': 'G', 'TAA': '*', 'GGC': 'G', 'TAC': 'Y', 'GAG': 'E', 'TCG': 'S', 'TTA': 'L', 'GAC': 'D', 'TCC': 'S', 'GAA': 'E', 'TCA': 'S', 'GCA': 'A', 'GTA': 'V', 'GCC': 'A', 'GTC': 'V', 'GCG': 'A', 'GTG': 'V', 'TTC': 'F', 'GTT': 'V', 'GCT': 'A', 'ACC': 'T', 'TGA': '*', 'TTG': 'L', 'CGT': 'R', 'TGG': 'W', 'CGC': 'R'}

Answer 3

回答只是为了解决如何从字典中查找蛋白质的问题。正确地创建字典是你问题的核心，到目前为止给出的答案很好地解决了这个问题。我个人最喜欢FogleBird的反向构造，但任何定义字典映射核苷酸符号三倍到氨基酸的方法都可以正常工作。

在您对问题的编辑中定义codon_lookup字典以及名为mutated_codon的三字母字符串列表时，从变异列表中打印氨基酸符号的最简单方法密码子就是这样：

for codon in mutated_codon:
    print codon_lookup[codon]

或者，在Python 3.X中：

for codon in mutated_codon:
    print(codon_lookup[codon])

它更符合通常的Python样式来命名列表mutated_codons，因为它几乎肯定会是复数，但这并不是什么大问题。我将继续下面的mutated_codon。

如果我正在编写这段代码，我可能会得到一个突变密码子的氨基酸列表，并可能在该列表上打印或做其他事情。最简单的方法是使用列表推导来定义新列表：

acids = [codon_lookup[codon] for codon in mutated_codon]

对于构建新列表的for循环，这或多或少是语法糖：

acids = []
for codon in mutated_codon:
    acids.append(codon_lookup[codon])

但它更简洁。我在没有实际测试两个不同版本的情况下犹豫描述性能，但我相信列表理解形式也更快。

无论哪种方式，我都可以迭代该列表来打印它们：

for acid in acids:
    print acid

以及进行任何进一步的必要处理。

值得指出的另一个选择是字典上的get方法。上面的代码都使用字典上的直接键查找，如果在KeyError字典中找不到您的密码子，则会引发codon_lookup。这可能是最好的选择 - 您正在使用有限的输入范围，如果某些事情导致您在mutated_codon列表中得到一个不是有效密码子的字符串，您可能希望看到该异常而非而不是隐藏它。但是，如果在将来某种情况下您处理的控制较少，您可能会发现get方法很有用。字典的这种方法接受键和可选的默认值。如果密钥在字典中，则返回该密钥的字典值。如果密钥不在字典中，则返回默认值（如果提供了一个）或None（如果没有）。例如，如果您希望您的代码将任何未知密码子视为停止，您可以编写如下内容：

for codon in mutated_codon:
    print codon_lookup.get(codon, '*')

自从我之前提到biopython以来，这是一个从docs使用translate将DNA核苷酸转换为氨基酸的例子：

>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_dna
>>> coding_dna = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG", generic_dna)
>>> coding_dna.translate()
Seq('MAIVMGR*KGAR*', HasStopCodon(ExtendedIUPACProtein(), '*'))

我链接的文档有更详细的内容。对于这个特定的任务，它可能比您需要的更多，但如果您需要比简单的转换表更进一步，它可能会为您节省一些工作。

Answer 4

您可以完全按原样记下表格（来自您提供的链接）：

table =
    [
        {
            'amino_acid': 'Isoleucine',
            'codons': [ 'ATT', 'ATC', 'ATA' ]
        },
        {
            'amino_acid': 'Leucine',
            'codons': [ 'CTT', 'CTC', 'CTA', 'CTG', 'TTA', 'TTG' ]
        },
        ...etc...
    ]

然后使用以下内容转换为从密码子映射到氨基酸的字典：

lookup = dict(itertools.chain.from_iterable(
    [[(codon, row['amino_acid']) for codon in row['codons']] for row in table]))

例如，lookup['TTA']提供'Leucine'。

我觉得这比重复氨基酸名称稍微优雅一样，就像在农民家的答案中那样，但这可能是一个意见问题。最好以最简洁的方式进行数据输入，然后以编程方式对其进行转换，而不是手动转换它。

Answer 5

拿起蒂莫西·希尔兹对自己答案的评论，如果你能从http://www.cbs.dtu.dk/courses/27619/codon.html抓住桌子并生成你的映射，那就太好了。

如果您尝试从网页复制表格并将其粘贴为源代码中的文字字符串，您会看到一些问题。首先，不同的浏览器对如何复制表有不同的想法。更严重的是，该表写得非常不规律;有些列没有换行符，有些列有一行，有些列有两行，有些列甚至在换行符后有空格。这将很难解析。

但是，如果你使用HTML源代码，那就容易多了。不像应该那样容易（页面乱七八糟，任何地方都没有ID或名称，老式的HTML样式而不是CSS，等等），但是很明显这些值你想要的只是表格列，除了顶部的框表，框标题和页脚。所以，这是一个如何用BeautifulSoup做到这一点的例子。（如果你需要坚持使用标准库，那会更加冗长，但不是那么难。）

import urllib2
import bs4

url='http://www.cbs.dtu.dk/courses/27619/codon.html'
page = urllib2.urlopen(url)
soup = bs4.BeautifulSoup(page)
codon_lookup = {}
for row in soup.find_all('tr')[2:-1]:
    amino, slc, codons = (col.text.strip() for col in row.find_all('td'))
    if slc == 'Stop':
        slc = 'Z'
    for codon in codons.split(','):
        codon_lookup[codon.strip()] = slc

当然，在现实生活中，您可能不希望您的程序每次需要运行时都必须联机。但您可以轻松地将此程序保存到pickle文件（或JSON文件，或您喜欢的任何其他内容）。只需添加以下行：

import pickle
with open('codons.pickle', 'wb') as f:
    pickle.dump(codon_lookup, f)

现在，在您的主程序中，您只需从：

开始

with open('codons.pickle', 'rb') as f:
    codon_lookup = pickle.load(f)

如何在不写20个if语句或制作20个列表/词典的情况下进行以下比较？

5 个答案: