Bio.SeqRecord模块

代表序列记录，一个带注释的序列。

class Bio.SeqRecord.SeqRecord(seq: Seq | MutableSeq | None, id: str | None = '<unknown id>', name: str = '<unknown name>', description: str = '<unknown description>', dbxrefs: list[str] | None = None, features: list[SeqFeature] | None = None, annotations: dict[str, str | int] | None = None, letter_annotations: dict[str, Sequence[Any]] | None = None)

基类：object

SeqRecord对象保存序列和有关该序列的信息。

主要属性：

• ID - 标识符，例如位置标签（字符串）

• seq - 序列本身（Seq对象或类似对象）

其他属性：

• 名称 - 序列名称，例如基因名称（字符串）

• 描述-附加文本（字符串）

• dbxref - 数据库交叉引用列表（字符串列表）

• 特征 - 定义的任何（子）要素（SeqElement对象列表）

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

• 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转换为特定文件格式的字符串的特殊情况，有一种格式方法在内部使用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

__init__(seq: Seq | MutableSeq | None, id: str | None = '<unknown id>', name: str = '<unknown name>', description: str = '<unknown description>', dbxrefs: list[str] | None = None, features: list[SeqFeature] | None = None, annotations: dict[str, str | int] | None = None, letter_annotations: dict[str, Sequence[Any]] | None = None) → None

创建SeqRecord。

论点：

• seq - 序列，必需（Seq或MutableSeq）

• ID - 序列标识符，建议（字符串）

• 名称 - 序列名，可选（字符串）

• 描述-序列描述，可选（字符串）

• dbxref - 数据库交叉引用，可选（字符串列表）

• 特征 - 任何（子）功能，可选（SeqElement对象列表）

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

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

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

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

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

dbxrefs: list[str]

annotations: dict[str, str | int]

property letter_annotations: dict[str, Sequence[Any]]

序列的每字母注释词典。

例如，这可以保存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 dict。

property seq: Seq | MutableSeq | None

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

__getitem__(index: int) → str

__getitem__(index: slice) → SeqRecord

返回子序列或单个字母。

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

• 名称、id和描述按原样保留。

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

• 除非使用跨度，否则所有完全属于子序列的特征都会被包含（其位置相应调整）。如果您想保留任何被截断的特征（例如，SEN/MBE源特征），则必须亲自将它们显式添加到新的SeqRecord中。

• 除任何分子类型外，注释字典和dbxref列表不用于新SeqRecord，因为一般来说它们可能不适用于子序列。如果您想保留它们，则必须亲自显式地将它们复制到新的SeqRecord。

使用整个索引，例如my_record [5] 是从序列my_record.seq中提取该字母的缩写 [5] .

例如，考虑这个短蛋白质及其由DBC编码的二级结构（例如，阿尔法螺旋的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')

如果您忽略这两者，那么您将获得原始记录的副本（尽管缺乏注释和dbxref）：

>>> 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__() → Iterator[str]

迭代序列中的字母。

例如，使用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

请注意，这不会促进与任何按字母注释一起进行迭代。 然而，您可以使用对记录（或其序列）和相关的按字母注释的pony 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

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

函数url中内置的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')

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

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

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

__repr__() → str

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

函数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_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打印函数自动添加新行，这意味着在本例中显示一行白线。 如果您查看字符串表示，您可以看到后面有一个新行（显示为斜线n），这在写入文件或将多个序列字符串连接在一起时非常重要。

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

__format__(format_spec: str) → str

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

该方法支持Python格式（）函数和f字符串。form_spec应该是Bio.SeqIO支持的大小写字符串，作为文本输出文件格式。请求二进制文件格式会引发Value错误。例如

>>> 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的form（）方法。

__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（类似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进行切片时，任何注释字典或dbxref列表条目都丢失了。您可以这样显式复制它们：

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

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

__firstlineno__ = 117

__hash__ = None

__static_attributes__ = ('_per_letter_annotations', '_seq', 'annotations', 'dbxrefs', 'description', 'features', 'id', 'letter_annotations', 'name')

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

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

可选参数开始和结束被解释为切片符号。该方法的行为类似于Python字符串的计数方法。

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

当然，还有一个匹配的下级方法：

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

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

如果记录序列中的所有ASC字符均为大写字母，则返回True。

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

islower()

如果记录序列中的所有ASC字符均为大写字母，则返回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、名称和描述指定为字符串，或者指定True以保留父记录的id、名称和描述，或者指定False作为默认值。

您可以使用SeqPerformance对象列表指定返回记录的功能，或者使用True以保留父项的功能，或者使用False以省略它们。默认情况是保留原始特征（调整线和位置）。

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

现在对于功能，我们需要一个不同的示例。解析基因库文件可能是获得包含功能的好示例的最简单方法.

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

请注意，如果SeqPerformance注释包括任何链特定信息（例如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、名称和描述指定为字符串，或者指定True以保留父记录的id、名称和描述，或者指定False作为默认值。

您可以使用SeqPerformance对象列表指定返回记录的功能，或者使用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