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。

例如，不帶鏈方向，在正向鏈上，以及在反向鏈上

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

位置鏈方向的別名（已過時）。

property ref

位置參考的別名（已過時）。

property ref_db

位置 ref_db 的別名（已過時）。

__eq__(other)

檢查兩個 SeqFeature 物件是否應被視為相等。

__repr__()

將特徵表示為字串以進行除錯。

__str__()

以 python 字串形式傳回完整特徵。

extract(parent_sequence, references=None)

從提供的父序列中擷取特徵的序列。

parent_sequence 可以是類似 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')

如果 SimpleLocation 為 None，例如在 GenBank 解析器中解析無效的 locus 位置時，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 物件（適用於非標準遺傳密碼）。預設為“Standard”表。

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

警告：為了更好地匹配正常的 Python 行為，SeqFeature 未來可能會在其長度為零時評估為 False！

__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 - 指定參考對應的序列區域的位置物件列表。如果沒有指定位置，則假定為整個序列。

• authors - 參考文獻的作者，一個大的舊字串，或按作者分割的列表。

• title - 參考文獻的標題。

• journal - 參考文獻發表的期刊。

• medline_id - 文章的 medline 參考文獻。

• pubmed_id - 文章的 pubmed 參考文獻。

• comment - 放置任何關於參考文獻的註釋的地方。

__init__()

初始化類別。

__str__()

將完整的 Reference 物件作為 Python 字串傳回。

__repr__()

將 Reference 物件表示為用於除錯的字串。

__eq__(other)

檢查是否應將兩個 Reference 物件視為相等。

請注意，在 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)

使用位置內的更複雜位置，

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

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

Bases: Location

指定序列上特徵的位置。

SimpleLocation 用於簡單的連續特徵，可以描述為從起始位置到結束位置（可選擇使用鏈和參考資訊）。由幾個不連續部分組成的更複雜的位置（例如，由幾個外顯子組成的編碼序列）使用具有 CompoundLocation 的 SeqFeature 進行描述。

請注意，起始位置和結束位置編號遵循 Python 的方案，因此 123..150（從 1 開始的計數）的 GenBank 條目會變成 [122:150] 的位置（從 0 開始的計數）。

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

也就是說，不要以感知鏈的方式從生物學角度考慮「開始」和「結束」，而是將它們視為所描述區域的「最左邊」或「最小」邊界，以及「最右邊」或「最大」邊界。這在描述不連續區域的複合位置中尤其重要。

在上面的範例中，我們使用了標準的精確位置，但也存在用於表示模糊位置的特殊位置物件。例如，像是 complement(<123..150) 這樣的 GenBank 位置會使用 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 物件。如果位置參照其他記錄，則必須在選填的字典 references 中提供這些記錄。

>>> 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 的別名，請參閱 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

更常見的是，您可以使用複合位置的起始和結束，它們會給出涵蓋的完整跨度，0 <= start <= end <= 完整序列長度。

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

這與單個區域的 SimpleLocation 行為一致，其中 'start' 和 'end' 不一定會給出生物起始和結束，而是 'minimal' 和 'maximal' 座標邊界。

請注意，加入位置會提供更直觀的建構方法

>>> 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 的所有部分是否等於另一個 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 物件。如果位置參照其他記錄，則必須在選填的字典 references 中提供這些記錄。

>>> 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 物件。

對於結束位置，將 offset 保留為零（預設值）

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

對於開始位置，將 offset 設定為減一（對於 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)

基底類別：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)

基底類別：ExactPosition

指定一個不確定的特定位置。

這用於 UniProt 中，例如 ?222 表示不確定的位置 222，或在 XML 格式中明確標記為不確定。不適用於 GenBank/EMBL。

__abstractmethods__ = frozenset({})

class Bio.SeqFeature.UnknownPosition

基底類別：Position

指定一個未知（沒有位置）的特定位置。

這用於 UniProt 中，例如 ? 或在 XML 中為 unknown。

__repr__()

將 UnknownPosition 物件表示為字串，以進行除錯。

__hash__()

回傳 UnknownPosition 物件的雜湊值。

__add__(offset)

回傳位置物件的副本，其位置已移動 (PRIVATE)。

__abstractmethods__ = frozenset({})

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

基底類別：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__ 接受的參數。

允許類別實例進行 pickle 和 unpickle 所必需的。

__repr__()

將 WithinPosition 物件表示為用於除錯的字串。

__str__()

返回 WithinPosition 物件的表示法（使用 Python 計數）。

__add__(offset)

返回一個位置物件的副本，其位置已偏移。

__abstractmethods__ = frozenset({})

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

基底類別：int、Position

指定兩個坐標之間的邊界位置（已過時？）。

引數

• 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

整數相等和比較使用給定的 position，

>>> 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__ 接受的參數。

允許類別實例進行 pickle 和 unpickle 所必需的。

__repr__()

將 BetweenPosition 物件表示為用於除錯的字串。

__str__()

返回 BetweenPosition 物件的表示法（使用 Python 計數）。

__add__(offset)

回傳位置物件的副本，其位置已移動 (PRIVATE)。

__abstractmethods__ = frozenset({})

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

基底類別：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)

基底類別：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)

基底類別：int、Position

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

這對應 GenBank 的 ‘one-of(1888,1901)’ 函式，並嘗試使其符合 Biopython 的 Position 模型。如果這是一個起始位置，它應該表現得像 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 衍生物件的列表，指定可能的位置。

position 是一個整數，指定預設行為。

__abstractmethods__ = frozenset({})

__getnewargs__()

返回 __new__ 接受的參數。

允許類別實例進行 pickle 和 unpickle 所必需的。

__repr__()

將 OneOfPosition 物件表示為字串，以便除錯。

__str__()

傳回 OneOfPosition 物件的表示法（使用 Python 計數）。

__add__(offset)

回傳位置物件的副本，其位置已移動 (PRIVATE)。