Bio.SeqRecord 模块

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

基类：object

SeqRecord 对象保存一个序列及其信息。

主要属性

id - 标识符，如基因座标签（字符串）
seq - 序列本身（Seq 对象或类似对象）

其他属性

name - 序列名称，例如基因名称（字符串）
description - 附加文本（字符串）
dbxrefs - 数据库交叉引用列表（字符串列表）
features - 任何（子）特征定义（SeqFeature 对象列表）
annotations - 整个序列的更多信息（字典）。大多数条目是字符串或字符串列表。
letter_annotations - 每个字母/符号注释（受限字典）。这保存了长度与序列匹配的 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 转换为特定文件格式的字符串的特殊情况，存在一个 format 方法，该方法在内部使用 Bio.SeqIO

>>> 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

创建 SeqRecord。

参数

seq - 序列，必需（Seq 或 MutableSeq）
id - 序列标识符，建议（字符串）
name - 序列名称，可选（字符串）
description - 序列描述，可选（字符串）
dbxrefs - 数据库交叉引用，可选（字符串列表）
features - 任何（子）特征，可选（SeqFeature 对象列表）
annotations - 整个序列的注释字典
letter_annotations - 每个字母注释的字典，值应该是字符串、列表或与完整序列长度相同的元组。

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

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

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

dbxrefs: list[str]

annotations: dict[str, str | int]

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_annotations 会自动切片

>>> 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]

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

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

您可以像往常一样从 letter_annotations 字典中删除条目。

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

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

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

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

property seq: 序列本身，作为 Seq 或 MutableSeq 对象。

__getitem__(index: int) → str

__getitem__(index: slice) → SeqRecord

返回子序列或单个字母。

切片，例如 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, SimpleLocation
>>> 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(SimpleLocation(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__() → Iterable[Seq | MutableSeq]

遍历序列中的字母。

例如，使用 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: str) → bool

实现“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__ 方法。

__bytes__() → bytes

__str__() → str

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

python 内置函数 str 通过调用对象的 __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')

在这个例子中，您实际上不需要显式地调用 str，因为 print 命令会自动执行此操作

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

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

__repr__() → str

返回用于调试的记录的简洁摘要（字符串）。

python 内置函数 repr 通过调用对象的 __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_annotations 和特征都不会显示（因为它们会导致非常长的字符串）。

format(format: str) → str

将记录作为指定文件格式的字符串返回。

格式应该是 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 print 函数会自动附加一个新行，这意味着在这个例子中会显示一个空行。如果您查看字符串表示，您会看到有一个尾随新行（显示为斜杠 n），这在写入文件或将多个序列字符串连接在一起时很重要。

请注意，此方法不适用于 Bio.SeqIO 支持的每种可能的格式（例如，有些格式仅用于多个序列，并且不支持二进制格式）。

__format__(format_spec: str) → str

将记录作为指定文件格式的字符串返回。

此方法支持 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__() → int

返回序列的长度。

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

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

__lt__(other: Any) → NoReturn: 定义小于运算符（未实现）。

__le__(other: Any) → NoReturn: 定义小于或等于运算符（未实现）。

__eq__(other: object) → NoReturn: 定义等于运算符（未实现）。

__ne__(other: object) → NoReturn: 定义不等于运算符（未实现）。

__gt__(other: Any) → NoReturn: 定义大于运算符（未实现）。

__ge__(other: Any) → NoReturn: 定义大于或等于运算符（未实现）。

__bool__() → bool

此类实例的布尔值（True）。

此行为是为了向后兼容，因为在添加 __len__ 方法之前，SeqRecord 始终评估为 True。

请注意，相比之下，Seq 对象如果具有零长度序列，则将评估为 False。

警告：SeqRecord 在未来可能在它的序列为零长度时评估为 False（为了更好地匹配 Seq 对象的行为）！

__add__(other: SeqRecord | Seq | MutableSeq | str) → SeqRecord

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

另一个序列可以是 SeqRecord 对象、Seq 对象（或类似对象，例如 MutableSeq）或普通 Python 字符串。如果您添加普通字符串或 Seq（类似）对象，新的 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 中

>>> 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 | str) → SeqRecord

将另一个序列或字符串添加到此序列（从左侧）。

此方法处理将 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))
[]

count(sub, start=None, end=None)

返回 seq[start:end] 中 sub 的非重叠出现的次数。

可选参数 start 和 end 的解释与切片表示法中的解释相同。此方法的行为与 Python 字符串的 count 方法相同。

upper() → SeqRecord

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

所有注释都保持不变，例如

>>> 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
+
"#$%&'()

自然，有一个匹配的 lower 方法

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

__annotations__ = {'_per_letter_annotations': '_RestrictedDict', 'annotations': dict[str, typing.Union[str, int]], 'dbxrefs': list[str]}

__hash__ = None

lower() → SeqRecord

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

所有注释都保持不变，例如

>>> 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

isupper()

如果记录的序列中的所有 ASCII 字符都是大写，则返回 True。

如果没有大小写字符，则该方法返回 False。

islower()

如果记录的序列中的所有 ASCII 字符都是小写，则返回 True。

如果没有大小写字符，则该方法返回 False。

reverse_complement(id: bool = False, name: bool = False, description: bool = False, features: bool = True, annotations: bool = False, letter_annotations: bool = True, dbxrefs: bool = False) → SeqRecord

返回具有反向互补序列的新 SeqRecord。

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

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

您可以将返回的记录的 features 指定为 SeqFeature 对象列表，或指定 True 以保留父记录的 features，或指定 False 以省略它们。默认情况下是保留原始特征（调整了链和位置）。

您还可以将返回的记录的 annotations 和 letter_annotations 都指定为字典，指定 True 以保留父记录的 annotations 和 letter_annotations，或指定 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

translate(table: str = 'Standard', stop_symbol: str = '*', to_stop: bool = False, cds: bool = False, gap: str | None = None, id: bool = False, name: bool = False, description: bool = False, features: bool = False, annotations: bool = False, letter_annotations: bool = False, dbxrefs: bool = False) → SeqRecord

返回带有翻译序列的新的 SeqRecord。

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

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

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

可以使用 SeqFeature 对象列表指定返回记录的特征，或使用 False（默认值）将其省略。

还可以指定返回记录的注释和 letter_annotations 作为字典，使用 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