Bio.SeqFeature 模块

表示一个序列特征，包含序列部分的信息。

这是以 Biocorba SeqFeature 对象为模型，并且可能比较偏向 GenBank 的东西，因为我正在为 GenBank 解析器输出编写它……

这里有什么

用于保存特征的基类

类

SeqFeature

保存关于参考的信息

这是试图创建一个通用类来保存参考类型信息。

类

Reference

指定特征在序列上的位置

这旨在处理，用 Ewan Birney 的话来说，‘令人头疼的模糊性问题’。这有利于我们处理模糊的信息，以防有人需要它，并且还能与 BioPerl 等和 BioSQL 兼容。

类

Location - SimpleLocation 和 CompoundLocation 的抽象基类。
SimpleLocation - 指定特征的起始和结束位置。
CompoundLocation - SimpleLocation 对象的集合（用于连接等）。
Position - ExactPosition、WithinPosition、BetweenPosition、AfterPosition、OneOfPosition、UncertainPosition 和 UnknownPosition 的抽象基类。
ExactPosition - 将位置指定为精确的。
WithinPosition - 指定某个范围内发生的职位。
BetweenPosition - 指定某个范围内发生的职位（已弃用？）。
BeforePosition - 将位置指定为在某个碱基之前找到。
AfterPosition - 将位置指定为在某个碱基之后找到。
OneOfPosition - 指定由多个备选位置组成的位置。
UncertainPosition - 指定一个不确定的特定位置。
UnknownPosition - 代表缺失的信息，如 UniProt 中的 '？'。

异常

LocationParserError - 指示无法解析位置字符串的异常。

exception Bio.SeqFeature.LocationParserError

基类：ValueError

无法解析特征位置字符串。

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

基类：object

表示对象上的序列特征。

属性

location - 特征在序列上的位置（SimpleLocation）
type - 特征的指定类型（即 CDS、外显子、重复……）
id - 特征的字符串标识符。
qualifiers - 特征上的限定符字典。这些类似于 GenBank 特征表中的限定符。字典的键是限定符名称，值是限定符值。

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

在序列上初始化一个 SeqFeature。

location 可以是 SimpleLocation（如果需要，也给出 strand 参数），或者 None。

例如，没有 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

对于精确的起始/结束位置，可以使用整数（如上所示）作为 ExactPosition 对象的简写。对于非精确位置，必须通过适当的位置对象指定 SimpleLocation。

property strand: location 的 strand 的别名（已弃用）。

property ref: location 的 ref 的别名（已弃用）。

property ref_db: location 的 ref_db 的别名（已弃用）。

__eq__(other): 检查两个 SeqFeature 对象是否应被视为相等。

__repr__(): 将特征表示为用于调试的字符串。

__str__(): 以 Python 字符串形式返回完整的特征。

extract(parent_sequence, references=None)

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

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

这应该能够处理复杂的位置，包括互补、连接和模糊位置。即使是混合链特征也应该可以工作！这也涵盖了蛋白质序列上的特征（例如域），尽管这里不允许反向链特征。如果位置引用了其他记录，则必须在可选的 references 字典中提供这些记录。

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

如果 SimpleLocation 为 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 和 transl_table 限定符（如果存在）。如果不存在，则使用“table”和“start_offset”参数的值。

如果特征类型为“CDS”，则“cds”参数将设置为“True”，但可以通过提供显式参数来覆盖它。

参数 stop_symbol、to_stop 和 gap 与 Seq.translate 的含义相同，请参阅该文档以获取更多信息。

参数

parent_sequence - 一个 DNA 或 RNA 序列。
table - 如果此特征没有 transl_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, 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_offset 参数更改帧。请注意，这使用 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__ 方法之前，SeqFeature 始终被评估为 True。

请注意，相比之下，Seq 对象、字符串、列表等在长度为零时将被评估为 False。

警告：将来，当 SeqFeature 的长度为零时，它可能会被评估为 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

对于简单特征，这与跨越的区域相同（使用 Pythonic 计数的结束位置减去起始位置）。但是，对于复合位置（例如，作为多个外显子连接的 CDS），不会计算间隙（例如，内含子）。这确保 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](-)}

请注意，对于定义为多个子特征连接的特征（例如，多个外显子的并集），不会检查间隙（例如，内含子）。在这个例子中，tRNA 的位置在 GenBank 文件中定义为 complement(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]

__hash__ = None

class Bio.SeqFeature.Reference

基类：object

表示一个泛型引用对象。

属性

location - 指定引用所对应序列区域的 Location 对象列表。如果未指定任何位置，则假定为整个序列。
authors - 引用作者的大字符串或以作者分隔的列表。
title - 参考文献的标题。
journal - 发表引用的期刊。
medline_id - 文章的 medline 引用。
pubmed_id - 文章的 pubmed 引用。
comment - 用于存放有关引用的任何评论的地方。

__init__(): 初始化类。

__str__(): 将完整的引用对象作为 Python 字符串返回。

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

__eq__(other)

检查两个引用对象是否应该被认为相等。

请注意，在 Biopython 1.70 之前，位置没有被比较，因为在那之前 SimpleLocation 类的 __eq__ 没有被定义。

__hash__ = None

class Bio.SeqFeature.Location

Bases: ABC

表示位置的抽象基类。

abstract __repr__(): 将 Location 对象表示为用于调试的字符串。

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

从字符串创建 Location 对象。

这应该接受 INSDC 特征表格式 (https://www.insdc.org/submitting-standards/feature-table/) 中的任何有效位置字符串，如 GenBank、DDBJ 和 EMBL 文件中所使用。

简单示例

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

使用 within 位置的更复杂位置。

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

对于一个特殊情况，在循环基因组的开始/结束处的 between 位置，需要预期的序列长度。

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

除了这个特殊情况之外，between 位置 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__'})

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

Bases: Location

指定特征沿序列的位置。

SimpleLocation 用于简单连续的特征，这些特征可以被描述为从起始位置运行到结束位置（可选地带有链和引用信息）。由多个不连续部分组成的更复杂位置（例如，由多个外显子组成的编码序列）使用带有 CompoundLocation 的 SeqFeature 来描述。

请注意，起始位置和结束位置编号遵循 Python 的方案，因此 GenBank 条目 123..150（基于一的计数）变为位置 [122:150]（基于零的计数）。

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

请注意，链默认为 None。如果您正在处理核苷酸序列，则需要明确说明它是否是正链。

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

请注意，对于长度为 n 的父序列，SimpleLocation 的起始位置和结束位置必须满足不等式 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

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

在上面的示例中，我们使用了标准的精确位置，但还有一些专门的位置对象用于表示模糊位置，例如 GenBank 位置 complement(<123..150) 将对起始位置使用 BeforePosition 对象。

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

初始化类。

start 和 end 参数指定特征开始和结束的值。这些可以是继承自 Position 的任何 *Position 对象，也可以只是指定位置的整数。如果是整数，则假定这些值是精确的，并在 ExactPosition 参数中进行转换。这旨在简化处理非模糊端点的操作。

即简短形式

>>> 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，对已知链但链方向未知（GFF3 中的 ?）使用 0，或者对不适用链（GFF3 中的点）使用 None，例如蛋白质上的特征。

>>> 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): 从字符串创建 SimpleLocation 对象。

property strand: 位置的链（+1、-1、0 或 None）。

__str__()

返回 SimpleLocation 对象的表示（使用 Python 计数）。

对于简单情况，这使用 Python 切片语法 [122:150]（基于零的计数），GenBank 会将其称为 123..150（基于一的计数）。

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

__add__(other)

将位置与另一个 SimpleLocation 对象合并，或将其移动。

您可以将两个特征位置相加以创建一个联合 CompoundLocation

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

此外，您可以用这种方式将 SimpleLocation 与 CompoundLocation 合并。

单独添加一个整数将得到一个新的 SimpleLocation，其开始和结束位置偏移该数量。例如

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

这在编辑注释时很有用。

__radd__(other): 通过将位置偏移一个整数数量来返回一个 SimpleLocation 对象。

__sub__(other)

减去一个整数将使开始和结束位置偏移该数量。

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

这在编辑注释时很有用。您也可以将一个整数添加到特征位置（这会向相反方向移动）。

__nonzero__()

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

此行为是为了向后兼容，因为在添加 __len__ 方法之前，SimpleLocation 始终被评估为 True。

请注意，相比之下，Seq 对象、字符串、列表等在长度为零时将被评估为 False。

警告：SimpleLocation 在将来可能会在长度为零时被评估为 False（为了更好地匹配正常的 python 行为）！

__len__()

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

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

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

__contains__(value)

检查一个整数位置是否在 SimpleLocation 对象内。

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

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

迭代 SimpleLocation 对象中的父位置。

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

只读部分列表（始终只有一个，即 SimpleLocation 对象）。

这是一个方便的属性，允许您编写可以互换处理 SimpleLocation 对象（只有一个部分）和更复杂的 CompoundLocation 对象（有多个部分）的代码。

property start

起始位置 - 最左侧（最小）值，与链无关。

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

property end

结束位置 - 最右侧（最大）值，与链无关。

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

extract(parent_sequence, references=None)

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

parent_sequence 可以是类似 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({})

__hash__ = None

Bio.SeqFeature.FeatureLocation: 是 SimpleLocation 的别名

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

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

请注意，复合位置的链是自动计算的 - 如果子位置的链混合，则整体链将设置为 None。

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

上面的示例执行 list(f) 迭代特征内的坐标。这允许您在位置上使用 max 和 min，以找到覆盖的范围

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

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

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

这与 SimpleLocation 对单个区域的行为一致，在该区域中，‘start’ 和 ‘end’ 不一定给出生物学上的开始和结束，而是给出 ‘最小’ 和 ‘最大’ 坐标边界。

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

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

如果您设置了 CompoundLocation 的链，它将应用于所有部分 - 请谨慎使用

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

您可以添加另一个 SimpleLocation

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

您也可以添加另一个 CompoundLocation

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

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

>>> 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__ 方法之前，SimpleLocation 始终被评估为 True。

请注意，相比之下，Seq 对象、字符串、列表等在长度为零时将被评估为 False。

警告：SimpleLocation 在将来可能会在长度为零时被评估为 False（为了更好地匹配正常的 python 行为）！

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

__iter__(): 迭代 CompoundLocation 对象中的父位置。

__eq__(other): 检查 CompoundLocation 的所有部分是否等于 other CompoundLocation 的所有部分。

property start

起始位置 - 最左侧（最小）值，与链无关。

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

对于环状基因组起源的 CompoundLocation 特殊情况，这将返回零。

property end

结束位置 - 最右侧（最大）值，与链无关。

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

对于环状基因组起源的 CompoundLocation 特殊情况，这将与基因组长度匹配。

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 SimpleLocation, CompoundLocation
>>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
>>> fl1 = SimpleLocation(2, 8)
>>> fl2 = SimpleLocation(10, 15)
>>> fl3 = CompoundLocation([fl1,fl2])
>>> fl3.extract(seq)
Seq('QHKAMILIVIC')

__abstractmethods__ = frozenset({})

__hash__ = None

class Bio.SeqFeature.Position

Bases: ABC

表示位置的抽象基类。

abstract __repr__(): 将 Position 对象表示为字符串，用于调试。

static fromstring(text, offset=0)

从文本字符串构建 Position 对象。

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

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

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

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

注意整数行为是如何改变的！

>>> 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__'})

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

Bases: int, Position

指定边界的具体位置。

参数

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): 创建一个 ExactPosition 对象。

__str__(): 返回 ExactPosition 对象的表示形式（使用 Python 计数）。

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

__add__(offset): 返回位置对象的副本，其位置已移位（PRIVATE）。

__abstractmethods__ = frozenset({})

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

Bases: ExactPosition

指定一个不确定的具体位置。

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

__abstractmethods__ = frozenset({})

class Bio.SeqFeature.UnknownPosition

Bases: Position

指定一个未知的具体位置（没有位置）。

这在 UniProt 中使用，例如 ? 或者在 XML 中作为 unknown。

__repr__(): 将 UnknownPosition 对象表示为字符串，用于调试。

__hash__(): 返回 UnknownPosition 对象的哈希值。

__add__(offset): 返回位置对象的副本，其位置已移位（PRIVATE）。

__abstractmethods__ = frozenset({})

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

Bases: int, Position

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

参数：- position - 默认整数位置 - left - 边界的起始（左侧）位置 - right - 边界的结束（右侧）位置

这允许处理像 ((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

基本整数比较和运算应该像对待普通整数一样工作

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

注意这也适用于与其他位置对象的比较，在这种情况下，同样会使用整数行为

>>> 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): 创建一个 WithinPosition 对象。

__getnewargs__()

返回 __new__ 接受的参数。

对于允许类实例的腌制和解腌制是必要的。

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

__str__(): 返回 WithinPosition 对象的表示形式（使用 Python 计数）。

__add__(offset): 返回位置对象的副本，其位置已移位。

__abstractmethods__ = frozenset({})

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

Bases: int, Position

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

参数

position - 默认整数位置
left - 边界的起始（左侧）位置
right - 边界的结束（右侧）位置

这允许处理像 123^456 这样的位置。这表示序列的起始位于 123 和 456 之间的某个位置。由解析器决定将 position 参数设置为哪个边界点（取决于它被用作特征的起始还是结束）。例如，作为特征结束

>>> 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 和 extension 的旧遗留属性将起始/较低/左侧位置作为整数，以及到结束/较高/右侧位置的距离作为整数。注意，位置对象的行为就像左侧或右侧端点，具体取决于它创建的方式

>>> 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): 在 BetweenPosition 对象中创建一个新实例。

__getnewargs__()

返回 __new__ 接受的参数。

对于允许类实例的腌制和解腌制是必要的。

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

__str__(): 返回 BetweenPosition 对象的表示形式（使用 Python 计数）。

__add__(offset): 返回位置对象的副本，其位置已移位（PRIVATE）。

__abstractmethods__ = frozenset({})

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

Bases: int, Position

指定位置，实际位置发生在它之前。

参数

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): 在 BeforePosition 对象中创建一个新实例。

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

__str__(): 返回 BeforePosition 对象的表示形式（使用 Python 计数）。

__add__(offset): 返回位置对象的副本，其位置已移位（PRIVATE）。

__abstractmethods__ = frozenset({})

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

Bases: int, Position

指定位置，实际位置在它之后找到。

参数

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): 创建 AfterPosition 对象的新实例。

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

__str__(): 返回 AfterPosition 对象的表示形式（使用 Python 计数）。

__add__(offset): 返回位置对象的副本，其位置已移位（PRIVATE）。

__abstractmethods__ = frozenset({})

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

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

整数比较和运算符的行为类似于使用 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)

使用一组可能的职位初始化。

choices 是一个 Position 派生对象的列表，指定可能的 location。

position 是一个整数，指定默认行为。

__abstractmethods__ = frozenset({})

__getnewargs__()

返回 __new__ 接受的参数。

对于允许类实例的腌制和解腌制是必要的。

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

__str__(): 返回 OneOfPosition 对象的表示形式（使用 Python 计数）。

__add__(offset): 返回位置对象的副本，其位置已移位（PRIVATE）。