Bio.Seq模块¶

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

另请参阅 Seq Wiki和我们教程中的章节：

class Bio.Seq.SequenceDataAbstractBaseClass¶

基类：ABC

序列内容提供程序的抽象基类。

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

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

__len__ 必须返回序列长度；
__getitem__ 一定要回来
- 一个 bytes 对象，用于请求的区域；或
- 请求区域的子类的新实例；或
- 举起一个 UndefinedSequenceError 。
呼叫 __getitem__ 对于大小为零的序列区域，应始终返回空值 bytes 对象。呼叫 __getitem__ 对于完整序列(如在数据中 [:] )应返回一个 bytes 对象，或引发 UndefinedSequenceError 。

SequenceDataAbstractBaseClass的子类必须调用 super().__init__() 作为他们计划的一部分 __init__ 方法。

__slots__ = ()¶

__init__()¶: 检查是否 __getitem__ 返回一个类似字节的对象。

abstract __len__()¶

abstract __getitem__(key)¶

__bytes__()¶

__hash__()¶: 返回hash(Self)。

__eq__(other)¶: 返回self==value。

__lt__(other)¶: 返回self<value。

__le__(other)¶: 返回self<=value。

__gt__(other)¶: 返回self>value。

__ge__(other)¶: 返回self>=value。

__add__(other)¶

__radd__(other)¶

__mul__(other)¶

__contains__(item)¶

decode(encoding='utf-8')¶

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

编码: 用于解码字节的编码。

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

返回数据中SUB的非重叠出现次数 [开始：结束] 。

可选参数start和end被解释为切片表示法。

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

返回数据中找到SUB的最低索引。

返回数据中找到SUB的最低索引，以便SUB包含在数据中 [开始、结束] 。可选参数start和end被解释为切片表示法。

失败时返回-1。

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

返回数据中找到SUB的最高索引。

返回数据中找到SUB的最高索引，以便SUB包含在数据中 [开始、结束] 。可选参数start和end被解释为切片表示法。

失败时返回-1。

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

返回数据中找到SUB的最低索引。

返回数据中找到SUB的最低索引，以便SUB包含在数据中 [开始、结束] 。可选参数start和end被解释为切片表示法。

找不到该子部分时引发ValueError。

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

返回数据中找到SUB的最高索引。

返回数据中找到SUB的最高索引，以便SUB包含在数据中 [开始、结束] 。可选参数start和end被解释为切片表示法。

找不到该子部分时引发ValueError。

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

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

在可选启动的情况下，测试数据从该位置开始。使用可选的End，停止在该位置比较数据。前缀也可以是要尝试的字节数组。

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

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

在可选启动的情况下，测试数据从该位置开始。使用可选的End，停止在该位置比较数据。后缀也可以是要尝试的字节数组。

split(sep=None, maxsplit=-1)¶

使用SEP作为分隔符，返回数据中的节列表。

9月: 拆分数据所依据的分隔符。无(默认值)表示拆分ASCII空格字符(空格、制表符、回车、换行符、换页符、垂直制表符)。
最大分割: 要执行的最大拆分次数。(默认值)表示没有限制。

rsplit(sep=None, maxsplit=-1)¶

使用SEP作为分隔符，返回数据中的节列表。

9月: 拆分数据所依据的分隔符。无(默认值)表示拆分ASCII空格字符(空格、制表符、回车、换行符、换页符、垂直制表符)。
最大分割: 要执行的最大拆分次数。(默认值)表示没有限制。

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

strip(chars=None)¶

去掉参数中包含的前导字符和尾随字符。

如果省略参数或无参数，则去掉前导和尾随ASCII空格。

lstrip(chars=None)¶

去掉参数中包含的前导字符。

如果省略参数或无参数，则去掉前导ASCII空格。

rstrip(chars=None)¶

去掉参数中包含的尾随字符。

如果省略参数或无参数，则去掉尾随的ASCII空格。

upper()¶: 返回所有ASCII字符均转换为大写的数据副本。

lower()¶: 返回所有ASCII字符均转换为小写的数据副本。

replace(old, new)¶: 返回一个副本，将所有出现的子字符串old替换为new。

translate(table, delete=b'')¶

返回一个副本，每个字符都由给定的转换表映射。

表格
转换表，它必须是长度为256字节的对象。

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

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

class Bio.Seq.Seq(data, length=None)¶

基类：_SeqAbstractBaseClass

只读序列对象(本质上是具有生物方法的字符串)。

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

Seq对象提供了许多类似字符串的方法(如Count、Find、Split和strie)。

Seq对象还提供了一些生物学方法，如补体、反向_补体、转录、反向转录和翻译(这些方法不适用于蛋白质序列)。

__init__(data, length=None)¶

创建一个Seq对象。

参数：

数据序列，必填项(字符串)
Length-序列长度，仅在数据为None(整数)时使用

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

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

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

要使用为已知长度但未知序列内容的序列创建Seq对象，请使用None作为Data参数，并传递Length参数的序列长度。尝试访问以此方式创建的Seq对象的Sequence内容将引发UnfinedSequenceError：

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

__hash__()¶

用于比较的字符串形式的序列哈希。

请参阅序列对象比较文档(方法 __eq__ 特别是)，因为在Biopython1.65中已经改变了这一点。旧版本将根据对象标识进行散列。

tomutable()¶

将完整序列作为MutableSeq对象返回。

>>> from Bio.Seq import Seq
>>> my_seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> my_seq
Seq('MKQHKAMIVALIVICITAVVAAL')
>>> my_seq.tomutable()
MutableSeq('MKQHKAMIVALIVICITAVVAAL')

encode(encoding='utf-8', errors='strict')¶

以字节对象的形式返回序列的编码版本。

Seq对象旨在匹配Python字符串的接口。

这实质上是为了在需要字节字符串(例如用于计算散列)时省去执行str(My_Seq).encode()：

>>> from Bio.Seq import Seq
>>> Seq("ACGT").encode("ascii")
b'ACGT'

complement()¶

通过创建新的Seq对象返回补码序列。

此方法适用于DNA序列：

>>> from Bio.Seq import Seq
>>> my_dna = Seq("CCCCCGATAG")
>>> my_dna
Seq('CCCCCGATAG')
>>> my_dna.complement()
Seq('GGGGGCTATC')

当然，您可以使用混合大小写序列，

>>> from Bio.Seq import Seq
>>> my_dna = Seq("CCCCCgatA-GD")
>>> my_dna
Seq('CCCCCgatA-GD')
>>> my_dna.complement()
Seq('GGGGGctaT-CH')

注在上面的例子中，歧义字符D表示G、A或T，因此它的补码是H(对于C、T或A)。

请注意，如果序列既不包含T也不包含U，我们假设它是DNA，并将任何A字符映射到T：

>>> Seq("CGA").complement()
Seq('GCT')
>>> Seq("CGAT").complement()
Seq('GCTA')

如果你真的有RNA，这目前是有效的，但是我们以后可能会弃用它。我们建议改用新的补体_RNA方法：

>>> Seq("CGAU").complement()
Seq('GCUA')
>>> Seq("CGAU").complement_rna()
Seq('GCUA')

如果序列同时包含T和U，则会引发异常：

>>> Seq("CGAUT").complement()
Traceback (most recent call last):
   ...
ValueError: Mixed RNA/DNA found

试图补充蛋白质序列得到的是一个无意义的序列：

>>> my_protein = Seq("MAIVMGR")
>>> my_protein.complement()
Seq('KTIBKCY')

这里，“M”被解释为“A”或“C”的IUPAC歧义代码，补语“K”表示“T”或“G”。同样，“A”有补语“T”。根据IUPAC公约，字母“i”没有明确的含义，没有变化。

reverse_complement()¶

通过创建新的Seq对象返回反向补码序列。

此方法适用于DNA序列：

>>> from Bio.Seq import Seq
>>> my_dna = Seq("CCCCCGATAGNR")
>>> my_dna
Seq('CCCCCGATAGNR')
>>> my_dna.reverse_complement()
Seq('YNCTATCGGGGG')

注意在上面的例子中，由于R=G或A，所以它的补码是Y(表示C或T)。

当然，您可以使用混合大小写序列，

>>> from Bio.Seq import Seq
>>> my_dna = Seq("CCCCCgatA-G")
>>> my_dna
Seq('CCCCCgatA-G')
>>> my_dna.reverse_complement()
Seq('C-TatcGGGGG')

正如对于补码方法所讨论的，如果序列既不包含T也不包含U，则假定IS是DNA，并且会将任何字母A映射到T。

如果您正在处理RNA，则应该改用新的REVERSE_COMPUTE_RNA方法

>>> Seq("CGA").reverse_complement()  # defaults to DNA
Seq('TCG')
>>> Seq("CGA").reverse_complement_rna()
Seq('UCG')

如果序列同时包含T和U，则会引发异常：

>>> Seq("CGAUT").reverse_complement()
Traceback (most recent call last):
   ...
ValueError: Mixed RNA/DNA found

试图反向补充蛋白质序列将得到一个无意义的序列：

>>> from Bio.Seq import Seq
>>> my_protein = Seq("MAIVMGR")
>>> my_protein.reverse_complement()
Seq('YCKBITK')

这里，“M”被解释为“A”或“C”的IUPAC歧义代码，补语“K”表示“T”或“G”，依此类推。

ungap(gap='-')¶

返回不带间隙字符的序列副本(已过时)。

现在，间隙字符默认为减号，并且只能通过方法参数指定。这不再可能通过序列的字母表(在Biopython1.77之前是可能的)：

>>> from Bio.Seq import Seq
>>> my_dna = Seq("-ATA--TGAAAT-TTGAAAA")
>>> my_dna
Seq('-ATA--TGAAAT-TTGAAAA')
>>> my_dna.ungap("-")
Seq('ATATGAAATTTGAAAA')

此方法已过时；请改用my_dna.place(ap，“”)。

__abstractmethods__ = frozenset({})¶

class Bio.Seq.UnknownSeq(length, alphabet=None, character='?')¶

基类：Seq

长度已知但内容未知的只读序列对象(已弃用)。

如果您有一个未知的序列，您可以用一个普通的Seq对象来表示它，例如：

>>> my_seq = Seq("N"*5)
>>> my_seq
Seq('NNNNN')
>>> len(my_seq)
5
>>> print(my_seq)
NNNNN

但是，这相当浪费内存(特别是对于大型序列)，而这正是该类最有用的地方：

>>> unk_five = UnknownSeq(5)
>>> unk_five
UnknownSeq(5, character='?')
>>> len(unk_five)
5
>>> print(unk_five)
?????

您可以将未知序列添加到一起。如果字符相同，您将获得另一个内存节约UnnownSeq：

>>> unk_four = UnknownSeq(4)
>>> unk_four
UnknownSeq(4, character='?')
>>> unk_four + unk_five
UnknownSeq(9, character='?')

如果字符不同，ADD会给出一个普通的Seq对象：

>>> unk_nnnn = UnknownSeq(4, character="N")
>>> unk_nnnn
UnknownSeq(4, character='N')
>>> unk_nnnn + unk_four
Seq('NNNN????')

与真实的Seq相结合，可以得到一个新的Seq对象：

>>> known_seq = Seq("ACGT")
>>> unk_four + known_seq
Seq('????ACGT')
>>> known_seq + unk_four
Seq('ACGT????')

虽然最初打算用于未知序列(因此称为类名)，但它也可以用于均聚物序列，如aaaaaa，生物学方法将遵守这一点：

>>> homopolymer = UnknownSeq(6, character="A")
>>> homopolymer.complement()
UnknownSeq(6, character='T')
>>> homopolymer.complement_rna()
UnknownSeq(6, character='U')
>>> homopolymer.translate()
UnknownSeq(2, character='K')

__init__(length, alphabet=None, character='?')¶

创建一个新的UnnownSeq对象。

参数：

长度-整数，必填。
字母表-不再使用，必须为无。
字符-单个字母字符串，默认为“？”。通常“N”代表核苷酸，“X”代表蛋白质，而“？”不然的话。

__len__()¶: 返回未知序列的声明长度。

__bytes__()¶: 将未知序列作为给定长度的完整字符串返回。

__str__()¶: 将未知序列作为给定长度的完整字符串返回。

__repr__()¶: 返回(截断)序列的表示形式以进行调试。

__add__(other)¶

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

如果字符相同，则将两个UnnownSeq对象相加将返回另一个UnnownSeq对象。

>>> from Bio.Seq import UnknownSeq
>>> UnknownSeq(10, character='X') + UnknownSeq(5, character='X')
UnknownSeq(15, character='X')

如果字符不同，则不能使用UnnownSeq对象，因此返回Seq对象：

>>> from Bio.Seq import UnknownSeq
>>> UnknownSeq(10, character='X') + UnknownSeq(5, character="x")
Seq('XXXXXXXXXXxxxxx')

如果将字符串添加到UnnownSeq，则返回新的Seq：

>>> from Bio.Seq import UnknownSeq
>>> UnknownSeq(5, character='X') + "LV"
Seq('XXXXXLV')

__radd__(other)¶: 在左侧添加一个序列。

__mul__(other)¶

将未知序列乘以整数。

>>> from Bio.Seq import UnknownSeq
>>> UnknownSeq(3) * 2
UnknownSeq(6, character='?')
>>> UnknownSeq(3, character="N") * 2
UnknownSeq(6, character='N')

__rmul__(other)¶

将整数乘以未知序列。

>>> from Bio.Seq import UnknownSeq
>>> 2 * UnknownSeq(3)
UnknownSeq(6, character='?')
>>> 2 * UnknownSeq(3, character="N")
UnknownSeq(6, character='N')

__imul__(other)¶

就地乘以未知序列。

>>> from Bio.Seq import UnknownSeq
>>> seq = UnknownSeq(3, character="N")
>>> seq *= 2
>>> seq
UnknownSeq(6, character='N')

__getitem__(index)¶

从UnnownSeq对象中获取一个子序列。

>>> unk = UnknownSeq(8, character="N")
>>> print(unk[:])
NNNNNNNN
>>> print(unk[5:3])

>>> print(unk[1:-1])
NNNNNN
>>> print(unk[1:-1:2])
NNN

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

返回一个不重叠的计数，类似于python字符串的计数。

它的行为类似于同名的python string(和Seq对象)方法，它执行非重叠计数！

对于重叠搜索，请使用较新的count_overlay()方法。

返回一个整数，即由给定的(SUB)序列中的子字符串参数SUB出现的次数 [开始：结束] 。可选参数start和end被解释为切片表示法。

参数：

Sub-要查找的字符串或另一个Seq对象
开始-可选整数，切片开始
结束-可选整数，切片结束

>>> "NNNN".count("N")
4
>>> Seq("NNNN").count("N")
4
>>> UnknownSeq(4, character="N").count("N")
4
>>> UnknownSeq(4, character="N").count("A")
0
>>> UnknownSeq(4, character="N").count("AA")
0

但是，请注意，因为python字符串和Seq对象(以及MutableSeq对象)执行非重叠搜索，所以这可能不会给出您期望的答案：

>>> UnknownSeq(4, character="N").count("NN")
2
>>> UnknownSeq(4, character="N").count("NNN")
1

count_overlap(sub, start=None, end=None)¶

返回重叠计数。

对于非重叠搜索，请使用count()方法。

返回一个整数，即由给定的(SUB)序列中的子字符串参数SUB出现的次数 [开始：结束] 。可选参数start和end被解释为切片表示法。

参数：

Sub-要查找的字符串或另一个Seq对象
开始-可选整数，切片开始
结束-可选整数，切片结束

例如：

>>> from Bio.Seq import UnknownSeq
>>> UnknownSeq(4, character="N").count_overlap("NN")
3
>>> UnknownSeq(4, character="N").count_overlap("NNN")
2

在子字符串不重叠的情况下，应与count()方法的行为相同：

>>> UnknownSeq(4, character="N").count_overlap("N")
4
>>> UnknownSeq(4, character="N").count_overlap("N") == UnknownSeq(4, character="N").count("N")
True
>>> UnknownSeq(4, character="N").count_overlap("A")
0
>>> UnknownSeq(4, character="N").count_overlap("A") == UnknownSeq(4, character="N").count("A")
True
>>> UnknownSeq(4, character="N").count_overlap("AA")
0
>>> UnknownSeq(4, character="N").count_overlap("AA") == UnknownSeq(4, character="N").count("AA")
True

complement()¶

假设补码是DNA，则返回补码。

在典型用法中，这将返回相同的未知序列：

>>> my_nuc = UnknownSeq(8, character='N')
>>> my_nuc
UnknownSeq(8, character='N')
>>> print(my_nuc)
NNNNNNNN
>>> my_nuc.complement()
UnknownSeq(8, character='N')
>>> print(my_nuc.complement())
NNNNNNNN

如果您的序列实际上不是未知的，并且具有N以外的核苷酸字母，则使用适当的DNA互补碱基：

>>> UnknownSeq(8, character="A").complement()
UnknownSeq(8, character='T')

complement_rna()¶

假设补码是RNA，则返回补码。

在典型用法中，这将返回相同的未知序列。如果您的序列实际上不是未知的，则使用适当的RNA互补碱基：

>>> UnknownSeq(8, character="A").complement_rna()
UnknownSeq(8, character='U')

reverse_complement()¶

假设它是DNA，则返回反向补码。

在典型用法中，这将返回相同的未知序列：

>>> from Bio.Seq import UnknownSeq
>>> example = UnknownSeq(6, character="N")
>>> print(example)
NNNNNN
>>> print(example.reverse_complement())
NNNNNN

如果您的序列实际上不是未知的，则使用适当的DNA互补碱基：

>>> UnknownSeq(8, character="A").reverse_complement()
UnknownSeq(8, character='T')

reverse_complement_rna()¶

假设它是RNA，则返回反向补码。

在典型用法中，这将返回相同的未知序列。如果您的序列实际上不是未知的，则使用适当的RNA互补碱基：

>>> UnknownSeq(8, character="A").reverse_complement_rna()
UnknownSeq(8, character='U')

transcribe()¶

从未知DNA序列返回未知RNA序列。

>>> my_dna = UnknownSeq(10, character="N")
>>> my_dna
UnknownSeq(10, character='N')
>>> print(my_dna)
NNNNNNNNNN
>>> my_rna = my_dna.transcribe()
>>> my_rna
UnknownSeq(10, character='N')
>>> print(my_rna)
NNNNNNNNNN

在典型用法中，这将返回相同的未知序列。如果你的序列实际上不是未知的，而是T的均聚物，那么标准的DNA到RNA的转录就完成了，用U：

>>> UnknownSeq(9, character="t").transcribe()
UnknownSeq(9, character='u')

back_transcribe()¶

从未知RNA序列返回未知DNA序列。

>>> my_rna = UnknownSeq(20, character="N")
>>> my_rna
UnknownSeq(20, character='N')
>>> print(my_rna)
NNNNNNNNNNNNNNNNNNNN
>>> my_dna = my_rna.back_transcribe()
>>> my_dna
UnknownSeq(20, character='N')
>>> print(my_dna)
NNNNNNNNNNNNNNNNNNNN

在典型用法中，这将返回相同的未知序列。如果您的序列实际上是U均聚物，则应用标准RNA到DNA的反向翻译，将U替换为T：

>>> UnknownSeq(9, character="U").back_transcribe()
UnknownSeq(9, character='T')

upper()¶

返回序列的大写副本。

>>> from Bio.Seq import UnknownSeq
>>> my_seq = UnknownSeq(20, character="n")
>>> my_seq
UnknownSeq(20, character='n')
>>> print(my_seq)
nnnnnnnnnnnnnnnnnnnn
>>> my_seq.upper()
UnknownSeq(20, character='N')
>>> print(my_seq.upper())
NNNNNNNNNNNNNNNNNNNN

另请参见下面的方法。

lower()¶

返回序列的小写副本。

>>> from Bio.Seq import UnknownSeq
>>> my_seq = UnknownSeq(20, character="X")
>>> my_seq
UnknownSeq(20, character='X')
>>> print(my_seq)
XXXXXXXXXXXXXXXXXXXX
>>> my_seq.lower()
UnknownSeq(20, character='x')
>>> print(my_seq.lower())
xxxxxxxxxxxxxxxxxxxx

另请参见上面的方法。

translate(table='Standard', stop_symbol='*', to_stop=False, cds=False, gap='-')¶

将未知的核苷酸序列翻译成未知的蛋白质。

如果您的序列作为密码子有意义(例如，PolyA尾巴aaaaa)，它将被相应地翻译：

>>> UnknownSeq(7, character='A').translate()
UnknownSeq(2, character='K')

否则，它将被翻译为未知氨基酸的X：

>>> UnknownSeq(7).translate()
UnknownSeq(2, character='X')

ungap(gap='-')¶

返回不带间隙字符的序列副本。

现在，间隙字符默认为减号，并且只能通过方法参数指定。这不再可能通过序列的字母表(在Biopython1.77之前是可能的)：

>>> from Bio.Seq import UnknownSeq
>>> my_dna = UnknownSeq(20, character='N')
>>> my_dna
UnknownSeq(20, character='N')
>>> my_dna.ungap()  # using default
UnknownSeq(20, character='N')
>>> my_dna.ungap("-")
UnknownSeq(20, character='N')

如果UnnownSeq使用间隙字符，则返回空的Seq：

>>> my_gap = UnknownSeq(20, character="-")
>>> my_gap
UnknownSeq(20, character='-')
>>> my_gap.ungap()  # using default
Seq('')
>>> my_gap.ungap("-")
Seq('')

join(other)¶

返回Other中的序列的合并，由Self中的序列分隔。

接受Seq或String(并迭代字母)，或者接受包含Seq或String对象的迭代数。这些参数将与作为间隔符的调用序列串联：

>>> concatenated = UnknownSeq(5).join([Seq("AAA"), Seq("TTT"), Seq("PPP")])
>>> concatenated
Seq('AAA?????TTT?????PPP')

如果所有输入也是使用相同字符的UnnownSeq，则它返回一个新的UnnownSeq：

>>> UnknownSeq(5).join([UnknownSeq(3), UnknownSeq(3), UnknownSeq(3)])
UnknownSeq(19, character='?')

采用单个序列并连接字母的示例：

>>> UnknownSeq(3).join("ACGT")
Seq('A???C???G???T')
>>> UnknownSeq(3).join(UnknownSeq(4))
UnknownSeq(13, character='?')

仅当所有要联接的对象都是与间隔符具有相同字符的UnnownSeq时，才会返回UnnownSeq对象，这类似于添加一个UnnownSeq和另一个UnnownSeq的工作方式。

__abstractmethods__ = frozenset({})¶

class Bio.Seq.MutableSeq(data)¶

基类：_SeqAbstractBaseClass

可编辑的序列对象。

与不可变的普通python字符串和基本的Sequence对象(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对象。

property data¶: 获取数据。

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

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

没有返回值。

complement()¶

修改可变序列以采用其补码。

没有返回值。

如果序列既不包含T也不包含U，则假定为DNA，并且任何A都将映射到T。

如果序列同时包含T和U，则会引发异常。

reverse_complement()¶

修改可变序列以采用其反向补码。

没有返回值。

extend(other)¶

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

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

没有返回值。

toseq()¶

将完整序列作为新的不可变的Seq对象返回。

>>> from Bio.Seq import MutableSeq
>>> my_mseq = MutableSeq("MKQHKAMIVALIVICITAVVAAL")
>>> my_mseq
MutableSeq('MKQHKAMIVALIVICITAVVAAL')
>>> my_mseq.toseq()
Seq('MKQHKAMIVALIVICITAVVAAL')

__abstractmethods__ = frozenset({})¶

exception Bio.Seq.UndefinedSequenceError¶

基类：ValueError

序列内容未定义。

Bio.Seq.transcribe(dna)¶

将DNA序列转录成RNA。

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

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

例如：

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

Bio.Seq.back_transcribe(rna)¶

将反转录成DNA的RNA序列返回。

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

给定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标识符(整数)或CodonTable对象(用于非标准遗传代码)。默认为“标准”表。
STOP_SYMBOL-用于任何终止符的单字符串，默认为星号“*”。
TO_STOP-布尔值，缺省为FALSE，表示在所有停止代码(转换为指定的STOP_SYMBOL)之后继续执行完整翻译。如果为True，则在帧内第一个停止密码处终止翻译(并且不会将STOP_SYMBOL附加到返回的蛋白质序列中)。
CDS-布尔值，表示这是一个完整的CDS。如果为True，则检查序列以有效的替代起始密码子(将转换为蛋氨酸，M)开始，序列长度是否为3的倍数，以及末尾是否有单个帧内终止密码子(无论TO_STOP选项如何，这将从蛋白质序列中排除)。如果这些测试失败，则会引发异常。
间隙-表示用于间隙的符号的单字符串。默认为无。

使用默认(标准)遗传代码的简单字符串示例：

>>> 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，在翻译时应真正以蛋氨酸(而不是缬氨酸)开头：

>>> 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”。任何无效密码子(例如“助教？”或“T-A”)将抛出一个TranslationError。

然而，它将翻译DNA或RNA。

注意-从1.71版开始，Biopython包含带有“歧义终止密码子”的密码子表。这些是具有明确序列的终止密码子，但具有作为STOP或氨基酸的上下文相关编码。对于这些表，‘TO_STOP’必须为FALSE(否则将引发ValueError)。双重编码密码子总是被翻译成氨基酸，除了‘cds=True’，其中最后一个密码子将被翻译成STOP。

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

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

但是，它将引发生物恐龙警告(未显示)。

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

返回核苷酸字符串的反向互补序列。

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

支持明确和模糊的核苷酸序列。

例如：

>>> reverse_complement("ACTG-NH")
'DN-CAGT'

如果既不存在T也不存在U，则假定为DNA，并将A映射到T：

>>> reverse_complement("A")
'T'

Bio.Seq.complement(sequence)¶

返回DNA字符串的补码序列。

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

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

支持明确和模糊的核苷酸序列。

例如：

>>> complement("ACTG-NH")
'TGAC-ND'

如果既不存在T也不存在U，则假定为DNA，并将A映射到T：

>>> complement("A")
'T'

然而，这在未来可能不会得到支持。如果您有RNA，请使用COMPARY_RNA函数。

Bio.Seq.complement_rna(sequence)¶

返回RNA字符串的补码序列。

>>> complement("ACG")  # assumed DNA
'TGC'
>>> complement_rna("ACG")
'UGC'

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