Bio. SeqPerformance模块

表示包含有关序列一部分的信息的序列特征。

这主要是根据Biocorba SeqPerformance对象建模的，并且可能非常偏向于基因库内容，因为我是为基因库解析器输出编写的.

这里有什么：

包含功能的基本类

职业：

• SeqFeature

保留有关引用的信息

这是试图创建General类来保存引用类型信息。

职业：

• 参考

指定要素在序列上的位置

用伊万·伯尼的话来说，这旨在解决“可怕的模糊问题”。这的优点是允许我们处理模糊的内容，以防有人需要，并且还与BioPerl等和BioSQL兼容。

职业：

• Locate-SimpleLocate和CompoundLocate的抽象Base。

• SimpleLocity-指定要素的开始和结束位置。

• CompoundLocity-SimpleLocity对象的集合（用于连接等）。

• Position -ExactPosition、WithinPosition、BetweenPosition、AfterPosition、OneOfPosition、UncertainPosition和UnknownPosition的抽象基类。

• 精确位置-指定精确位置。

• WithinStatus-指定某个范围内发生的位置。

• BetweenCamp-指定范围之间的位置（ObSOSYS？）。

• BeforeStatus-指定在某个基地之前找到的位置。

• AfterPosition -指定在某个基础之后找到的位置。

• OneOfStatus-指定由多个替代职位组成的职位。

• 不确定位置-指定不确定的特定位置。

• UnknownPosition -代表缺失的信息，例如“？”'在UniProt。

警告：

• LocationParser错误-指示解析位置字符串失败的异常。

exception Bio.SeqFeature.LocationParserError

基类：ValueError

无法分析要素位置字符串。

__firstlineno__ = 163

__static_attributes__ = ()

class Bio.SeqFeature.SeqFeature(location=None, type='', id='<unknown id>', qualifiers=None, sub_features=None)

基类：object

代表对象上的序列特征。

属性：

• 位置-序列上要素的位置（SimpleLocate）

• type -特征的指定类型（即，CDS，外显子，重复序列......）

• id -功能的字符串标识符。

• 限定符-功能的限定符词典。这些类似于基因库特征表中的限定符。字典的键是限定符名称，值是限定符值。

__init__(location=None, type='', id='<unknown id>', qualifiers=None, sub_features=None)

初始化序列上的SeqPerformance。

位置可以是SimpleLocate（如果需要，还可以提供strand参数），也可以是无。

例如，没有链，在正向链上和在反向链上：

>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> f1 = SeqFeature(SimpleLocation(5, 10), type="domain")
>>> f1.location.strand == None
True
>>> f2 = SeqFeature(SimpleLocation(7, 110, strand=1), type="CDS")
>>> f2.location.strand == +1
True
>>> f3 = SeqFeature(SimpleLocation(9, 108, strand=-1), type="CDS")
>>> f3.location.strand == -1
True

对于确切的开始/结束位置，可以使用一个integer（如上所示）作为ExactStatus对象的缩写。对于不精确的位置，必须通过适当的位置对象指定SimpleLocate。

property strand

指定该位置的链（已废弃）。

property ref

指定该地点的参考（已废除）。

property ref_db

指定该位置的ref_DB（已删除）。

__eq__(other)

检查两个SeqFeature对象是否应被视为相等。

__repr__()

将该功能表示为字符串以进行调试。

__str__()

以Python字符串的形式返回完整功能。

extract(parent_sequence, references=None)

从提供的父序列中提取要素的序列。

parent_order可以是类似Seq的对象或字符串，并且通常会返回相同类型的对象。例外是MutableSeq，因为父序列将返回Seq对象。

这应该能够应对复杂的位置，包括补充、连接和模糊位置。即使是混合串功能也应该起作用！这还涵盖蛋白质序列上的特征（例如结构域），尽管这里不允许反向链特征。如果位置引用其他记录，则必须在可选的字典引用中提供它们。

>>> from Bio.Seq import Seq
>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> f = SeqFeature(SimpleLocation(8, 15), type="domain")
>>> f.extract(seq)
Seq('VALIVIC')

如果SimpleLocity为“无”，例如，当在ESB解析器中解析无效的基因座位置时，extract（）将引发ValueHelp。

>>> from Bio.Seq import Seq
>>> from Bio.SeqFeature import SeqFeature
>>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> f = SeqFeature(None, type="domain")
>>> f.extract(seq)
Traceback (most recent call last):
   ...
ValueError: The feature's .location is None. Check the sequence file for a valid location.

注意-目前仅支持“join”类型的复合功能。

translate(parent_sequence, table='Standard', start_offset=None, stop_symbol='*', to_stop=False, cds=None, gap=None)

获取特征序列的翻译。

该方法旨在用于CDS或编码蛋白质的其他特征，并且是一种捷径，可以提取特征并翻译它，同时考虑密码子_start和transl_table限定符（如果存在的话）。如果它们不存在，则使用参数“table”和“start_odge”的值。

如果功能的类型为“CDS”，则“cds”参数设置为“True”，但可以通过给出显式参数来重写。

参数stop_Symbol、to_stop和gap与Seq具有相同的含义。翻译，请参阅该文档以了解更多信息。

论点：

• parent_order-DNA或RNA序列。

• table -如果此功能没有transl_table限定符，则使用哪个密码子表。这可以是名称（字符串）、NCBI标识符（integer）或CodonTable对象（对非标准遗传密码有用）。 这默认为“标准”表。

• start_offset -编码特征的第一个完整密码子相对于该特征的第一个碱基的偏移量。有效值为0、1或2。注意：这使用python的基于0的编号，而NCBI文件中的codon_start限定符使用基于1的编号。将覆盖codon_start限定符

>>> from Bio.Seq import Seq
>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> seq = Seq("GGTTACACTTACCGATAATGTCTCTGATGA")
>>> f = SeqFeature(SimpleLocation(0, 30), type="CDS")
>>> f.qualifiers['transl_table'] = [11]

请注意，CDS类型的特征在翻译时需要接受通常的检查。但您可以通过给出明确的参数来覆盖此行为：

>>> f.translate(seq, cds=False)
Seq('GYTYR*CL**')

现在使用start_odge参数来更改帧。请注意，这使用基于Python 0的编号。

>>> f.translate(seq, start_offset=1, cds=False)
Seq('VTLTDNVSD')

或者使用codon_start限定符来执行同样的事情。注意：这使用从1开始的编号，可在NCBI的文件中找到。

>>> f.qualifiers['codon_start'] = [2]
>>> f.translate(seq, cds=False)
Seq('VTLTDNVSD')

__bool__()

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

此行为是为了向后兼容，因为直到 __len__ 添加方法后，SeqPerformance始终评估为True。

请注意，相比之下，如果Seq对象、字符串、列表等的长度为零，它们的计算结果都将为False。

警告：SeqPerformance将来当其长度为零时可能会评估为False（为了更好地匹配正常的Python行为）！

__len__()

返回要素所在区域的长度。

>>> from Bio.Seq import Seq
>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> f = SeqFeature(SimpleLocation(8, 15), type="domain")
>>> len(f)
7
>>> f.extract(seq)
Seq('VALIVIC')
>>> len(f.extract(seq))
7

这是获取要素位置长度的代理：

>>> len(f.location)
7

对于简单的特征，这与跨越的区域相同（使用Python计数的结束位置减去开始位置）。然而，对于复合位置（例如CDS作为几个exon的结合），不计算间隙（例如intron）。这确保len（f）与len（f.extract（parent_seq））匹配，并且还确保在包裹原点等的功能时正常工作。

__iter__()

迭代要素内的父位置。

迭代顺序是串感知的，并且可以被认为是使用父序列坐标沿着特征移动：

>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> f = SeqFeature(SimpleLocation(5, 10, strand=-1), type="domain")
>>> len(f)
5
>>> for i in f: print(i)
9
8
7
6
5
>>> list(f)
[9, 8, 7, 6, 5]

这是用于迭代位置的代理，

>>> list(f.location)
[9, 8, 7, 6, 5]

__contains__(value)

检查要素内是否有一个整位置。

>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> f = SeqFeature(SimpleLocation(5, 10, strand=-1), type="domain")
>>> len(f)
5
>>> [i for i in range(15) if i in f]
[5, 6, 7, 8, 9]

例如，要查看哪些功能包括SNP位置，您可以使用以下内容：

>>> from Bio import SeqIO
>>> record = SeqIO.read("GenBank/NC_000932.gb", "gb")
>>> for f in record.features:
...     if 1750 in f:
...         print("%s %s" % (f.type, f.location))
source [0:154478](+)
gene [1716:4347](-)
tRNA join{[4310:4347](-), [1716:1751](-)}

请注意，对于定义为几个子特征的结合（例如几个exon的联合）的特征，不检查间隙（例如intron）。在本例中，TLR位置在基因库文件中定义为互补（join（1717. 1751,4311.. 4347）），因此位置1760落入间隙：

>>> for f in record.features:
...     if 1760 in f:
...         print("%s %s" % (f.type, f.location))
source [0:154478](+)
gene [1716:4347](-)

请注意，对于模糊位置可能需要额外的注意，例如就在BeforePosition之前：

>>> from Bio.SeqFeature import SeqFeature, SimpleLocation
>>> from Bio.SeqFeature import BeforePosition
>>> f = SeqFeature(SimpleLocation(BeforePosition(3), 8), type="domain")
>>> len(f)
5
>>> [i for i in range(10) if i in f]
[3, 4, 5, 6, 7]

请注意，它是用于测试该位置的会员资格的代理。

>>> [i for i in range(10) if i in f.location]
[3, 4, 5, 6, 7]

__firstlineno__ = 167

__hash__ = None

__static_attributes__ = ('id', 'location', 'qualifiers', 'type')

class Bio.SeqFeature.Reference

基类：object

代表通用引用对象。

属性：

• location -指定引用所对应的序列区域的Location对象列表。如果未指定位置，则假设整个序列。

• 作者-一个大的旧字符串，或按作者分割的供参考的作者列表。

• title -引用的标题。

• journal -参考文献发表的期刊。

• medline_id -文章的medline引用。

• pubmed_id -文章的pubmed引用。

• 评论-一个可以粘贴有关引用的任何评论的地方。

__init__()

初始化课程。

__str__()

以Python字符串形式返回完整的Reference对象。

__repr__()

将引用对象表示为字符串以进行调试。

__eq__(other)

检查两个引用对象是否应视为相等。

请注意，在Biopython 1.70之前，位置没有进行比较，因为在此之前 __eq__ 未定义SimpleLocate类。

__firstlineno__ = 638

__hash__ = None

__static_attributes__ = ('authors', 'comment', 'consrtm', 'journal', 'location', 'medline_id', 'pubmed_id', 'title')

class Bio.SeqFeature.Location

基类：ABC

表示位置的抽象Base Class。

abstractmethod __repr__()

将Locate对象表示为字符串以进行调试。

fromstring(length=None, circular=False, stranded=True)

从字符串创建Locate对象。

这应该接受在SEN、DDBJ和EmbL文件中使用的INSDC功能表格式（https：//www.insdc.org/submitting-standards/feature-table/）的任何有效位置字符串。

简单的例子：

>>> Location.fromstring("123..456", 1000)
SimpleLocation(ExactPosition(122), ExactPosition(456), strand=1)
>>> Location.fromstring("complement(<123..>456)", 1000)
SimpleLocation(BeforePosition(122), AfterPosition(456), strand=-1)

使用内部位置的更复杂的位置，

>>> Location.fromstring("(9.10)..(20.25)", 1000)
SimpleLocation(WithinPosition(8, left=8, right=9), WithinPosition(25, left=20, right=25), strand=1)

请注意，这将如何表现得好像它有8个开始和25个结束。

特征之间的零长度，

>>> Location.fromstring("123^124", 1000)
SimpleLocation(ExactPosition(123), ExactPosition(123), strand=1)

对于特殊情况，即环形基因组开始/结束的位置之间，需要预期的序列长度：

>>> Location.fromstring("1000^1", 1000)
SimpleLocation(ExactPosition(1000), ExactPosition(1000), strand=1)

除了这种特殊情况之外，位置P & Q之间必须有P+1==Q，

>>> Location.fromstring("123^456", 1000)
Traceback (most recent call last):
   ...
Bio.SeqFeature.LocationParserError: invalid feature location '123^456'

您可以选择提供引用名称：

>>> Location.fromstring("AL391218.9:105173..108462", 2000000)
SimpleLocation(ExactPosition(105172), ExactPosition(108462), strand=1, ref='AL391218.9')

>>> Location.fromstring("<2644..159", 2868, "circular")
CompoundLocation([SimpleLocation(BeforePosition(2643), ExactPosition(2868), strand=1), SimpleLocation(ExactPosition(0), ExactPosition(159), strand=1)], 'join')

__abstractmethods__ = frozenset({'__repr__'})

__annotations__ = {}

__firstlineno__ = 707

__static_attributes__ = ()

class Bio.SeqFeature.SimpleLocation(start, end, strand=None, ref=None, ref_db=None)

基类：Location

指定要素沿着序列的位置。

SimpleLocate用于简单的连续特征，可以描述为从开始位置运行到结束位置（可选地具有链和参考信息）。 使用具有CompoundLocate的SeqPerformance描述由几个非连续部分组成的更复杂位置（例如由几个exon组成的编码序列）。

请注意，开始和结束位置编号遵循Python的方案，因此家谱条目为123。150（以一为基础的计数）成为 [122:150] (zero基于计数）。

>>> from Bio.SeqFeature import SimpleLocation
>>> f = SimpleLocation(122, 150)
>>> print(f)
[122:150]
>>> print(f.start)
122
>>> print(f.end)
150
>>> print(f.strand)
None

请注意，该串默认为无。如果您正在处理核苷序列，您需要明确它是否是正向链：

>>> from Bio.SeqFeature import SimpleLocation
>>> f = SimpleLocation(122, 150, strand=+1)
>>> print(f)
[122:150](+)
>>> print(f.strand)
1

请注意，对于长度为n的父序列，SimpleLocity开始和结束必须满足不等式0 <= start <= end <= n。这意味着即使对于核苷酸序列反向链上的特征，我们也预计“开始”坐标小于“结束”。

>>> from Bio.SeqFeature import SimpleLocation
>>> r = SimpleLocation(122, 150, strand=-1)
>>> print(r)
[122:150](-)
>>> print(r.start)
122
>>> print(r.end)
150
>>> print(r.strand)
-1

即，与其以链感知的方式从生物学上思考“开始”和“结束”，不如将它们视为所描述区域的“最左”或“最小”边界，以及“最右”或“最大”边界。这对于描述非连续区域的复合位置尤其重要。

在上面的例子中，我们使用了标准的精确位置，但也有专门的位置对象用于表示模糊位置，例如像补录（< 123.. 150)首先会使用BeforeStatus对象。

__init__(start, end, strand=None, ref=None, ref_db=None)

初始化课程。

开始和结束参数指定功能开始和结束的值。这些可以由任何一个 *Position 继承自位置的对象，或者可以只是指定位置的整数。对于integer，假设值是精确的，并在ExactStatus参数中进行转换。这是为了让处理非模糊的结果变得容易。

即简短形式：

>>> from Bio.SeqFeature import SimpleLocation
>>> loc = SimpleLocation(5, 10, strand=-1)
>>> print(loc)
[5:10](-)

显式形式：

>>> from Bio.SeqFeature import SimpleLocation, ExactPosition
>>> loc = SimpleLocation(ExactPosition(5), ExactPosition(10), strand=-1)
>>> print(loc)
[5:10](-)

其他模糊位置也类似地使用，

>>> from Bio.SeqFeature import SimpleLocation
>>> from Bio.SeqFeature import BeforePosition, AfterPosition
>>> loc2 = SimpleLocation(BeforePosition(5), AfterPosition(10), strand=-1)
>>> print(loc2)
[<5:>10](-)

对于核苷特征，您还需要指定链，使用1代表正向（正）链，-1代表反向（负）链，0代表链但链未知（？在GFF 3中），或者当链不适用时（GFF 3中的点）为无，例如蛋白质上的特征。

>>> loc = SimpleLocation(5, 10, strand=+1)
>>> print(loc)
[5:10](+)
>>> print(loc.strand)
1

通常，要素位置是相对于您正在处理的父序列给出的，但可以通过可选的ref和db_ref字符串给出显式加入：

>>> loc = SimpleLocation(105172, 108462, ref="AL391218.9", strand=1)
>>> print(loc)
AL391218.9[105172:108462](+)
>>> print(loc.ref)
AL391218.9

static fromstring(text, length=None, circular=False)

从字符串创建SimpleLocate对象。

property strand

位置的串（+1、-1、0或无）。

__str__()

返回SimpleLocate对象的表示形式（使用pPython计数）。

对于简单的情况，这使用pPython拼接语法， [122:150] (zero基于计数），基因银行将其称为123.. 150（以一计）。

__repr__()

将SimpleLocate对象表示为字符串以进行调试。

__add__(other)

将位置与另一个SimpleLocate对象组合，或移动它。

您可以添加两个要素位置以加入CompoundLocity：

>>> from Bio.SeqFeature import SimpleLocation
>>> f1 = SimpleLocation(5, 10)
>>> f2 = SimpleLocation(20, 30)
>>> combined = f1 + f2
>>> print(combined)
join{[5:10], [20:30]}

因此，这相当于：

>>> from Bio.SeqFeature import CompoundLocation
>>> join = CompoundLocation([f1, f2])
>>> print(join)
join{[5:10], [20:30]}

您还可以使用sum（.）这样：

>>> join = sum([f1, f2])
>>> print(join)
join{[5:10], [20:30]}

此外，您可以通过这种方式将SimpleLocate与CompoundLocate结合起来。

单独地，添加一个整点将得到一个新的SimpleLocity，其起点和终点将被该量抵消。例如：

>>> print(f1)
[5:10]
>>> print(f1 + 100)
[105:110]
>>> print(200 + f1)
[205:210]

这在编辑注释时很有用。

__radd__(other)

通过将位置移动一个整量来返回SimpleLocate对象。

__sub__(other)

减去一个整元会将开头和结尾移动该量。

>>> from Bio.SeqFeature import SimpleLocation
>>> f1 = SimpleLocation(105, 150)
>>> print(f1)
[105:150]
>>> print(f1 - 100)
[5:50]

这在编辑注释时很有用。您还可以向要素位置（向相反方向移动）添加一个整数。

__nonzero__()

无论特征的长度如何，都返回True。

此行为是为了向后兼容，因为直到 __len__ 添加方法后，SimpleLocate始终评估为True。

请注意，相比之下，如果Seq对象、字符串、列表等的长度为零，它们的计算结果都将为False。

警告：当SimpleLocity的长度为零时，将来可能会评估为False（为了更好地匹配正常的Python行为）！

__len__()

返回SimpleLocate对象描述的区域的长度。

请注意，对于模糊的位置可能需要额外小心，例如

>>> from Bio.SeqFeature import SimpleLocation
>>> from Bio.SeqFeature import BeforePosition, AfterPosition
>>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10))
>>> len(loc)
5

__contains__(value)

检查SimpleLocate对象中是否有一个整位置。

请注意，对于模糊的位置可能需要额外小心，例如

>>> from Bio.SeqFeature import SimpleLocation
>>> from Bio.SeqFeature import BeforePosition, AfterPosition
>>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10))
>>> len(loc)
5
>>> [i for i in range(15) if i in loc]
[5, 6, 7, 8, 9]

__iter__()

迭代SimpleLocate对象内的父位置。

>>> from Bio.SeqFeature import SimpleLocation
>>> from Bio.SeqFeature import BeforePosition, AfterPosition
>>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10))
>>> len(loc)
5
>>> for i in loc: print(i)
5
6
7
8
9
>>> list(loc)
[5, 6, 7, 8, 9]
>>> [i for i in range(15) if i in loc]
[5, 6, 7, 8, 9]

请注意，这是链意识的：

>>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10), strand = -1)
>>> list(loc)
[9, 8, 7, 6, 5]

__eq__(other)

通过比较所有位置属性来实现平等。

property parts

只读部分列表（始终是一个，SimpleLocate对象）。

这是一个便利属性，允许您编写可互换处理SimpleLocate对象（具有一个部分）和更复杂的CompoundLocate对象（具有多个部分）的代码。

property start

开始位置-最左（最小）值，无论绳如何。

只读，返回一个像位置对象这样的整数，可能是一个模糊位置。

property end

结束位置-最右（最大）值，无论绳如何。

只读，返回一个像位置对象这样的整数，可能是一个模糊位置。

extract(parent_sequence, references=None)

使用SimpleLocate对象从提供的父序列中提取序列。

parent_order可以是类似Seq的对象或字符串，并且通常会返回相同类型的对象。例外是MutableSeq，因为父序列将返回Seq对象。如果位置引用其他记录，则必须在可选的字典引用中提供它们。

>>> from Bio.Seq import Seq
>>> from Bio.SeqFeature import SimpleLocation
>>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> feature_loc = SimpleLocation(8, 15)
>>> feature_loc.extract(seq)
Seq('VALIVIC')

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 838

__hash__ = None

__static_attributes__ = ('_end', '_start', '_strand', 'ref', 'ref_db', 'strand')

Bio.SeqFeature.FeatureLocation

SimpleLocation 的别名

class Bio.SeqFeature.CompoundLocation(parts, operator='join')

基类：Location

用于处理要素位置具有多个部分的连接等。

__init__(parts, operator='join')

初始化课程。

>>> from Bio.SeqFeature import SimpleLocation, CompoundLocation
>>> f1 = SimpleLocation(10, 40, strand=+1)
>>> f2 = SimpleLocation(50, 59, strand=+1)
>>> f = CompoundLocation([f1, f2])
>>> len(f) == len(f1) + len(f2) == 39 == len(list(f))
True
>>> print(f.operator)
join
>>> 5 in f
False
>>> 15 in f
True
>>> f.strand
1

请注意，复合位置的链是自动计算的-在子位置上混合链的情况下，整个链设置为无。

>>> f = CompoundLocation([SimpleLocation(3, 6, strand=+1),
...                       SimpleLocation(10, 13, strand=-1)])
>>> print(f.strand)
None
>>> len(f)
6
>>> list(f)
[3, 4, 5, 12, 11, 10]

上面执行列表（f）的示例迭代特征内的坐标。这允许您在位置上使用最大值和最小值，以找到覆盖的范围：

>>> min(f)
3
>>> max(f)
12

更一般地说，您可以使用复合位置的开始和结束，它们给出覆盖的全跨度，0 <= start <= end <=完整序列长度。

>>> f.start == min(f)
True
>>> f.end == max(f) + 1
True

这与SimpleLocate对单个区域的行为一致，其中“开始”和“结束”不一定给出生物学开始和结束，而是“最小”和“最大”坐标边界。

请注意，添加位置提供了一种更直观的构建方法：

>>> f = SimpleLocation(3, 6, strand=+1) + SimpleLocation(10, 13, strand=-1)
>>> len(f)
6
>>> list(f)
[3, 4, 5, 12, 11, 10]

__str__()

返回CompoundLocation对象的表示（使用python计数）。

__repr__()

将CompoundLocation对象表示为用于调试的字符串。

property strand

大院所在地的整体。

如果所有部分都具有相同的链，则返回该链。否则，对于混合串，此操作返回None。

>>> from Bio.SeqFeature import SimpleLocation, CompoundLocation
>>> f1 = SimpleLocation(15, 17, strand=1)
>>> f2 = SimpleLocation(20, 30, strand=-1)
>>> f = f1 + f2
>>> f1.strand
1
>>> f2.strand
-1
>>> f.strand
>>> f.strand is None
True

如果您设置CompoundLocity的链，则此操作将应用于所有部件-请谨慎使用：

>>> f.strand = 1
>>> f1.strand
1
>>> f2.strand
1
>>> f.strand
1

__add__(other)

合并位置，或将位置移动整数偏移量。

>>> from Bio.SeqFeature import SimpleLocation
>>> f1 = SimpleLocation(15, 17) + SimpleLocation(20, 30)
>>> print(f1)
join{[15:17], [20:30]}

您可以添加另一个SimpleLocity：

>>> print(f1 + SimpleLocation(40, 50))
join{[15:17], [20:30], [40:50]}
>>> print(SimpleLocation(5, 10) + f1)
join{[5:10], [15:17], [20:30]}

您还可以添加另一个化合物位置：

>>> f2 = SimpleLocation(40, 50) + SimpleLocation(60, 70)
>>> print(f2)
join{[40:50], [60:70]}
>>> print(f1 + f2)
join{[15:17], [20:30], [40:50], [60:70]}

此外，与SimpleLocity一样，添加一个整数会将位置的坐标移动该偏差：

>>> print(f1 + 100)
join{[115:117], [120:130]}
>>> print(200 + f1)
join{[215:217], [220:230]}
>>> print(f1 + (-5))
join{[10:12], [15:25]}

__radd__(other)

在左侧添加一个要素。

__contains__(value)

检查CompoundLocate对象内是否有一个整位置。

__nonzero__()

无论特征的长度如何，都返回True。

此行为是为了向后兼容，因为直到 __len__ 添加方法后，SimpleLocate始终评估为True。

请注意，相比之下，如果Seq对象、字符串、列表等的长度为零，它们的计算结果都将为False。

警告：当SimpleLocity的长度为零时，将来可能会评估为False（为了更好地匹配正常的Python行为）！

__len__()

返回CompoundLocate对象的长度。

__iter__()

在CompoundLocation对象中的父位置上迭代。

__eq__(other)

检查CompoundLocity的所有部分是否等于其他CompoundLocity的所有部分。

property start

开始位置-最左（最小）值，无论绳如何。

只读，返回一个像位置对象这样的整数，可能是一个模糊位置。

对于CompoundLocity包裹环形基因组起源的特殊情况，这将返回零。

property end

结束位置-最右（最大）值，无论绳如何。

只读，返回一个像位置对象这样的整数，可能是一个模糊位置。

对于包裹环形基因组起源的CompoundLocity的特殊情况，这将与基因组长度相匹配。

property ref

CompoundLocity中不存在，用于API兼容性的伪方法。

property ref_db

CompoundLocity中不存在，用于API兼容性的伪方法。

extract(parent_sequence, references=None)

使用CompoundLocate对象从提供的父序列中提取序列。

parent_order可以是类似Seq的对象或字符串，并且通常会返回相同类型的对象。例外是MutableSeq，因为父序列将返回Seq对象。如果位置引用其他记录，则必须在可选的字典引用中提供它们。

>>> from Bio.Seq import Seq
>>> from Bio.SeqFeature import SimpleLocation, CompoundLocation
>>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> fl1 = SimpleLocation(2, 8)
>>> fl2 = SimpleLocation(10, 15)
>>> fl3 = CompoundLocation([fl1,fl2])
>>> fl3.extract(seq)
Seq('QHKAMILIVIC')

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 1399

__hash__ = None

__static_attributes__ = ('operator', 'parts')

class Bio.SeqFeature.Position

基类：ABC

表示位置的抽象Base Class。

abstractmethod __repr__()

将位置对象表示为字符串以进行调试。

static fromstring(text, offset=0)

从文本字符串构建位置对象。

对于结束位置，将偏移保留为零（默认值）：

>>> Position.fromstring("5")
ExactPosition(5)

对于开始位置，将偏差设置为负一（对于Python计数）：

>>> Position.fromstring("5", -1)
ExactPosition(4)

这还涵盖模糊位置：

>>> p = Position.fromstring("<5")
>>> p
BeforePosition(5)
>>> print(p)
<5
>>> int(p)
5

>>> Position.fromstring(">5")
AfterPosition(5)

默认情况下假设结束位置，因此请注意integer行为：

>>> p = Position.fromstring("one-of(5,8,11)")
>>> p
OneOfPosition(11, choices=[ExactPosition(5), ExactPosition(8), ExactPosition(11)])
>>> print(p)
one-of(5,8,11)
>>> int(p)
11

>>> Position.fromstring("(8.10)")
WithinPosition(10, left=8, right=10)

模糊的开始位置：

>>> p = Position.fromstring("<5", -1)
>>> p
BeforePosition(4)
>>> print(p)
<4
>>> int(p)
4

请注意，integer行为也是如何变化的！

>>> p = Position.fromstring("one-of(5,8,11)", -1)
>>> p
OneOfPosition(4, choices=[ExactPosition(4), ExactPosition(7), ExactPosition(10)])
>>> print(p)
one-of(4,7,10)
>>> int(p)
4

__abstractmethods__ = frozenset({'__repr__'})

__annotations__ = {}

__firstlineno__ = 1799

__static_attributes__ = ()

class Bio.SeqFeature.ExactPosition(position, extension=0)

基类：int, Position

指定边界的特定位置。

论点：

• 位置-边界的位置。

• extension -一个可选参数，它必须为零，因为我们没有扩展。提供该参数是为了可以将相同数量的参数传递给所有位置类型。

在这种情况下，不存在与该位置相关的模糊性。

>>> p = ExactPosition(5)
>>> p
ExactPosition(5)
>>> print(p)
5

>>> isinstance(p, Position)
True
>>> isinstance(p, int)
True

收件箱比较和操作应按预期工作：

>>> p == 5
True
>>> p < 6
True
>>> p <= 5
True
>>> p + 10
ExactPosition(15)

static __new__(cls, position, extension=0)

创建ExactStatus对象。

__str__()

返回ExactPosition对象的表示（使用python计数）。

__repr__()

将ExactStatus对象表示为字符串以进行调试。

__add__(offset)

返回位置发生移动的位置对象的副本（PRIVATE）。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 1902

__static_attributes__ = ()

class Bio.SeqFeature.UncertainPosition(position, extension=0)

基类：ExactPosition

指定不确定的具体职位。

这在UniProt中使用，例如？222表示不确定位置222，或者以明确标记为不确定的ML格式。不适用于SEN/MBE。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 1963

__static_attributes__ = ()

class Bio.SeqFeature.UnknownPosition

基类：Position

指定未知（没有职位）的特定职位。

这在UniProt中使用，例如？或在HTML中显示为未知。

__repr__()

将UnknownStatus对象表示为字符串以进行调试。

__hash__()

返回UnknownPosition对象的哈希值。

__add__(offset)

返回位置发生移动的位置对象的副本（PRIVATE）。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 1971

__static_attributes__ = ()

class Bio.SeqFeature.WithinPosition(position, left, right)

基类：int, Position

指定某些坐标内边界的位置。

论点：- 位置-默认的整值位置-左-边界的开始（左）位置-右-边界的结束（右）位置

这允许处理像（（11.14）..这样的位置100）。这表明序列的开始在11和14之间。由于这是开始坐标，因此它应该表现得像在位置11（或在Python计数中，10）。

>>> p = WithinPosition(10, 10, 13)
>>> p
WithinPosition(10, left=10, right=13)
>>> print(p)
(10.13)
>>> int(p)
10

基本的integer比较和操作应该就像这是一个普通的integer一样工作：

>>> p == 10
True
>>> p in [9, 10, 11]
True
>>> p < 11
True
>>> p + 10
WithinPosition(20, left=20, right=23)

>>> isinstance(p, WithinPosition)
True
>>> isinstance(p, Position)
True
>>> isinstance(p, int)
True

请注意，这也适用于与其他位置对象的比较，其中再次使用了integer行为：

>>> p == 10
True
>>> p == ExactPosition(10)
True
>>> p == BeforePosition(10)
True
>>> p == AfterPosition(10)
True

如果这是终点，您会希望位置为13（右侧/较大的值，而不是上面的左侧/较小的值）：

>>> p2 = WithinPosition(13, 10, 13)
>>> p2
WithinPosition(13, left=10, right=13)
>>> print(p2)
(10.13)
>>> int(p2)
13
>>> p2 == 13
True
>>> p2 == ExactPosition(13)
True

static __new__(cls, position, left, right)

创建WithinStatus对象。

__getnewargs__()

返回接受的论点 __new__.

允许对类实例进行腌制和反腌制是必要的。

__repr__()

将WithinStatus对象表示为字符串以进行调试。

__str__()

返回WithinStatus对象的表示形式（使用Python计数）。

__add__(offset)

返回位置发生移动的位置对象的副本。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 1994

__static_attributes__ = ()

class Bio.SeqFeature.BetweenPosition(position, left, right)

基类：int, Position

指定两个坐标之间边界的位置（ObSOSYS？）。

论点：

• position -默认整数位置

• left -边界的起始（左）位置

• 右-边界的结束（右）位置

这允许处理类似123 ' 456的位置。这表明序列的开始位于123和456之间。解析器将位置参数设置为任意一个边界点（取决于这是用作功能的开始还是结束）。例如，作为功能端：

>>> p = BetweenPosition(456, 123, 456)
>>> p
BetweenPosition(456, left=123, right=456)
>>> print(p)
(123^456)
>>> int(p)
456

分配平等和比较使用给定的位置，

>>> p == 456
True
>>> p in [455, 456, 457]
True
>>> p > 300
True

位置和扩展的旧遗留属性将开始/下/左位置作为一个整体，并将到结束/上/右位置的距离作为一个整体。请注意，位置对象将像左终点或右终点，具体取决于它的创建方式：

>>> p2 = BetweenPosition(123, left=123, right=456)
>>> int(p) == int(p2)
False
>>> p == 456
True
>>> p2 == 123
True

请注意这个可能令人惊讶的行为：

>>> BetweenPosition(123, left=123, right=456) == ExactPosition(123)
True
>>> BetweenPosition(123, left=123, right=456) == BeforePosition(123)
True
>>> BetweenPosition(123, left=123, right=456) == AfterPosition(123)
True

即，对于相等（和排序）来说，位置对象的行为就像个位数一样。

static __new__(cls, position, left, right)

在BetweenStatus对象中创建新实例。

__getnewargs__()

返回接受的论点 __new__.

允许对类实例进行腌制和反腌制是必要的。

__repr__()

将BetweenStatus对象表示为字符串以进行调试。

__str__()

返回BetweenStatus对象的表示形式（使用Python计数）。

__add__(offset)

返回位置发生移动的位置对象的副本（PRIVATE）。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 2108

__static_attributes__ = ()

class Bio.SeqFeature.BeforePosition(position, extension=0)

基类：int, Position

指定一个实际位置出现在其前面的位置。

论点：

• 位置-位置可能出现的上边界。

• extension -一个可选参数，它必须为零，因为我们没有扩展。提供该参数是为了可以将相同数量的参数传递给所有位置类型。

这用于指定像（<10.）这样的位置100)其中该位置发生在位置10之前的某个地方。

>>> p = BeforePosition(5)
>>> p
BeforePosition(5)
>>> print(p)
<5
>>> int(p)
5
>>> p + 10
BeforePosition(15)

请注意这个可能令人惊讶的行为：

>>> p == ExactPosition(5)
True
>>> p == AfterPosition(5)
True

请记住，对于相等和排序来说，位置对象的行为就像个位数一样。

static __new__(cls, position, extension=0)

在BeforeStatus对象中创建新实例。

__repr__()

将位置表示为字符串以进行调试。

__str__()

返回BeforeStatus对象的表示形式（使用Python计数）。

__add__(offset)

返回位置发生移动的位置对象的副本（PRIVATE）。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 2209

__static_attributes__ = ()

class Bio.SeqFeature.AfterPosition(position, extension=0)

基类：int, Position

指定一个位置，在该位置之后可以找到实际位置。

论点：

• 位置-位置可能出现的下限。

• extension -一个可选参数，它必须为零，因为我们没有扩展。提供该参数是为了可以将相同数量的参数传递给所有位置类型。

这用于指定像（>10.）这样的位置100)其中该位置发生在位置10之后的某个地方。

>>> p = AfterPosition(7)
>>> p
AfterPosition(7)
>>> print(p)
>7
>>> int(p)
7
>>> p + 10
AfterPosition(17)

>>> isinstance(p, AfterPosition)
True
>>> isinstance(p, Position)
True
>>> isinstance(p, int)
True

请注意这个可能令人惊讶的行为：

>>> p == ExactPosition(7)
True
>>> p == BeforePosition(7)
True

请记住，对于相等和排序来说，位置对象的行为就像个位数一样。

static __new__(cls, position, extension=0)

创建AfterStatus对象的新实例。

__repr__()

将位置表示为字符串以进行调试。

__str__()

返回AfterPosition对象的表示形式（使用Python计数）。

__add__(offset)

返回位置发生移动的位置对象的副本（PRIVATE）。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 2266

__static_attributes__ = ()

class Bio.SeqFeature.OneOfPosition(position, choices)

基类：int, Position

指定一个位置，其中位置可以是多个位置。

这模拟了GenBank的“one-of（1888，1901）”函数，并试图使其适合Biopython位置模型。如果这是一个开始位置，它应该像1888，但作为一个结束位置1901。

>>> p = OneOfPosition(1888, [ExactPosition(1888), ExactPosition(1901)])
>>> p
OneOfPosition(1888, choices=[ExactPosition(1888), ExactPosition(1901)])
>>> int(p)
1888

RST比较和运算符的作用就像使用int（p）一样，

>>> p == 1888
True
>>> p <= 1888
True
>>> p > 1888
False
>>> p + 100
OneOfPosition(1988, choices=[ExactPosition(1988), ExactPosition(2001)])

>>> isinstance(p, OneOfPosition)
True
>>> isinstance(p, Position)
True
>>> isinstance(p, int)
True

static __new__(cls, position, choices)

用一组可能的位置初始化。

选择是位置衍生对象的列表，指定可能的位置。

位置是一个指定默认行为的整数。

__abstractmethods__ = frozenset({})

__annotations__ = {}

__firstlineno__ = 2330

__getnewargs__()

返回接受的论点 __new__.

允许对类实例进行腌制和反腌制是必要的。

__static_attributes__ = ()

__repr__()

将OneOfStatus对象表示为字符串以进行调试。

__str__()

返回OneOfStatus对象的表示形式（使用pPython计数）。

__add__(offset)

返回位置发生移动的位置对象的副本（PRIVATE）。