Bio.SeqFeature模块¶

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

这在很大程度上模仿了Biocorba SeqFeature对象，可能对GenBank内容有相当的偏见，因为我是为GenBank解析器输出编写它的……

这里有什么：

用于保存要素的基类¶

班级：

SeqFeature

保存有关引用的信息¶

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

班级：

参考文献

指定序列上要素的位置¶

用尤恩·伯尼(Ewan Birney)的话说，这是为了处理“可怕的模糊问题”。这样做的好处是，我们可以在任何人需要的情况下处理模糊的东西，并且还可以与BioPerl等和BioSQL兼容。

班级：

特征位置(FeatureLocation)-指定特征的开始和结束位置。
CompoundLocation-FeatureLocation对象的集合(用于连接等)。
精确位置(ExactPosition)-指定精确的位置。
范围内位置-指定在某个范围内出现的位置。
介于位置(BetweenPosition)-指定出现在范围(过时？)之间的位置。
先于位置(BeforePosition)-指定在某个底座之前找到的位置。
AfterPosition-指定在某个基数之后找到的位置。
OneOfPosition-指定位置可以是多个位置的位置。
不确定位置-指定不确定的特定位置。
未知位置-表示缺少的信息，如“？”在UniProt中。

class Bio.SeqFeature.SeqFeature(location=None, type='', location_operator='', strand=None, id='<unknown id>', qualifiers=None, sub_features=None, ref=None, ref_db=None)¶

基类：object

表示对象上的序列特征。

属性：

位置-序列上要素的位置(FeatureLocation)
类型-指定的要素类型(即CD，外显子，重复.)
LOCATION_OPERATOR-指定此SeqFeature如何与其他SeqFeature关联的字符串。例如，在下面显示的示例GenBank特性中，LOCATION_OPERATOR将是“Join”。这是Feature.location.Operator的代理，并且仅适用于复合位置。
链-指定该功能处理哪条链(例如，DNA序列的链)的值。1表示正链，-1表示负链，0表示搁浅但未知(？在GFF3中)，而缺省值NONE表示链不适用(GFF3中的点，例如蛋白质上的特征)。注意：这是访问特征位置的STRAND属性的快捷方式。
ID-功能的字符串标识符。
REF-对另一个序列的引用。这可能是某个不同序列的登录号。注意：这是要素位置的Reference属性的快捷方式。
ref_db-参考登录号的不同数据库。请注意，这是位置的引用属性的快捷方式
限定词-有关该功能的限定词词典。它们类似于GenBank功能表中的限定符。字典的键是限定符名称，值是限定符的值。从Biopython1.69开始，这是一个有序的词典。

__init__(location=None, type='', location_operator='', strand=None, id='<unknown id>', qualifiers=None, sub_features=None, ref=None, ref_db=None)¶

初始化序列上的SeqFeature。

位置可以是FeatureLocation(如果需要，还可以给出strand参数)或无。

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

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

无效的链将触发异常：

>>> f4 = SeqFeature(FeatureLocation(50, 60), strand=2)
Traceback (most recent call last):
   ...
ValueError: Strand should be +1, -1, 0 or None, not 2

同样，如果直接通过FeatureLocation设置：

>>> loc4 = FeatureLocation(50, 60, strand=2)
Traceback (most recent call last):
   ...
ValueError: Strand should be +1, -1, 0 or None, not 2

对于精确的开始/结束位置，可以使用整数(如上所述)作为ExactPosition对象的速记。对于非精确位置，必须通过适当的Position对象指定FeatureLocation。

请注意，SeqFeature的strand、ref和ref_db参数现在已过时，将在将来的版本中弃用(将提供警告消息)，并在以后删除。改为通过Location对象设置它们。

请注意，LOCATION_OPERATOR和SUB_FEATURES参数不能再使用，而是通过CompoundLocation对象执行此操作。

property strand¶

要素的链

这是Feature.location.strand的快捷方式

property ref¶

功能位置参考(例如加入)。

这是要素的快捷方式。location.ref

property ref_db¶

要素位置参考的数据库。

这是要素的快捷方式。location.ref_db

property location_operator¶: 复合位置的位置运算符(例如JOIN)。

__repr__()¶: 将该功能表示为用于调试的字符串。

__str__()¶: 以python字符串形式返回完整功能。

extract(parent_sequence, references=None)¶

从提供的父序列中提取特征的序列。

PARENT_SEQUENCE可以是类似Seq的对象，也可以是字符串，通常会返回相同类型的对象。例外情况是MutableSeq，因为父序列将返回Seq对象。

这应该可以处理复杂的位置，包括补语、连接和模糊位置。即使是混合串功能也应该起作用！这也包括蛋白质序列上的特征(例如结构域)，尽管这里不允许反链特征。如果该位置引用其他记录，则必须在可选的字典参考中提供这些记录。

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

如果FeatureLocation为NONE，例如在解析GenBank解析器中的无效位置时，Extract()将引发ValueError。

>>> 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或其他编码蛋白质的特征，是一种快捷方式，它将提取特征并翻译它，同时考虑CODON_START和TRAIL_TABLE限定符(如果存在)。如果它们不存在，则使用参数“TABLE”和“START_OFFSET”的值。

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

参数STOP_SYMBOL、TO_STOP和GAP与Seq.Translate的含义相同，有关详细信息，请参阅该文档。

参数：

Parent_Sequence-DNA或RNA序列。
TABLE-如果此功能没有TRAIL_TABLE限定符，则使用哪个密码表。它可以是名称(字符串)、NCBI标识符(整数)或CodonTable对象(用于非标准遗传代码)。这默认为“标准”表。
START_OFFSET-可以找到编码特征的第一个完整密码子的偏移量，相对于该特征的第一个碱基。具有有效值0、1或2。注意：这使用Python的从0开始的编号，而来自NCBI的文件中的CODON_START限定符使用从1开始的编号。将覆盖CODON_START限定符

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

请注意，CDS类型的功能在转换时要进行通常的检查。但您可以通过给出显式参数来覆盖此行为：

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

现在使用START_OFFSET参数更改帧。注意，这使用基于python0的编号。

>>> 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__ 方法时，SeqFeature的计算结果始终为True。

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

警告：将来，当SeqFeature的长度为零时，其计算结果可能为false(为了更好地匹配正常的Python行为)！

__len__()¶

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

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

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

>>> len(f.location)
7

对于简单的功能，这与跨越的区域相同(结束位置减去使用Pythonic计数的开始位置)。然而，对于复合位置(例如，CDS作为几个外显子的连接)，不计算间隙(例如，内含子)。这样可以确保len(F)与len(f.tract(Parent_Seq))匹配，还可以确保包装原点的特征等工作正常。

__iter__()¶

迭代要素内的父位置。

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

>>> from Bio.SeqFeature import SeqFeature, FeatureLocation
>>> f = SeqFeature(FeatureLocation(5, 10), type="domain", strand=-1)
>>> 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, FeatureLocation
>>> f = SeqFeature(FeatureLocation(5, 10), type="domain", strand=-1)
>>> 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](-)}

注意，对于定义为几个子特征的连接的特征(例如，几个外显子的联合)，不检查间隙(例如，内含子)。在本例中，tRNA位置在GenBank文件中定义为补码(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, FeatureLocation
>>> from Bio.SeqFeature import BeforePosition
>>> f = SeqFeature(FeatureLocation(BeforePosition(3), 8), type="domain")
>>> len(f)
5
>>> [i for i in range(10) if i in f]
[3, 4, 5, 6, 7]

请注意，IS是测试位置上的成员资格的代理。

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

class Bio.SeqFeature.Reference¶

基类：object

表示通用引用对象。

属性：

位置(Location)-指定引用对应的序列区域的位置对象列表。如果未指定位置，则假定为整个序列。
作者-参考的作者的大旧字符串或按作者拆分的列表。
标题-引用的标题。
期刊-参考文献发表在期刊上。
Medline_id-文章的Medline引用。
pubMed_id-文章的发布参考。
注释-粘贴有关引用的任何注释的位置。

__init__()¶: 初始化类。

__str__()¶: 以python字符串的形式返回完整的引用对象。

__repr__()¶: 将引用对象表示为用于调试的字符串。

__eq__(other)¶

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

注意：在Biopython 1.70之前，位置不会进行比较，因为在此之前 __eq__ 未定义FeatureLocation类的。

__hash__ = None¶

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

基类：object

指定特征沿序列的位置。

FeatureLocation用于简单的连续特征，可以描述为从起始位置运行到结束位置(可选地使用链和参考信息)。使用带有CompoundLocation的SeqFeature描述由几个非连续部分组成的更复杂的位置(例如，由几个外显子组成的编码序列)。

请注意，开始和结束位置编号遵循Python的方案，因此GenBank条目123..150(基于一的计数)成为的位置 [122：150] (从零开始计数)。

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

请注意，线束默认为无。如果您使用的是核苷酸序列，如果它是正向链，则需要明确：

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

请注意，对于长度为n的亲本序列，FeatureLocation的开始和结束必须满足不等式0<=start<=end<=n。这意味着即使对于核苷酸序列的反链上的特征，我们也期望‘start’坐标小于‘end’。

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

也就是说，与其以一种有条带意识的生物学方式思考“开始”和“结束”，不如将它们想象为所描述区域的“最左”或“最小”边界，以及“最右”或“最大”边界。这对于描述非连续区域的复合位置尤其重要。

在上面的示例中，我们使用了标准的精确位置，但也有专门的位置对象用于表示模糊位置，例如，像补码(<123..150)这样的GenBank位置将使用BeforePosition对象作为开始。

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

初始化类。

开始和结束参数指定特征开始和结束的值。这些可以由任何 *Position 从AbstractPosition继承的对象，或者可以只是指定位置的整数。对于整数，假设这些值是精确的，并在ExactPosition参数中进行转换。这是为了使处理非模糊目标变得容易。

即缩写形式：

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

显式形式：

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

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

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

对于核苷酸特征，您还需要指定链，正向(正)链使用1，反向(负)链使用-1，链未知(？)在GFF3中)，或当链不适用时为无(GFF3中的圆点)，例如蛋白质上的特征。

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

通常，特征位置是相对于您正在处理的父序列给出的，但可以使用可选的ref和db_ref字符串进行显式加入：

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

property strand¶: 位置的链(+1、-1、0或无)。

__str__()¶

返回FeatureLocation对象的表示形式(带有python计数)。

对于简单的情况，这使用Python拼接语法， [122：150] (基于零的计数)，GenBank将其称为123..150(基于1的计数)。

__repr__()¶: 将FeatureLocation对象表示为用于调试的字符串。

__add__(other)¶

将Location与另一个FeatureLocation对象合并，或将其移位。

您可以添加两个特征位置以创建连接CompoundLocation：

>>> from Bio.SeqFeature import FeatureLocation
>>> f1 = FeatureLocation(5, 10)
>>> f2 = FeatureLocation(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]}

此外，您可以通过这种方式将FeatureLocation与CompoundLocation组合在一起。

另外，添加整数将得到一个新的FeatureLocation，其起点和终点偏移为该值。例如：

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

这在编辑注释时很有用。

__radd__(other)¶: 在左侧添加一个要素位置另一个要素位置对象。

__nonzero__()¶

无论要素的长度如何，都返回True。

此行为是为了向后兼容，因为在 __len__ 方法，则FeatureLocation始终计算为True。

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

警告：将来，当FeatureLocation的长度为零时，其计算结果可能为false(为了更好地匹配正常的Python行为)！

__len__()¶

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

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

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

__contains__(value)¶

检查FeatureLocation对象中是否存在整数位置。

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

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

__iter__()¶

迭代FeatureLocation对象内的父位置。

>>> from Bio.SeqFeature import FeatureLocation
>>> from Bio.SeqFeature import BeforePosition, AfterPosition
>>> loc = FeatureLocation(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]

请注意，这是STAND感知的：

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

__eq__(other)¶: 通过比较所有位置属性来实现相等。

property parts¶

只读截面列表(始终为一个，即FeatureLocation对象)。

这是一个方便的属性，允许您编写代码以互换方式处理简单的FeatureLocation对象(只有一个部分)和更复杂的CompoundLocation对象(有多个部分)。

property start¶

起始位置-最左侧(最小)值，与线束无关。

只读，返回一个类似Position对象的整数，可能是模糊位置。

property end¶

结束位置-最右侧(最大)值，与线束无关。

只读，返回一个类似Position对象的整数，可能是模糊位置。

property nofuzzy_start¶

起始位置(整数，如果模糊则近似，只读)(废弃)。

这现在是int(feature ure.start)的别名，应该优先使用它--除非您试图支持旧版本的Biopython。

property nofuzzy_end¶

结束位置(整数，如果模糊则近似，只读)(废弃)。

这现在是int(feature ure.end)的别名，应该优先使用它--除非您试图支持旧版本的Biopython。

extract(parent_sequence, references=None)¶

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

PARENT_SEQUENCE可以是类似Seq的对象，也可以是字符串，通常会返回相同类型的对象。例外情况是MutableSeq，因为父序列将返回Seq对象。如果该位置引用其他记录，则必须在可选的字典参考中提供这些记录。

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

__hash__ = None¶

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

基类：object

用于处理连接等，其中一个特征位置有几个部分。

__init__(parts, operator='join')¶

初始化类。

>>> from Bio.SeqFeature import FeatureLocation, CompoundLocation
>>> f1 = FeatureLocation(10, 40, strand=+1)
>>> f2 = FeatureLocation(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([FeatureLocation(3, 6, strand=+1),
...                       FeatureLocation(10, 13, strand=-1)])
>>> print(f.strand)
None
>>> len(f)
6
>>> list(f)
[3, 4, 5, 12, 11, 10]

上面的示例执行列表(F)迭代要素内的坐标。这允许您在位置上使用max和min，以查找覆盖的范围：

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

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

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

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

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

>>> f = FeatureLocation(3, 6, strand=+1) + FeatureLocation(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 FeatureLocation, CompoundLocation
>>> f1 = FeatureLocation(15, 17, strand=1)
>>> f2 = FeatureLocation(20, 30, strand=-1)
>>> f = f1 + f2
>>> f1.strand
1
>>> f2.strand
-1
>>> f.strand
>>> f.strand is None
True

如果设置CompoundLocation的链，这将应用于所有零件-请谨慎使用：

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

__add__(other)¶

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

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

您可以添加另一个FeatureLocation：

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

您还可以添加另一个CompoundLocation：

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

此外，与FeatureLocation一样，添加整数会将位置的坐标移位该偏移量：

>>> 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)¶: 检查CompoundLocation对象中是否存在整数位置。

__nonzero__()¶

无论要素的长度如何，都返回True。

此行为是为了向后兼容，因为在 __len__ 方法，则FeatureLocation始终计算为True。

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

警告：将来，当FeatureLocation的长度为零时，其计算结果可能为false(为了更好地匹配正常的Python行为)！

__len__()¶: 返回CompoundLocation对象的长度。

__iter__()¶: 迭代CompoundLocation对象内的父位置。

__eq__(other)¶: 检查CompoundLocation的所有部分是否与其他CompoundLocation的所有部分相同。

property start¶

起始位置-最左侧(最小)值，与线束无关。

只读，返回一个类似Position对象的整数，可能是模糊位置。

对于包装环形基因组原点的CompoundLocation的特殊情况，这将返回零。

property end¶

结束位置-最右侧(最大)值，与线束无关。

只读，返回一个类似Position对象的整数，可能是模糊位置。

对于CompoundLocation包装圆形基因组原点的特殊情况，这将与基因组长度匹配(给定Python如何从零开始计算，减去1)。

property nofuzzy_start¶

起始位置(整数，如果模糊则近似，只读)(废弃)。

这是int(feature ure.start)的别名，应该优先使用它--除非您试图支持旧版本的Biopython。

property nofuzzy_end¶

结束位置(整数，如果模糊则近似，只读)(废弃)。

这是int(feature ure.end)的别名，应该优先使用它--除非您试图支持旧版本的Biopython。

property ref¶: CompoundLocation中不存在，用于API兼容性的伪方法。

property ref_db¶: CompoundLocation中不存在，用于API兼容性的伪方法。

extract(parent_sequence, references=None)¶

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

PARENT_SEQUENCE可以是类似Seq的对象，也可以是字符串，通常会返回相同类型的对象。例外情况是MutableSeq，因为父序列将返回Seq对象。如果该位置引用其他记录，则必须在可选的字典参考中提供这些记录。

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

__hash__ = None¶

class Bio.SeqFeature.AbstractPosition¶

基类：object

表示职位的抽象基类。

__repr__()¶: 将AbstractPosition对象表示为用于调试的字符串。

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

基类：int, AbstractPosition

指定边界的特定位置。

参数：

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

在这种情况下，没有与位置相关联的模糊性。

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

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

整数比较和运算应按预期工作：

>>> p == 5
True
>>> p < 6
True
>>> p <= 5
True
>>> p + 10
15

static __new__(cls, position, extension=0)¶: 创建一个ExactPosition对象。

__str__()¶: 返回ExactPosition对象的表示形式(带有python计数)。

__repr__()¶: 将ExactPosition对象表示为用于调试的字符串。

property position¶: 要获取整数位置的遗留属性(已过时)。

property extension¶: 此对象中不存在，则返回零(已过时)。

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

基类：ExactPosition

指定不确定的特定位置。

这在UniProt中使用，例如？222表示不确定位置222，或在明确标记为不确定的XML格式中使用。不适用于GenBank/EMBL。

class Bio.SeqFeature.UnknownPosition¶

基类：AbstractPosition

指定未知的特定位置(没有位置)。

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

__repr__()¶: 将UnnownPosition对象表示为用于调试的字符串。

__hash__()¶: 返回UnnownPosition对象的哈希值。

property position¶: 要获取位置的旧属性(无)(已过时)。

property extension¶: 要将扩展名(零)作为整数(过时)获取的旧式属性。

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

基类：int, AbstractPosition

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

参数：-position-默认整数位置-Left-边界的开始(左)位置-Right-边界的结束(右)位置

这允许处理像((1.4)..100)这样的位置。这表明序列的起始位置在1和4之间。因为这是一个起始坐标，所以它的行为应该像它在位置1一样(或者在Python计数中是0)。

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

基本整数比较和运算应该像纯整数一样工作：

>>> p == 10
True
>>> p in [9, 10, 11]
True
>>> p < 11
True
>>> p + 10
20

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

注意：这也适用于与其他Position对象的比较，在其他Position对象中，同样使用整数行为：

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

位置和延伸的旧传统属性将起始/较低/左侧位置指定为整数，并将到结束/较高/右侧位置的距离指定为整数。请注意，Position对象的行为将类似于左侧或右侧端点，具体取决于其创建方式：

>>> p.position == p2.position == 10
True
>>> p.extension == p2.extension == 3
True
>>> int(p) == int(p2)
False
>>> p == 10
True
>>> p2 == 13
True

static __new__(cls, position, left, right)¶: 创建一个WithinPosition对象。

__getnewargs__()¶

返回接受的参数 __new__.

允许对类实例进行酸洗和取消酸洗所必需的。

__repr__()¶: 将WithinPosition对象表示为用于调试的字符串。

__str__()¶: 返回WithinPosition对象的表示形式(带有Python计数)。

property position¶: 要获取(左)位置为整数(已过时)的遗留属性。

property extension¶: 将扩展名(从左到右)作为整数(过时)获取的遗留属性。

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

基类：int, AbstractPosition

指定两个坐标之间边界的位置(过时？)。

参数：

位置-默认整数位置
左-边界的起始(左)位置
Right-边界的结束(右)位置

这允许处理类似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

位置和延伸的旧传统属性将起始/较低/左侧位置指定为整数，并将到结束/较高/右侧位置的距离指定为整数。请注意，Position对象的行为将类似于左侧或右侧端点，具体取决于其创建方式：

>>> p2 = BetweenPosition(123, left=123, right=456)
>>> p.position == p2.position == 123
True
>>> p.extension
333
>>> p2.extension
333
>>> p.extension == p2.extension == 333
True
>>> 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

即，为了相等(和排序)，Position对象的行为类似于整数。

static __new__(cls, position, left, right)¶: 在BetweenPosition对象中创建一个新实例。

__getnewargs__()¶

返回接受的参数 __new__.

允许对类实例进行酸洗和取消酸洗所必需的。

__repr__()¶: 将BetweenPosition对象表示为用于调试的字符串。

__str__()¶: 返回BetweenPosition对象的表示形式(带有python计数)。

property position¶: 要获取(左)位置为整数(已过时)的遗留属性。

property extension¶: 将扩展名(从左到右)作为整数(过时)获取的遗留属性。

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

基类：int, AbstractPosition

指定实际位置在其前面的位置。

参数：

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

它用于指定位置(<10..100)之类的位置，其中位置位于位置10之前的某个位置。

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

请注意这一潜在的令人惊讶的行为：

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

请记住，对于相等和排序，Position对象的行为类似于整数。

static __new__(cls, position, extension=0)¶: 在BeforePosition对象中创建一个新实例。

property position¶: 要获取整数位置的遗留属性(已过时)。

property extension¶: 要将扩展名(零)作为整数(过时)获取的旧式属性。

__repr__()¶: 将位置表示为字符串以进行调试。

__str__()¶: 返回BeforePosition对象的表示形式(带有python计数)。

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

基类：int, AbstractPosition

指定在其后面找到实际位置的位置。

参数：

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

它用于指定位置(>10..100)之类的位置，位置位于位置10之后的某个位置。

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

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

请注意这一潜在的令人惊讶的行为：

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

请记住，对于相等和排序，Position对象的行为类似于整数。

static __new__(cls, position, extension=0)¶: 创建AfterPosition对象的新实例。

property position¶: 要获取整数位置的遗留属性(已过时)。

property extension¶: 要将扩展名(零)作为整数(过时)获取的旧式属性。

__repr__()¶: 将位置表示为字符串以进行调试。

__str__()¶: 返回AfterPosition对象的表示形式(带有Python计数)。

class Bio.SeqFeature.OneOfPosition(position, choices)¶

基类：int, AbstractPosition

指定位置可以是多个位置的位置。

这将对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

整数比较和运算符的作用类似于使用int(P)，

>>> p == 1888
True
>>> p <= 1888
True
>>> p > 1888
False
>>> p + 100
1988

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

位置和扩展的旧遗留属性将起始/最低/最左位置指定为整数，并将到结束/最高/最右位置的距离指定为整数。请注意，Position对象的行为将类似于可能的位置列表之一，具体取决于它的创建方式：

>>> p2 = OneOfPosition(1901, [ExactPosition(1888), ExactPosition(1901)])
>>> p.position == p2.position == 1888
True
>>> p.extension == p2.extension == 13
True
>>> int(p) == int(p2)
False
>>> p == 1888
True
>>> p2 == 1901
True

static __new__(cls, position, choices)¶

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

Position_List是AbstractPosition派生对象的列表，指定可能的位置。

Position是指定默认行为的整数。

__getnewargs__()¶

返回接受的参数 __new__.

允许对类实例进行酸洗和取消酸洗所必需的。

property position¶: 要获取(左)位置为整数(已过时)的遗留属性。

property extension¶: 要获取整数形式的扩展名的旧式属性(已过时)。

__repr__()¶: 将OneOfPosition对象表示为用于调试的字符串。

__str__()¶: 返回OneOfPosition对象的表示形式(带有python计数)。

class Bio.SeqFeature.PositionGap(gap_size)¶

基类：object

保存位置之间差距信息的简单类。

__init__(gap_size)¶: 使用包含间隙信息的Position对象初始化。

__repr__()¶: 将位置间隙表示为用于调试的字符串。

__str__()¶: 返回PositionGap对象的表示形式(带有Python计数)。