Bio.Seq模块

提供代表生物序列的对象。

另见 Seq 维基和我们教程中的章节：

• HTML Tutorial _

• PDF Tutorial _

class Bio.Seq.SequenceDataAbstractBaseClass

基类：ABC

序列内容提供程序的抽象Base Class。

大多数用户不需要使用此类。它在内部用作序列内容提供程序类的基本类，例如本模块中定义的_UndefinedSequenceData和Bio.SeqIO.TwoBitIO中的_TwoBitSequenceData。可以使用这些类的收件箱来代替 bytes 创建Seq对象时将对象作为数据参数，并仅在通过请求时提供序列内容 __getitem__ .这允许懒惰解析器仅从文件中加载和解析所请求的序列区域的序列数据，并且_UndefinedSequenceData实例在请求未定义的序列数据时引发异常。

类似地提供按需序列数据解析的延迟解析器的未来实现应该使用这个抽象类的子类并实现抽象方法 __len__ 和 __getitem__ :

• __len__ 必须返回序列长度;

• __getitem__ 必须返回

  • 一 bytes 请求区域的对象;或

  • 请求区域的子类别的新实例;或

  • 引发 UndefinedSequenceError .

  调用 __getitem__ 对于大小为零的序列区域应始终返回空 bytes object.调用 __getitem__ 对于完整序列（如数据中 [:] ）应该要么返回 bytes 具有完整序列的对象，或者引发 UndefinedSequenceError .

SequenceDataAbstractBaseClass的子类必须调用 super().__init__() 在其 __init__ 法

__slots__ = ()

__init__()

检查是否 __getitem__ 返回类似字节的对象。

abstractmethod __len__()

abstractmethod __getitem__(key)

__bytes__()

__hash__()

返回哈希（self）。

__eq__(other)

返回自我==价值。

__lt__(other)

返回自我<值。

__le__(other)

返回自我<=值。

__gt__(other)

返回自我>价值。

__ge__(other)

返回自我>=价值。

__add__(other)

__radd__(other)

__mul__(other)

__contains__(item)

decode(encoding='utf-8')

使用注册进行编码的编解码器将数据解码为字节。

编码

解码字节的编码。

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

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

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

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

返回数据中找到子小节的最低索引。

返回数据中找到子小节的最低索引，以便子小节包含在数据中 [start,end] . 可选参数开始和结束被解释为切片符号。

失败时返回-1。

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

返回找到子小节的数据中的最高索引。

返回数据中找到子小节的最高索引，以便子包含在数据中 [start,end] . 可选参数开始和结束被解释为切片符号。

失败时返回-1。

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

返回数据中找到子小节的最低索引。

返回数据中找到子小节的最低索引，以便子小节包含在数据中 [start,end] . 可选参数开始和结束被解释为切片符号。

当找不到小节时，引发Value错误。

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

返回找到子小节的数据中的最高索引。

返回数据中找到子小节的最高索引，以便子包含在数据中 [start,end] . 可选参数开始和结束被解释为切片符号。

找不到子节时引发ValueError。

startswith(prefix, start=None, end=None)

如果数据以指定的开头，则返回True，否则返回False。

使用可选开始，测试数据从该位置开始。使用可选结束，停止在该位置比较数据。prefix也可以是要尝试的字节元组。

endswith(suffix, start=None, end=None)

如果数据以指定的后缀结尾，则返回True，否则返回False。

使用可选开始，测试数据从该位置开始。使用可选结束，停止在该位置比较数据。后缀也可以是要尝试的字节元组。

split(sep=None, maxsplit=-1)

返回数据中的部分列表，使用sep作为参数。

Sep

拆分数据所依据的收件箱。无（默认值）意味着分裂为ASCI空白字符（空白、制表符、返回、白线、formfeed、垂直制表符）。

maxsplit

要执行的最大拆分次数。-1（默认值）表示无限制。

rsplit(sep=None, maxsplit=-1)

返回数据中的部分列表，使用sep作为参数。

Sep

拆分数据所依据的收件箱。无（默认值）意味着分裂为ASCI空白字符（空白、制表符、返回、白线、formfeed、垂直制表符）。

maxsplit

要执行的最大拆分次数。-1（默认值）表示无限制。

拆分从数据的末尾开始，一直到前面。

strip(chars=None)

删除参数中包含的前置字符和后置字符。

如果参数被省略或无，则删除开头和结尾的ASC空白。

lstrip(chars=None)

去掉论点中包含的主角。

如果参数被省略或无，则删除开头的ASC空白。

rstrip(chars=None)

删除参数中包含的尾随字符。

如果参数被省略或无，则删除尾随的ASC空白。

removeprefix(prefix)

如果存在，请删除该后缀。

removesuffix(suffix)

删除后缀（如果存在）。

upper()

返回所有ASC字符均已转换为大写字母的数据副本。

lower()

返回所有ASC字符均已转换为大写字母的数据副本。

isupper()

如果数据中的所有ASC字符均为大写字母，则返回True。

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

islower()

如果数据中的所有ASC字符均为大写字母，则返回True。

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

replace(old, new)

返回一个副本，所有出现的子字符串old都被new替换。

translate(table, delete=b'')

返回一个副本，其中每个字符都由给定的翻译表映射。

表

翻译表，必须是长度为256的字节对象。

删除可选参数select中出现的所有字符。其余字符通过给定的翻译表进行映射。

property defined

如果序列已定义，则返回True;如果未定义或部分定义，则返回False。

零长度序列总是被认为是已定义的。

property defined_ranges

返回定义序列内容的范围的多元组。

返回值的格式为（（start1，end1），（start2，end2），.）。

__abstractmethods__ = frozenset({'__getitem__', '__len__'})

__annotations__ = {}

__firstlineno__ = 66

__static_attributes__ = ()

class Bio.Seq.Seq(data: str | bytes | bytearray | _SeqAbstractBaseClass | SequenceDataAbstractBaseClass | dict | None, length: int | None = None)

基类：_SeqAbstractBaseClass

只读序列对象（本质上是一个带有生物学方法的字符串）。

就像普通的Python字符串一样，我们的基本序列对象是不可变的。这会阻止您执行my_seq [5] =“A”例如，但确实允许Seq对象用作字典键。

Seq对象提供了许多类似字符串的方法（例如计数、查找、拆分和剥离）。

Seq对象还提供了一些生物学方法，例如互补、反向互补、转录、反向转录和翻译（不适用于蛋白质序列）。

__init__(data: str | bytes | bytearray | _SeqAbstractBaseClass | SequenceDataAbstractBaseClass | dict | None, length: int | None = None)

创建Seq对象。

论点：

• 数据-序列，必需（字符串）

• 长度-序列长度，仅在数据为“无”或字典（integer）时使用

您通常会使用Bio.SeqIO从文件中读取序列作为SeqRecord对象，其序列将通过seq属性公开为Seq对象。

但是，您也可以直接创建Seq对象：

>>> from Bio.Seq import Seq
>>> my_seq = Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF")
>>> my_seq
Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')
>>> print(my_seq)
MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF

要为长度已知但序列内容未知的序列创建Seq对象，请使用无作为数据参数，并为长度参数传递序列长度。尝试访问以这种方式创建的Seq对象的序列内容将引发UndefinedSequence错误：

>>> my_undefined_sequence = Seq(None, 20)
>>> my_undefined_sequence
Seq(None, length=20)
>>> len(my_undefined_sequence)
20
>>> print(my_undefined_sequence)
Traceback (most recent call last):
...
Bio.Seq.UndefinedSequenceError: Sequence content is undefined

如果仅知道序列部分的序列内容，请使用数据参数的字典来传递已知的序列段：

>>> my_partially_defined_sequence = Seq({3: "ACGT"}, 10)
>>> my_partially_defined_sequence
Seq({3: 'ACGT'}, length=10)
>>> len(my_partially_defined_sequence)
10
>>> print(my_partially_defined_sequence)
Traceback (most recent call last):
...
Bio.Seq.UndefinedSequenceError: Sequence content is only partially defined
>>> my_partially_defined_sequence[3:7]
Seq('ACGT')
>>> print(my_partially_defined_sequence[3:7])
ACGT

__hash__()

将序列哈希为字符串以进行比较。

请参阅Seq对象比较文档（方法 __eq__ 特别是），因为这在Biopython 1.65中发生了变化。旧版本会哈希对象身份。

__abstractmethods__ = frozenset({})

__annotations__ = {'_data': typing.Union[bytes, Bio.Seq.SequenceDataAbstractBaseClass]}

__firstlineno__ = 2026

__static_attributes__ = ('_data',)

class Bio.Seq.MutableSeq(data)

基类：_SeqAbstractBaseClass

一个可编辑的序列对象。

与普通的Python字符串和我们的基本序列对象（Seq类）不可变不同，MutableSeq允许您就地编辑序列。然而，这意味着您不能使用MutableSeq对象作为字典键。

>>> from Bio.Seq import MutableSeq
>>> my_seq = MutableSeq("ACTCGTCGTCG")
>>> my_seq
MutableSeq('ACTCGTCGTCG')
>>> my_seq[5]
'T'
>>> my_seq[5] = "A"
>>> my_seq
MutableSeq('ACTCGACGTCG')
>>> my_seq[5]
'A'
>>> my_seq[5:8] = "NNN"
>>> my_seq
MutableSeq('ACTCGNNNTCG')
>>> len(my_seq)
11

请注意，MutableSeq对象不支持像Seq对象那样多的类似字符串的方法或生物方法。

__init__(data)

创建MutableSeq对象。

__setitem__(index, value)

通过value参数设置单个字母的子序列。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> my_seq[0] = 'T'
>>> my_seq
MutableSeq('TCTCGACGTCG')

__delitem__(index)

删除单字母的子序列。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> del my_seq[0]
>>> my_seq
MutableSeq('CTCGACGTCG')

append(c)

将子序列添加到可变序列对象。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> my_seq.append('A')
>>> my_seq
MutableSeq('ACTCGACGTCGA')

没有返回值。

insert(i, c)

将子序列添加到给定索引处的可变序列对象。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> my_seq.insert(0,'A')
>>> my_seq
MutableSeq('AACTCGACGTCG')
>>> my_seq.insert(8,'G')
>>> my_seq
MutableSeq('AACTCGACGGTCG')

没有返回值。

pop(i=-1)

删除给定索引处单个字母的子序列。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> my_seq.pop()
'G'
>>> my_seq
MutableSeq('ACTCGACGTC')
>>> my_seq.pop()
'C'
>>> my_seq
MutableSeq('ACTCGACGT')

返回序列的最后一个字符。

remove(item)

从可变序列中删除单个字母的子序列。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> my_seq.remove('C')
>>> my_seq
MutableSeq('ATCGACGTCG')
>>> my_seq.remove('A')
>>> my_seq
MutableSeq('TCGACGTCG')

没有返回值。

reverse()

修改可变序列以逆转自身。

没有返回值。

extend(other)

将序列添加到原始可变序列对象。

>>> my_seq = MutableSeq('ACTCGACGTCG')
>>> my_seq.extend('A')
>>> my_seq
MutableSeq('ACTCGACGTCGA')
>>> my_seq.extend('TTT')
>>> my_seq
MutableSeq('ACTCGACGTCGATTT')

没有返回值。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 2176

__static_attributes__ = ('_data',)

exception Bio.Seq.UndefinedSequenceError

基类：ValueError

序列内容未定义。

__firstlineno__ = 2351

__static_attributes__ = ()

Bio.Seq.transcribe(dna)

将DNA序列转录为RNA。

按照通常的惯例，该序列被解释为DNA双螺旋的编码链，而不是模板链。这意味着我们只需通过将T切换为U即可获得RNA序列。

如果给定字符串，则返回新字符串对象。

给定Seq或MutableSeq，返回新的Seq对象。

例如

>>> transcribe("ACTGN")
'ACUGN'

Bio.Seq.back_transcribe(rna)

将RNA序列逆转录为DNA。

如果给定字符串，则返回新字符串对象。

给定Seq或MutableSeq，返回新的Seq对象。

例如

>>> back_transcribe("ACUGN")
'ACTGN'

Bio.Seq.translate(sequence, table='Standard', stop_symbol='*', to_stop=False, cds=False, gap=None)

把核苷酸序列翻译成氨基酸。

如果给定字符串，则返回新字符串对象。给定Seq或MutableSeq，返回Seq对象。

论点：

• 表-使用哪个密码子表？ 这可以是名称（字符串）、NCBI标识符（integer）或CodonTable对象（对非标准遗传密码有用）。 返回到“标准”表。

• stop_Symbol -单个字符串，用于任何终止符，默认为星号“*”。

• to_stop -布尔，默认为False，这意味着在任何停止密码子之后继续进行完整翻译（翻译为指定的stop_符号）。 如果为True，则翻译在框架内的第一个终止密码子处终止（并且stop_符号不会附加到返回的蛋白质序列上）。

• cds -布尔，表明这是完整的CDS。 如果为True，则会检查序列以有效的替代起始密码子（将被翻译为甲硫素M）开始，序列长度是三的倍数，并且末端是否有一个框内终止密码子（无论to_stop选项如何，这都将被排除在蛋白质序列之外）。如果这些测试失败，则会引发异常。

• gap -单个字符串，表示用于间隙的符号。切换到无。

使用默认（标准）遗传密码的简单字符串示例：

>>> coding_dna = "GTGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG"
>>> translate(coding_dna)
'VAIVMGR*KGAR*'
>>> translate(coding_dna, stop_symbol="@")
'VAIVMGR@KGAR@'
>>> translate(coding_dna, to_stop=True)
'VAIVMGR'

现在使用NCBI表2，其中TGA不是终止密码子：

>>> translate(coding_dna, table=2)
'VAIVMGRWKGAR*'
>>> translate(coding_dna, table=2, to_stop=True)
'VAIVMGRWKGAR'

事实上，这个例子使用了NCBI表2下有效的替代起始密码子GTG，这意味着这个例子是一个完全有效的CDS，当翻译时，它实际上应该以甲硫素（而不是Val）开始：

>>> translate(coding_dna, table=2, cds=True)
'MAIVMGRWKGAR'

请注意，如果序列没有框内终止密码子，那么to_stop参数就没有效果：

>>> coding_dna2 = "GTGGCCATTGTAATGGGCCGC"
>>> translate(coding_dna2)
'VAIVMGR'
>>> translate(coding_dna2, to_stop=True)
'VAIVMGR'

注意--诸如“TAN”或“NNN”等模糊密码子可以是氨基酸或终止密码子。 这些被翻译为“X”。 任何无效密码子（例如“TA？”或“T-A”）将引发TranslationHelp。

然而，它将翻译DNA或RNA。

注-自1.71版本以来，Biopython包含带有“模糊终止密码子”的密码子表。这些是具有明确序列的终止密码子，但具有上下文依赖性编码为STOP或氨基酸。对于这些表，“to_stop”必须为False（否则将引发ValueHelp）。双重编码密码子始终被翻译为氨基酸，除了“cds= True”，其中最后一个密码子将被翻译为STOP。

>>> coding_dna3 = "ATGGCACGGAAGTGA"
>>> translate(coding_dna3)
'MARK*'

>>> translate(coding_dna3, table=27)  # Table 27: TGA -> STOP or W
'MARKW'

但它会引发BiopythonWarning（未显示）。

>>> translate(coding_dna3, table=27, cds=True)
'MARK'

>>> translate(coding_dna3, table=27, to_stop=True)
Traceback (most recent call last):
   ...
ValueError: You cannot use 'to_stop=True' with this table ...

Bio.Seq.reverse_complement(sequence, inplace=False)

将反向互补序列作为DNA序列返回。

如果给定字符串，则返回新字符串对象。给定Seq对象，返回新的Seq对象。给定MutableSeq，返回新的MutableSeq对象。给定SeqRecord对象，返回新的SeqRecord对象。

>>> my_seq = "CGA"
>>> reverse_complement(my_seq)
'TCG'
>>> my_seq = Seq("CGA")
>>> reverse_complement(my_seq)
Seq('TCG')
>>> my_seq = MutableSeq("CGA")
>>> reverse_complement(my_seq)
MutableSeq('TCG')
>>> my_seq
MutableSeq('CGA')

序列中的任何U都被视为T：

>>> reverse_complement(Seq("CGAUT"))
Seq('AATCG')

相反， reverse_complement_rna 返回RNA序列：

>>> reverse_complement_rna(Seq("CGAUT"))
Seq('AAUCG')

支持和小写和大写字符，以及明确和不明确的核苷酸。不转换所有其他字符：

>>> reverse_complement("ACGTUacgtuXYZxyz")
'zrxZRXaacgtAACGT'

如果就地为True，则就地修改并返回序列：

>>> my_seq = MutableSeq("CGA")
>>> reverse_complement(my_seq, inplace=True)
MutableSeq('TCG')
>>> my_seq
MutableSeq('TCG')

作为琴弦和 Seq 对象是不可变的， TypeError 如果 reverse_complement 被称为 Seq 对象与 inplace=True .

Bio.Seq.reverse_complement_rna(sequence, inplace=False)

将反向互补序列作为RNA序列返回。

如果给定字符串，则返回新字符串对象。给定Seq对象，返回新的Seq对象。给定MutableSeq，返回新的MutableSeq对象。给定SeqRecord对象，返回新的SeqRecord对象。

>>> my_seq = "CGA"
>>> reverse_complement_rna(my_seq)
'UCG'
>>> my_seq = Seq("CGA")
>>> reverse_complement_rna(my_seq)
Seq('UCG')
>>> my_seq = MutableSeq("CGA")
>>> reverse_complement_rna(my_seq)
MutableSeq('UCG')
>>> my_seq
MutableSeq('CGA')

序列中的任何T都被视为U：

>>> reverse_complement_rna(Seq("CGAUT"))
Seq('AAUCG')

相反， reverse_complement 返回DNA序列：

>>> reverse_complement(Seq("CGAUT"), inplace=False)
Seq('AATCG')

支持和小写和大写字符，以及明确和不明确的核苷酸。不转换所有其他字符：

>>> reverse_complement_rna("ACGTUacgtuXYZxyz")
'zrxZRXaacguAACGU'

如果就地为True，则就地修改并返回序列：

>>> my_seq = MutableSeq("CGA")
>>> reverse_complement_rna(my_seq, inplace=True)
MutableSeq('UCG')
>>> my_seq
MutableSeq('UCG')

作为琴弦和 Seq 对象是不可变的， TypeError 如果 reverse_complement 被称为 Seq 对象与 inplace=True .

Bio.Seq.complement(sequence, inplace=False)

将互补序列作为DNA序列返回。

如果给定字符串，则返回新字符串对象。给定Seq对象，返回新的Seq对象。给定MutableSeq，返回新的MutableSeq对象。给定SeqRecord对象，返回新的SeqRecord对象。

>>> my_seq = "CGA"
>>> complement(my_seq)
'GCT'
>>> my_seq = Seq("CGA")
>>> complement(my_seq)
Seq('GCT')
>>> my_seq = MutableSeq("CGA")
>>> complement(my_seq)
MutableSeq('GCT')
>>> my_seq
MutableSeq('CGA')

序列中的任何U都被视为T：

>>> complement(Seq("CGAUT"))
Seq('GCTAA')

相反， complement_rna 返回RNA序列：

>>> complement_rna(Seq("CGAUT"))
Seq('GCUAA')

支持和小写和大写字符，以及明确和不明确的核苷酸。不转换所有其他字符：

>>> complement("ACGTUacgtuXYZxyz")
'TGCAAtgcaaXRZxrz'

如果就地为True，则就地修改并返回序列：

>>> my_seq = MutableSeq("CGA")
>>> complement(my_seq, inplace=True)
MutableSeq('GCT')
>>> my_seq
MutableSeq('GCT')

作为琴弦和 Seq 对象是不可变的， TypeError 如果 reverse_complement 被称为 Seq 对象与 inplace=True .

Bio.Seq.complement_rna(sequence, inplace=False)

将互补序列作为RNA序列返回。

如果给定字符串，则返回新字符串对象。给定Seq对象，返回新的Seq对象。给定MutableSeq，返回新的MutableSeq对象。给定SeqRecord对象，返回新的SeqRecord对象。

>>> my_seq = "CGA"
>>> complement_rna(my_seq)
'GCU'
>>> my_seq = Seq("CGA")
>>> complement_rna(my_seq)
Seq('GCU')
>>> my_seq = MutableSeq("CGA")
>>> complement_rna(my_seq)
MutableSeq('GCU')
>>> my_seq
MutableSeq('CGA')

序列中的任何T都被视为U：

>>> complement_rna(Seq("CGAUT"))
Seq('GCUAA')

相反， complement 返回DNA序列：

>>> complement(Seq("CGAUT"))
Seq('GCTAA')

支持和小写和大写字符，以及明确和不明确的核苷酸。不转换所有其他字符：

>>> complement_rna("ACGTUacgtuXYZxyz")
'UGCAAugcaaXRZxrz'

如果就地为True，则就地修改并返回序列：

>>> my_seq = MutableSeq("CGA")
>>> complement(my_seq, inplace=True)
MutableSeq('GCT')
>>> my_seq
MutableSeq('GCT')

作为琴弦和 Seq 对象是不可变的， TypeError 如果 reverse_complement 被称为 Seq 对象与 inplace=True .