Bio.SeqRecord模块

表示序列记录，带注释的序列。

class Bio.SeqRecord.SeqRecord(seq, id='<unknown id>', name='<unknown name>', description='<unknown description>', dbxrefs=None, features=None, annotations=None, letter_annotations=None)

基类：object

SeqRecord对象保存序列及其相关信息。

主要属性：

• ID-标识符，如位置标签(字符串)

• SEQ-序列本身(序列对象或类似对象)

其他属性：

• 名称-序列名称，例如基因名称(字符串)

• 说明-附加文本(字符串)

• dbxrefs-数据库交叉引用列表(字符串列表)

• 特征-定义的任何(子)特征(序列特征对象列表)

• 注释-有关整个序列(字典)的更多信息。大多数条目是字符串或字符串列表。

• Letter_Annotation-每个字母/符号注释(受限词典)。它保存长度与序列长度匹配的Python序列(列表、字符串或元组)。典型的用法是保存代表测序质量分数的整数列表，或代表二级结构的字符串。

通常使用Bio.SeqIO将文件中的序列作为SeqRecord对象读入。但是，您可能希望直接创建自己的SeqRecord对象(请参阅 __init__ 方法以了解更多详细信息)：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein")
>>> print(record)
ID: YP_025292.1
Name: HokC
Description: toxic membrane protein
Number of features: 0
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')

如果要将SeqRecord对象保存到序列文件，请使用Bio.SeqIO。对于希望将SeqRecord转换为特定文件格式的字符串的特殊情况，有一个在内部使用Bio.SeqIO的Format方法：

>>> print(record.format("fasta"))
>YP_025292.1 toxic membrane protein
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

您还可以执行切片SeqRecord、检查其长度等操作

>>> len(record)
44
>>> edited = record[:10] + record[11:]
>>> print(edited.seq)
MKQHKAMIVAIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
>>> print(record.seq)
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

__init__(seq, id='<unknown id>', name='<unknown name>', description='<unknown description>', dbxrefs=None, features=None, annotations=None, letter_annotations=None)

创建一个SeqRecord。

参数：

• SEQ-SEQUENCE，必需(SEQ或MutableSeq)

• ID-序列标识符，推荐(字符串)

• 名称-序列名称，可选(字符串)

• Description-序列描述，可选(字符串)

• dbxrefs-数据库交叉引用，可选(字符串列表)

• 特征-任何(子)特征，可选(序列特征对象列表)

• 注释-整个序列的注释字典

• Letter_Annotation-每个字母注释的字典-值应该是与完整序列长度相同的字符串、列表或元组。

通常使用Bio.SeqIO将文件中的序列作为SeqRecord对象读入。但是，您可能希望直接创建自己的SeqRecord对象。

请注意，虽然id是可选的，但我们强烈建议您为每条记录提供唯一的id字符串。如果您希望将序列写入文件，这一点尤其重要。

您可以创建一个“空的”SeqRecord对象，然后稍后填充属性。

property letter_annotations

序列的每个字母注释的字典。

例如，它可以保存FASTQ或QUAL文件中使用的质量分数。考虑以下示例，使用Bio.SeqIO将示例Solexa变体FASTQ文件作为SeqRecord读入：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']
>>> print(record.letter_annotations["solexa_quality"])
[40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5]

如果对父SeqRecord进行切片，则会自动对Letter_Annotation进行切片，例如，取最后十个基数：

>>> sub_record = record[-10:]
>>> print("%s %s" % (sub_record.id, sub_record.seq))
slxa_0001_1_0001_01 ACGTNNNNNN
>>> print(sub_record.letter_annotations["solexa_quality"])
[4, 3, 2, 1, 0, -1, -2, -3, -4, -5]

只要长度与SeqRecord序列的长度匹配，任何Python序列(即列表、元组或字符串)都可以记录在SeqRecord的Letter_Annotation字典中。例如：

>>> len(sub_record.letter_annotations)
1
>>> sub_record.letter_annotations["dummy"] = "abcdefghij"
>>> len(sub_record.letter_annotations)
2

您可以照常从Letter_Annotation字典中删除条目：

>>> del sub_record.letter_annotations["solexa_quality"]
>>> sub_record.letter_annotations
{'dummy': 'abcdefghij'}

您可以轻松地完全清除字典，如下所示：

>>> sub_record.letter_annotations = {}
>>> sub_record.letter_annotations
{}

请注意，如果用不同长度的序列替换记录的序列，则必须首先清除Letter_Annotation字典。

property seq

序列本身，作为Seq或MutableSeq对象。

__getitem__(index)

返回子序列或单个字母。

切片，例如MY_RECORD [5:10] 返回该子序列的新SeqRecord，其中保留了一些注释，如下所示：

• 名称、ID和描述保持原样。

• 任何每个字母的注释都会被切片，以匹配请求的子序列。

• 除非使用跨距，否则将包括完全落入子序列内的所有特征(并相应调整它们的位置)。如果您想保留任何截断的特征(例如，GenBank/EMBL源特征)，您必须自己显式地将它们添加到新的SeqRecord中。

• 除了任何分子类型之外，注释字典和dbxrefs列表不用于新的SeqRecord，因为通常它们可能不适用于子序列。如果要保留它们，必须自己显式地将它们复制到新的SeqRecord。

使用整数索引，例如MY_RECORD [5] 是从序列my_record.seq中提取字母快捷方式 [5] 。

例如，考虑此短蛋白及其由PDB编码的二级结构(例如，H代表α螺旋)，加上其组氨酸自身磷酸化位点的一个简单特征：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.SeqFeature import SeqFeature, FeatureLocation
>>> rec = SeqRecord(Seq("MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLAT"
...                     "EMMSEQDGYLAESINKDIEECNAIIEQFIDYLR"),
...                 id="1JOY", name="EnvZ",
...                 description="Homodimeric domain of EnvZ from E. coli")
>>> rec.letter_annotations["secondary_structure"] = "  S  SSSSSSHHHHHTTTHHHHHHHHHHHHHHHHHHHHHHTHHHHHHHHHHHHHHHHHHHHHTT  "
>>> rec.features.append(SeqFeature(FeatureLocation(20, 21),
...                     type = "Site"))

现在让我们快速浏览一下完整的记录，

>>> print(rec)
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 1
Per letter annotation for: secondary_structure
Seq('MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLATEMMSEQDGYLAESINKDIEE...YLR')
>>> rec.letter_annotations["secondary_structure"]
'  S  SSSSSSHHHHHTTTHHHHHHHHHHHHHHHHHHHHHHTHHHHHHHHHHHHHHHHHHHHHTT  '
>>> print(rec.features[0].location)
[20:21]

现在让我们取一个子序列，这里选择的是第一个(断裂的)α螺旋，它包括组氨酸磷酸化位点：

>>> sub = rec[11:41]
>>> print(sub)
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 1
Per letter annotation for: secondary_structure
Seq('RTLLMAGVSHDLRTPLTRIRLATEMMSEQD')
>>> sub.letter_annotations["secondary_structure"]
'HHHHHTTTHHHHHHHHHHHHHHHHHHHHHH'
>>> print(sub.features[0].location)
[9:10]

当然，您也可以省略起始值或结束值，例如，只获取前十个字母：

>>> print(rec[:10])
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 0
Per letter annotation for: secondary_structure
Seq('MAAGVKQLAD')

或最后十个字母：

>>> print(rec[-10:])
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 0
Per letter annotation for: secondary_structure
Seq('IIEQFIDYLR')

如果两者都省略，则会得到原始记录的副本(尽管缺少注释和dbxrefs)：

>>> print(rec[:])
ID: 1JOY
Name: EnvZ
Description: Homodimeric domain of EnvZ from E. coli
Number of features: 1
Per letter annotation for: secondary_structure
Seq('MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLATEMMSEQDGYLAESINKDIEE...YLR')

最后，使用简单整数进行索引是直接从序列中提取字母的快捷方式：

>>> rec[5]
'K'
>>> rec.seq[5]
'K'

__iter__()

迭代序列中的字母。

例如，使用Bio.SeqIO读取蛋白质FASTA文件：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/loveliesbleeding.pro", "fasta")
>>> for amino in record:
...     print(amino)
...     if amino == "L": break
X
A
G
L
>>> print(record.seq[3])
L

这只是直接迭代序列的快捷方式：

>>> for amino in record.seq:
...     print(amino)
...     if amino == "L": break
X
A
G
L
>>> print(record.seq[3])
L

请注意，这不利于与任何每个字母的注释一起迭代。但是，您可以使用记录(或其序列)上的python zip函数和相关的每字母注释来实现这一点：

>>> from Bio import SeqIO
>>> rec = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (rec.id, rec.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(rec.letter_annotations))
['solexa_quality']
>>> for nuc, qual in zip(rec, rec.letter_annotations["solexa_quality"]):
...     if qual > 35:
...         print("%s %i" % (nuc, qual))
A 40
C 39
G 38
T 37
A 36

您可能同意使用zip(rec.seq，.)比使用zip(rec，.)更明确如上所示。

__contains__(char)

实现“in”关键字，搜索序列。

例如：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
>>> "GAATTC" in record
False
>>> "AAA" in record
True

这实际上充当在序列上使用“in”的代理：

>>> "GAATTC" in record.seq
False
>>> "AAA" in record.seq
True

请注意，您还可以使用Seq对象作为查询，

>>> from Bio.Seq import Seq
>>> Seq("AAA") in record
True

另请参见Seq对象的 __contains__ 方法。

__str__()

返回记录及其注释的人类可读摘要(字符串)。

内置函数字符串的python通过调用对象的 ___str__ 方法。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein, small")
>>> print(str(record))
ID: YP_025292.1
Name: HokC
Description: toxic membrane protein, small
Number of features: 0
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')

在本例中，您实际上不需要调用stexplicity，因为print命令会自动执行此操作：

>>> print(record)
ID: YP_025292.1
Name: HokC
Description: toxic membrane protein, small
Number of features: 0
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')

请注意，长序列显示为截断。

__repr__()

返回用于调试的记录的简明摘要(字符串)。

内置函数repr的python通过调用对象的 ___repr__ 方法。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> rec = SeqRecord(Seq("MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKAT"
...                     "GEMKEQTEWHRVVLFGKLAEVASEYLRKGSQVYIEGQLRTRKWTDQ"
...                     "SGQDRYTTEVVVNVGGTMQMLGGRQGGGAPAGGNIGGGQPQGGWGQ"
...                     "PQQPQGGNQFSGGAQSRPQQSAPAAPSNEPPMDFDDDIPF"),
...                 id="NP_418483.1", name="b4059",
...                 description="ssDNA-binding protein",
...                 dbxrefs=["ASAP:13298", "GI:16131885", "GeneID:948570"])
>>> print(repr(rec))
SeqRecord(seq=Seq('MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKATGEMKEQTE...IPF'), id='NP_418483.1', name='b4059', description='ssDNA-binding protein', dbxrefs=['ASAP:13298', 'GI:16131885', 'GeneID:948570'])

在python提示符下，您还可以使用以下速记：

>>> rec
SeqRecord(seq=Seq('MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKATGEMKEQTE...IPF'), id='NP_418483.1', name='b4059', description='ssDNA-binding protein', dbxrefs=['ASAP:13298', 'GI:16131885', 'GeneID:948570'])

请注意，长序列显示为截断。还要注意，没有显示任何注释、Letter_Annotation和特性(因为它们会导致非常长的字符串)。

format(format)

以指定文件格式的字符串形式返回记录。

格式应为Bio.SeqIO支持的作为输出格式的小写字符串，用于将SeqRecord转换为字符串。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein")
>>> record.format("fasta")
'>YP_025292.1 toxic membrane protein\nMKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF\n'
>>> print(record.format("fasta"))
>YP_025292.1 toxic membrane protein
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

Python打印函数自动追加一行，这意味着在本例中会显示一个空行。如果查看字符串表示，可以看到后面有一个换行符(显示为劈开n)，这在写入文件或将多个序列字符串连接在一起时很重要。

请注意，此方法不适用于Bio.SeqIO支持的所有可能的文件格式(例如，有些仅适用于多个序列，不支持二进制格式)。

__format__(format_spec)

以指定文件格式的字符串形式返回记录。

此方法支持Python format()函数和f字符串。format_spec应该是Bio.SeqIO支持的小写字符串作为文本输出文件格式。请求二进制文件格式会引发ValueError。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
...                    id="YP_025292.1", name="HokC",
...                    description="toxic membrane protein")
...
>>> format(record, "fasta")
'>YP_025292.1 toxic membrane protein\nMKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF\n'
>>> print(f"Here is {record.id} in FASTA format:\n{record:fasta}")
Here is YP_025292.1 in FASTA format:
>YP_025292.1 toxic membrane protein
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

另请参阅SeqRecord的format()方法。

__len__()

返回序列的长度。

例如，使用Bio.SeqIO读入FASTA核苷酸文件：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
>>> len(record)
309
>>> len(record.seq)
309

__lt__(other)

定义小于操作数(未实现)。

__le___(other)

定义小于或等于操作数(未实现)。

__eq__(other)

定义等于操作数(未实现)。

__ne__(other)

定义不等于操作数(未实现)。

__gt__(other)

定义大于操作数(未实现)。

__ge__(other)

定义大于或等于操作数(未实现)。

__bool__()

此类实例的布尔值(True)。

此行为是为了向后兼容，因为在 __len__ 方法时，SeqRecord的计算结果始终为True。

请注意，相比之下，如果序列长度为零，则Seq对象的计算结果将为false。

警告：当SeqRecord的序列长度为零时(为了更好地匹配Seq对象行为)，将来SeqRecord的计算结果可能为FALSE！

__add__(other)

向此序列添加另一个序列或字符串。

另一个序列可以是SeqRecord对象、Seq对象(或类似的，例如MutableSeq)或纯Python字符串。如果添加一个普通字符串或Seq(LIKE)对象，新的SeqRecord将简单地将其附加到现有数据。但是，每个字母的任何批注都将丢失：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']

>>> new = record + "ACT"
>>> print("%s %s" % (new.id, new.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNNACT
>>> print(list(new.letter_annotations))
[]

新记录将尝试合并注释，但是对于任何歧义(例如，不同的名称)，它默认省略该注释。

>>> from Bio import SeqIO
>>> with open("GenBank/pBAD30.gb") as handle:
...     plasmid = SeqIO.read(handle, "gb")
>>> print("%s %i" % (plasmid.id, len(plasmid)))
pBAD30 4923

现在，让我们将质粒分成两部分，然后以相反的方式将它们连接起来(即，移动该质粒上的起点，查看原始文件中带注释的特征，以了解为什么这个特定的分割点可能有意义)：

>>> left = plasmid[:3765]
>>> right = plasmid[3765:]
>>> new = right + left
>>> print("%s %i" % (new.id, len(new)))
pBAD30 4923
>>> str(new.seq) == str(right.seq + left.seq)
True
>>> len(new.features) == len(left.features) + len(right.features)
True

当我们添加左SeqRecord对象和右SeqRecord对象时，它们的注释都是一致的，因此都保留在新的SeqRecord中：

>>> new.id == left.id == right.id == plasmid.id
True
>>> new.name == left.name == right.name == plasmid.name
True
>>> new.description == plasmid.description
True
>>> new.annotations == left.annotations == right.annotations
True
>>> new.letter_annotations == plasmid.letter_annotations
True
>>> new.dbxrefs == left.dbxrefs == right.dbxrefs
True

但是，我们应该指出，当我们对SeqRecord进行切片时，任何注释字典或dbxrefs列表条目都会丢失。您可以像这样显式复制它们：

>>> new.annotations = plasmid.annotations.copy()
>>> new.dbxrefs = plasmid.dbxrefs[:]

__radd__(other)

将另一个序列或字符串添加到此序列(从左侧开始)。

此方法处理将Seq对象(或类似对象，例如MutableSeq)或纯Python字符串(左侧)添加到SeqRecord(右侧)。请参阅 __add__ 方法获取更多详细信息，但例如：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']

>>> new = "ACT" + record
>>> print("%s %s" % (new.id, new.seq))
slxa_0001_1_0001_01 ACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(new.letter_annotations))
[]

upper()

返回具有大写顺序的记录副本。

所有注释都保持不变。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> record = SeqRecord(Seq("acgtACGT"), id="Test",
...                    description = "Made up for this example")
>>> record.letter_annotations["phred_quality"] = [1, 2, 3, 4, 5, 6, 7, 8]
>>> print(record.upper().format("fastq"))
@Test Made up for this example
ACGTACGT
+
"#$%&'()

当然，有一个与之相匹配的较低的方法：

>>> print(record.lower().format("fastq"))
@Test Made up for this example
acgtacgt
+
"#$%&'()

lower()

返回具有小写序列的记录副本。

所有注释都保持不变。例如：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Fasta/aster.pro", "fasta")
>>> print(record.format("fasta"))
>gi|3298468|dbj|BAA31520.1| SAMIPF
GGHVNPAVTFGAFVGGNITLLRGIVYIIAQLLGSTVACLLLKFVTNDMAVGVFSLSAGVG
VTNALVFEIVMTFGLVYTVYATAIDPKKGSLGTIAPIAIGFIVGANI

>>> print(record.lower().format("fasta"))
>gi|3298468|dbj|BAA31520.1| SAMIPF
gghvnpavtfgafvggnitllrgivyiiaqllgstvaclllkfvtndmavgvfslsagvg
vtnalvfeivmtfglvytvyataidpkkgslgtiapiaigfivgani

举一个注释更丰富的例子，

>>> from Bio import SeqIO
>>> old = SeqIO.read("EMBL/TRBG361.embl", "embl")
>>> len(old.features)
3
>>> new = old.lower()
>>> len(old.features) == len(new.features)
True
>>> old.annotations["organism"] == new.annotations["organism"]
True
>>> old.dbxrefs == new.dbxrefs
True

reverse_complement(id=False, name=False, description=False, features=True, annotations=False, letter_annotations=True, dbxrefs=False)

使用反向补码序列返回新的SeqRecord。

默认情况下，新记录不保留序列标识符、名称、描述、常规注释或数据库交叉引用-这些不太可能应用于相反的序列。

您可以将返回记录的id、name和description指定为字符串，或者指定True以保留父记录的ID，或者指定False作为默认值。

您可以使用SeqFeature对象列表指定返回记录的特征，或指定True以保留父记录的特征，或指定False以忽略它们。默认情况下，保留原始特征(调整了链和位置)。

您还可以将返回记录的注释和Letter_Annotation指定为字典，如果指定为True，则保留父记录的注释；如果指定False，则忽略它们。默认情况下，保留原始注释(反转字母注释)。

要显示字母前面的注释发生了什么，请考虑一个示例Solexa变体FASTQ文件，它只有一个条目，我们将把它读入为SeqRecord：

>>> from Bio import SeqIO
>>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
>>> print("%s %s" % (record.id, record.seq))
slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
>>> print(list(record.letter_annotations))
['solexa_quality']
>>> print(record.letter_annotations["solexa_quality"])
[40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5]

现在以相反的补码为例，这里我们显式地给出了一个新标识符(带后缀的旧标识符)：

>>> rc_record = record.reverse_complement(id=record.id + "_rc")
>>> print("%s %s" % (rc_record.id, rc_record.seq))
slxa_0001_1_0001_01_rc NNNNNNACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT

请注意，每个字母的注释也被颠倒了，尽管这可能并不适用于所有情况。

>>> print(rc_record.letter_annotations["solexa_quality"])
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]

现在，对于这些功能，我们需要一个不同的示例。解析GenBank文件可能是获得包含特性的优秀示例的最简单方法……

>>> from Bio import SeqIO
>>> with open("GenBank/pBAD30.gb") as handle:
...     plasmid = SeqIO.read(handle, "gb")
>>> print("%s %i" % (plasmid.id, len(plasmid)))
pBAD30 4923
>>> plasmid.seq
Seq('GCTAGCGGAGTGTATACTGGCTTACTATGTTGGCACTGATGAGGGTGTCAGTGA...ATG')
>>> len(plasmid.features)
13

现在，让我们取整个质粒的反向互补：

>>> rc_plasmid = plasmid.reverse_complement(id=plasmid.id+"_rc")
>>> print("%s %i" % (rc_plasmid.id, len(rc_plasmid)))
pBAD30_rc 4923
>>> rc_plasmid.seq
Seq('CATGGGCAAATATTATACGCAAGGCGACAAGGTGCTGATGCCGCTGGCGATTCA...AGC')
>>> len(rc_plasmid.features)
13

让我们比较第一个CDS特征-它已经从第二个特征(索引1)变为倒数第二个特征(索引-2)，它的链发生了变化，位置也改变了。

>>> print(plasmid.features[1])
type: CDS
location: [1081:1960](-)
qualifiers:
    Key: label, Value: ['araC']
    Key: note, Value: ['araC regulator of the arabinose BAD promoter']
    Key: vntifkey, Value: ['4']

>>> print(rc_plasmid.features[-2])
type: CDS
location: [2963:3842](+)
qualifiers:
    Key: label, Value: ['araC']
    Key: note, Value: ['araC regulator of the arabinose BAD promoter']
    Key: vntifkey, Value: ['4']

您可以根据质粒的长度检查这个新位置：

>>> len(plasmid) - 1081
3842
>>> len(plasmid) - 1960
2963

注意，如果SeqFeature注释包括任何链特定信息(例如，SNP的碱基改变)，则该信息不会被修改，并且需要在反向互补之后进行校正。

注意：尝试反向补充蛋白质时，SeqRecord会引发异常：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> protein_rec = SeqRecord(Seq("MAIVMGR"), id="Test",
...                         annotations={"molecule_type": "protein"})
>>> protein_rec.reverse_complement()
Traceback (most recent call last):
   ...
ValueError: Proteins do not have complements!

如果您的RNA没有任何U碱基，则必须将其注释为RNA，否则默认情况下它将被视为DNA，并将A映射到T：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> rna1 = SeqRecord(Seq("ACG"), id="Test")
>>> rna2 = SeqRecord(Seq("ACG"), id="Test", annotations={"molecule_type": "RNA"})
>>> print(rna1.reverse_complement(id="RC", description="unk").format("fasta"))
>RC unk
CGT

>>> print(rna2.reverse_complement(id="RC", description="RNA").format("fasta"))
>RC RNA
CGU

另请注意，您可以使用MutableSeq反向补充SeqRecord：

>>> from Bio.Seq import MutableSeq
>>> from Bio.SeqRecord import SeqRecord
>>> rec = SeqRecord(MutableSeq("ACGT"), id="Test")
>>> rec.seq[0] = "T"
>>> print("%s %s" % (rec.id, rec.seq))
Test TCGT
>>> rc = rec.reverse_complement(id=True)
>>> print("%s %s" % (rc.id, rc.seq))
Test ACGA

__hash__ = None

translate(table='Standard', stop_symbol='*', to_stop=False, cds=False, gap=None, id=False, name=False, description=False, features=False, annotations=False, letter_annotations=False, dbxrefs=False)

使用翻译后的序列返回新的SeqRecord。

这将调用记录的.seq.late()方法(该方法描述与翻译相关的参数，如遗传密码表)，

默认情况下，新记录不保留序列标识符、名称、描述、一般注释或数据库交叉引用-这些不太可能应用于翻译后的序列。

您可以将返回记录的id、name和description指定为字符串，或者指定True以保留父记录的ID，或者指定False作为默认值。

您可以使用SeqFeature对象列表指定返回记录的特征，或指定False(默认值)以忽略它们。

您还可以将返回记录的注释和Letter_Annotation都指定为字典，如果指定为True，则保留父记录的注释(仅注释)；如果指定False(默认)，则忽略它们。

例如加载FASTA基因并翻译它，

>>> from Bio import SeqIO
>>> gene_record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
>>> print(gene_record.format("fasta"))
>gi|3176602|gb|U78617.1|LOU78617 Lathyrus odoratus phytochrome A (PHYA) gene, partial cds
CAGGCTGCGCGGTTTCTATTTATGAAGAACAAGGTCCGTATGATAGTTGATTGTCATGCA
AAACATGTGAAGGTTCTTCAAGACGAAAAACTCCCATTTGATTTGACTCTGTGCGGTTCG
ACCTTAAGAGCTCCACATAGTTGCCATTTGCAGTACATGGCTAACATGGATTCAATTGCT
TCATTGGTTATGGCAGTGGTCGTCAATGACAGCGATGAAGATGGAGATAGCCGTGACGCA
GTTCTACCACAAAAGAAAAAGAGACTTTGGGGTTTGGTAGTTTGTCATAACACTACTCCG
AGGTTTGTT

现在转换记录，指定新的ID和描述：

>>> protein_record = gene_record.translate(table=11,
...                                        id="phya",
...                                        description="translation")
>>> print(protein_record.format("fasta"))
>phya translation
QAARFLFMKNKVRMIVDCHAKHVKVLQDEKLPFDLTLCGSTLRAPHSCHLQYMANMDSIA
SLVMAVVVNDSDEDGDSRDAVLPQKKKRLWGLVVCHNTTPRFV