Bio.Align 套件

子套件

子模組

模組內容

用於處理序列比對的程式碼。

這個模組中最重要的東西之一是 MultipleSeqAlignment 類別，用於 Bio.AlignIO 模組中。

class Bio.Align.AlignmentCounts(gaps, identities, mismatches)

基底類別：tuple

__getnewargs__()

將自己作為一個純粹的元組返回。用於複製和 pickle。

static __new__(_cls, gaps, identities, mismatches)

建立 AlignmentCounts(gaps, identities, mismatches) 的新實例

__repr__()

返回格式良好的表示字串

__slots__ = ()
gaps

欄位編號 0 的別名

identities

欄位編號 1 的別名

mismatches

欄位編號 2 的別名

class Bio.Align.MultipleSeqAlignment(records, alphabet=None, annotations=None, column_annotations=None)

基底類別：object

表示經典的多重序列比對 (MSA)。

我們指的是一組長度相同（通常使用間隙字元進行插入或填充）的序列（通常顯示為行）。然後，資料可以被視為字母矩陣，具有明確定義的列。

您通常會使用 AlignIO 模組載入比對檔案來建立 MSA

>>> from Bio import AlignIO
>>> align = AlignIO.read("Clustalw/opuntia.aln", "clustal")
>>> print(align)
Alignment with 7 rows and 156 columns
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273285|gb|AF191659.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273284|gb|AF191658.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273287|gb|AF191661.1|AF191
TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273286|gb|AF191660.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273290|gb|AF191664.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273289|gb|AF191663.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273291|gb|AF191665.1|AF191

在某些方面，您可以將這些物件視為 SeqRecord 物件的清單，每個物件都代表比對的一行。迭代比對會給出每行的 SeqRecord 物件

>>> len(align)
7
>>> for record in align:
...     print("%s %i" % (record.id, len(record)))
...
gi|6273285|gb|AF191659.1|AF191 156
gi|6273284|gb|AF191658.1|AF191 156
gi|6273287|gb|AF191661.1|AF191 156
gi|6273286|gb|AF191660.1|AF191 156
gi|6273290|gb|AF191664.1|AF191 156
gi|6273289|gb|AF191663.1|AF191 156
gi|6273291|gb|AF191665.1|AF191 156

您也可以透過索引來存取單獨的行，將其視為 SeqRecord 物件

>>> print(align[0].id)
gi|6273285|gb|AF191659.1|AF191
>>> print(align[-1].id)
gi|6273291|gb|AF191665.1|AF191

並提取列作為字串

>>> print(align[:, 1])
AAAAAAA

或者，僅提取前十列作為子比對

>>> print(align[:, :10])
Alignment with 7 rows and 10 columns
TATACATTAA gi|6273285|gb|AF191659.1|AF191
TATACATTAA gi|6273284|gb|AF191658.1|AF191
TATACATTAA gi|6273287|gb|AF191661.1|AF191
TATACATAAA gi|6273286|gb|AF191660.1|AF191
TATACATTAA gi|6273290|gb|AF191664.1|AF191
TATACATTAA gi|6273289|gb|AF191663.1|AF191
TATACATTAA gi|6273291|gb|AF191665.1|AF191

將此比對切片與比對相加相結合，可以讓您刪除比對的某一部分。例如，僅取前十列和最後十列

>>> print(align[:, :10] + align[:, -10:])
Alignment with 7 rows and 20 columns
TATACATTAAGTGTACCAGA gi|6273285|gb|AF191659.1|AF191
TATACATTAAGTGTACCAGA gi|6273284|gb|AF191658.1|AF191
TATACATTAAGTGTACCAGA gi|6273287|gb|AF191661.1|AF191
TATACATAAAGTGTACCAGA gi|6273286|gb|AF191660.1|AF191
TATACATTAAGTGTACCAGA gi|6273290|gb|AF191664.1|AF191
TATACATTAAGTATACCAGA gi|6273289|gb|AF191663.1|AF191
TATACATTAAGTGTACCAGA gi|6273291|gb|AF191665.1|AF191

注意 - 此物件不嘗試對下一代定序中使用的比對類型進行建模，這種比對中有多個定序讀取比對短得多，並且通常存在具有特殊狀態的共有序列或參考序列。

__init__(records, alphabet=None, annotations=None, column_annotations=None)

初始化新的 MultipleSeqAlignment 物件。

參數
  • records - SeqRecord 物件的清單（或迭代器），其

    序列都具有相同的長度。這可以是空的清單。

  • alphabet - 僅為了向後相容性；它的值應始終

    為 None。

  • annotations - 有關整個比對的資訊（字典）。

  • column_annotations - 每列註解（受限字典）。

    這會保存 Python 序列（清單、字串、元組），其長度與列數相符。一個典型的用途是二級結構共有字串。

您通常會使用 Bio.AlignIO 從檔案載入 MSA，但您也可以從 SeqRecord 物件的清單中執行此操作

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("AAAACGT"), id="Alpha")
>>> b = SeqRecord(Seq("AAA-CGT"), id="Beta")
>>> c = SeqRecord(Seq("AAAAGGT"), id="Gamma")
>>> align = MultipleSeqAlignment([a, b, c],
...                              annotations={"tool": "demo"},
...                              column_annotations={"stats": "CCCXCCC"})
>>> print(align)
Alignment with 3 rows and 7 columns
AAAACGT Alpha
AAA-CGT Beta
AAAAGGT Gamma
>>> align.annotations
{'tool': 'demo'}
>>> align.column_annotations
{'stats': 'CCCXCCC'}
property column_annotations

序列的每個字母註解的字典。

__str__()

返回比對的多行字串摘要。

此輸出旨在具有可讀性，但大型比對會顯示為截斷。最多顯示 20 行（序列）和 50 列，以及記錄識別碼。這應該很適合在單一螢幕上顯示。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("ACTGCTAGCTAG"), id="Alpha")
>>> b = SeqRecord(Seq("ACT-CTAGCTAG"), id="Beta")
>>> c = SeqRecord(Seq("ACTGCTAGATAG"), id="Gamma")
>>> align = MultipleSeqAlignment([a, b, c])
>>> print(align)
Alignment with 3 rows and 12 columns
ACTGCTAGCTAG Alpha
ACT-CTAGCTAG Beta
ACTGCTAGATAG Gamma

另請參閱比對的 format 方法。

__repr__()

傳回物件的表示形式以進行除錯。

表示形式不能與 eval() 一起使用來重新建立物件，而這通常對於簡單的 Python 物件是可行的。例如：

<Bio.Align.MultipleSeqAlignment instance (2 records of length 14) at a3c184c>

十六進制字串是物件的記憶體位址，請參閱 help(id)。這提供了一種簡單的方法來視覺上區分相同大小的比對。

__format__(format_spec)

以指定檔案格式傳回比對作為字串。

格式應為 Bio.AlignIO 支援作為輸出格式的小寫字串（例如「fasta」、「clustal」、「phylip」、「stockholm」等），該格式用於將比對轉換為字串。

例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("ACTGCTAGCTAG"), id="Alpha", description="")
>>> b = SeqRecord(Seq("ACT-CTAGCTAG"), id="Beta", description="")
>>> c = SeqRecord(Seq("ACTGCTAGATAG"), id="Gamma", description="")
>>> align = MultipleSeqAlignment([a, b, c])
>>> print(format(align, "fasta"))
>Alpha
ACTGCTAGCTAG
>Beta
ACT-CTAGCTAG
>Gamma
ACTGCTAGATAG

>>> print(format(align, "phylip"))
 3 12
Alpha      ACTGCTAGCT AG
Beta       ACT-CTAGCT AG
Gamma      ACTGCTAGAT AG
__iter__()

將比對行作為 SeqRecord 物件進行迭代。

例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("ACTGCTAGCTAG"), id="Alpha")
>>> b = SeqRecord(Seq("ACT-CTAGCTAG"), id="Beta")
>>> c = SeqRecord(Seq("ACTGCTAGATAG"), id="Gamma")
>>> align = MultipleSeqAlignment([a, b, c])
>>> for record in align:
...    print(record.id)
...    print(record.seq)
...
Alpha
ACTGCTAGCTAG
Beta
ACT-CTAGCTAG
Gamma
ACTGCTAGATAG
__len__()

傳回比對中的序列數量。

使用 len(alignment) 來取得序列的數量（即列數），以及使用 alignment.get_alignment_length() 來取得最長序列的長度（即欄數）。

如果您將對齊結果視為 SeqRecord 物件的列表，這會很容易記住。

get_alignment_length()

回傳對齊結果的最大長度。

對齊結果中的所有物件（希望）都應該具有相同的長度。此函數會遍歷並尋找對齊結果中序列的最大長度，來找出此長度。

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("ACTGCTAGCTAG"), id="Alpha")
>>> b = SeqRecord(Seq("ACT-CTAGCTAG"), id="Beta")
>>> c = SeqRecord(Seq("ACTGCTAGATAG"), id="Gamma")
>>> align = MultipleSeqAlignment([a, b, c])
>>> align.get_alignment_length()
12

如果您想知道對齊結果中序列的數量，請改用 len(align)。

>>> len(align)
3
extend(records)

將更多 SeqRecord 物件作為列新增到對齊結果中。

它們的長度必須與原始對齊結果相同。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("AAAACGT"), id="Alpha")
>>> b = SeqRecord(Seq("AAA-CGT"), id="Beta")
>>> c = SeqRecord(Seq("AAAAGGT"), id="Gamma")
>>> d = SeqRecord(Seq("AAAACGT"), id="Delta")
>>> e = SeqRecord(Seq("AAA-GGT"), id="Epsilon")

首先，我們建立一個小的對齊結果（三列）。

>>> align = MultipleSeqAlignment([a, b, c])
>>> print(align)
Alignment with 3 rows and 7 columns
AAAACGT Alpha
AAA-CGT Beta
AAAAGGT Gamma

現在，我們可以將另外兩列擴展到此對齊結果中。

>>> align.extend([d, e])
>>> print(align)
Alignment with 5 rows and 7 columns
AAAACGT Alpha
AAA-CGT Beta
AAAAGGT Gamma
AAAACGT Delta
AAA-GGT Epsilon

由於對齊物件允許迭代每一列作為 SeqRecord，您可以將 extend 方法與第二個對齊結果一起使用（前提是其序列的長度與原始對齊結果相同）。

append(record)

將一個 SeqRecord 物件作為新列新增到對齊結果中。

它的長度必須與原始對齊結果相同（除非這是第一個記錄）。

>>> from Bio import AlignIO
>>> align = AlignIO.read("Clustalw/opuntia.aln", "clustal")
>>> print(align)
Alignment with 7 rows and 156 columns
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273285|gb|AF191659.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273284|gb|AF191658.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273287|gb|AF191661.1|AF191
TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273286|gb|AF191660.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273290|gb|AF191664.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273289|gb|AF191663.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273291|gb|AF191665.1|AF191
>>> len(align)
7

現在，我們將建構一個虛擬記錄以附加作為範例。

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> dummy = SeqRecord(Seq("N"*156), id="dummy")

現在將其附加到對齊結果中。

>>> align.append(dummy)
>>> print(align)
Alignment with 8 rows and 156 columns
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273285|gb|AF191659.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273284|gb|AF191658.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273287|gb|AF191661.1|AF191
TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273286|gb|AF191660.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273290|gb|AF191664.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273289|gb|AF191663.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA gi|6273291|gb|AF191665.1|AF191
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN...NNN dummy
>>> len(align)
8
__add__(other)

將兩個具有相同列數的對齊結果相加來合併它們。

如果您有兩個多重序列對齊結果 (MSA)，有兩種方式可以考慮將它們相加：按列或按行。使用 extend 方法是按列新增。使用加法運算子是按行新增。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a1 = SeqRecord(Seq("AAAAC"), id="Alpha")
>>> b1 = SeqRecord(Seq("AAA-C"), id="Beta")
>>> c1 = SeqRecord(Seq("AAAAG"), id="Gamma")
>>> a2 = SeqRecord(Seq("GT"), id="Alpha")
>>> b2 = SeqRecord(Seq("GT"), id="Beta")
>>> c2 = SeqRecord(Seq("GT"), id="Gamma")
>>> left = MultipleSeqAlignment([a1, b1, c1],
...                             annotations={"tool": "demo", "name": "start"},
...                             column_annotations={"stats": "CCCXC"})
>>> right = MultipleSeqAlignment([a2, b2, c2],
...                             annotations={"tool": "demo", "name": "end"},
...                             column_annotations={"stats": "CC"})

現在，讓我們看看這兩個對齊結果。

>>> print(left)
Alignment with 3 rows and 5 columns
AAAAC Alpha
AAA-C Beta
AAAAG Gamma
>>> print(right)
Alignment with 3 rows and 2 columns
GT Alpha
GT Beta
GT Gamma

然後將它們相加。

>>> combined = left + right
>>> print(combined)
Alignment with 3 rows and 7 columns
AAAACGT Alpha
AAA-CGT Beta
AAAAGGT Gamma

為了使此操作生效，兩個對齊結果必須具有相同數量的記錄（這裡它們都有 3 列）。

>>> len(left)
3
>>> len(right)
3
>>> len(combined)
3

個別列是 SeqRecord 物件，可以將它們相加。請參閱 SeqRecord 文件，以瞭解如何處理註釋。此範例是一個特殊情況，因為兩個原始對齊結果都具有相同的名稱，這表示當列被相加時，它們也會得到相同的名稱。

任何常見的註釋都會保留，但不同的註釋會遺失。這與 SeqRecord 註釋中使用的行為相同，旨在防止不適當值的意外傳播。

>>> combined.annotations
{'tool': 'demo'}

類似地，任何常見的每欄註釋都會合併。

>>> combined.column_annotations
{'stats': 'CCCXCCC'}
__getitem__(index)

存取對齊結果的一部分。

根據索引，您可以取得一個 SeqRecord 物件（表示單一列）、一個 Seq 物件（表示單一欄）、一個字串（表示單一字元）或另一個對齊結果（表示對齊結果的部分或全部）。

align[r,c] 會取得一個字元作為字串；align[r] 會取得一列作為 SeqRecord；align[r,:] 會取得一列作為 SeqRecord；align[:,c] 會取得一欄作為 Seq。

align[:] 和 align[:,:] 會取得對齊結果的副本。

任何其他方式都會取得一個子對齊結果，例如：align[0:2] 或 align[0:2,:] 僅使用列 0 和 1；align[:,1:3] 僅使用欄 1 和 2；align[0:2,1:3] 僅使用列 0 和 1，且僅使用欄 1 和 2。

我們將在此處使用以下範例對齊結果進行說明。

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> a = SeqRecord(Seq("AAAACGT"), id="Alpha")
>>> b = SeqRecord(Seq("AAA-CGT"), id="Beta")
>>> c = SeqRecord(Seq("AAAAGGT"), id="Gamma")
>>> d = SeqRecord(Seq("AAAACGT"), id="Delta")
>>> e = SeqRecord(Seq("AAA-GGT"), id="Epsilon")
>>> align = MultipleSeqAlignment([a, b, c, d, e])

您可以使用整數索引來存取對齊結果的一列作為 SeqRecord（在這裡，將對齊結果視為 SeqRecord 物件的列表）。

>>> first_record = align[0]
>>> print("%s %s" % (first_record.id, first_record.seq))
Alpha AAAACGT
>>> last_record = align[-1]
>>> print("%s %s" % (last_record.id, last_record.seq))
Epsilon AAA-GGT

您也可以使用 Python 的切片表示法來建立一個僅包含部分 SeqRecord 物件的子對齊結果。

>>> sub_alignment = align[2:5]
>>> print(sub_alignment)
Alignment with 3 rows and 7 columns
AAAAGGT Gamma
AAAACGT Delta
AAA-GGT Epsilon

這包括對 step 的支援，即 align[start:end:step]，可以用來選取每隔一個序列。

>>> sub_alignment = align[::2]
>>> print(sub_alignment)
Alignment with 3 rows and 7 columns
AAAACGT Alpha
AAAAGGT Gamma
AAA-GGT Epsilon

或者取得一個列反向的對齊結果副本。

>>> rev_alignment = align[::-1]
>>> print(rev_alignment)
Alignment with 5 rows and 7 columns
AAA-GGT Epsilon
AAAACGT Delta
AAAAGGT Gamma
AAA-CGT Beta
AAAACGT Alpha

您也可以使用兩個索引來同時指定列和欄。使用簡單的整數會得到一個字元字串。例如：

>>> align[3, 4]
'C'

這等效於：

>>> align[3][4]
'C'

或：

>>> align[3].seq[4]
'C'

若要取得單一欄（作為字串），請使用此語法。

>>> align[:, 4]
'CCGCG'

或者，取得欄的一部分：

>>> align[1:3, 4]
'CG'

然而，一般來說，您會取得一個子對齊結果。

>>> print(align[1:5, 3:6])
Alignment with 4 rows and 3 columns
-CG Beta
AGG Gamma
ACG Delta
-GG Epsilon

對於任何使用過 NumPy 陣列或矩陣物件的人來說，這一切都應該很熟悉。

__delitem__(index)

依索引刪除 SeqRecord，或依切片刪除多個 SeqRecord。

sort(key=None, reverse=False)

對對齊結果的列（SeqRecord 物件）進行原地排序。

這會預設使用 SeqRecord 物件 ID 依字母順序排序這些列。可以透過提供一個鍵函數來控制排序，該函數必須將每個 SeqRecord 對應到一個排序值。

如果您想新增兩個使用相同記錄識別符號但順序不同的對齊結果，這會很有用。例如：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> align1 = MultipleSeqAlignment([
...              SeqRecord(Seq("ACGT"), id="Human"),
...              SeqRecord(Seq("ACGG"), id="Mouse"),
...              SeqRecord(Seq("ACGC"), id="Chicken"),
...          ])
>>> align2 = MultipleSeqAlignment([
...              SeqRecord(Seq("CGGT"), id="Mouse"),
...              SeqRecord(Seq("CGTT"), id="Human"),
...              SeqRecord(Seq("CGCT"), id="Chicken"),
...          ])

如果您在沒有排序的情況下直接嘗試新增這些，您會得到這個。

>>> print(align1 + align2)
Alignment with 3 rows and 8 columns
ACGTCGGT <unknown id>
ACGGCGTT <unknown id>
ACGCCGCT Chicken

請參閱 SeqRecord 文件，其中說明了為什麼當識別符號之類的註釋不符時，您會取得預設值。但是，如果我們先對對齊結果進行排序，然後將它們相加，則會得到想要的結果。

>>> align1.sort()
>>> align2.sort()
>>> print(align1 + align2)
Alignment with 3 rows and 8 columns
ACGCCGCT Chicken
ACGTCGTT Human
ACGGCGGT Mouse

作為使用不同排序順序的範例，您可以依每個序列的 GC 含量進行排序。

>>> from Bio.SeqUtils import gc_fraction
>>> print(align1)
Alignment with 3 rows and 4 columns
ACGC Chicken
ACGT Human
ACGG Mouse
>>> align1.sort(key = lambda record: gc_fraction(record.seq))
>>> print(align1)
Alignment with 3 rows and 4 columns
ACGT Human
ACGC Chicken
ACGG Mouse

還有一個 reverse 引數，因此如果您想依 ID 但反向排序。

>>> align1.sort(reverse=True)
>>> print(align1)
Alignment with 3 rows and 4 columns
ACGG Mouse
ACGT Human
ACGC Chicken
property substitutions

回傳一個陣列，其中包含對齊結果中字母替換的次數。

例如，考慮三個 DNA 序列的多重序列對齊結果：

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import MultipleSeqAlignment
>>> seq1 = SeqRecord(Seq("ACGT"), id="seq1")
>>> seq2 = SeqRecord(Seq("A--A"), id="seq2")
>>> seq3 = SeqRecord(Seq("ACGT"), id="seq3")
>>> seq4 = SeqRecord(Seq("TTTC"), id="seq4")
>>> alignment = MultipleSeqAlignment([seq1, seq2, seq3, seq4])
>>> print(alignment)
Alignment with 4 rows and 4 columns
ACGT seq1
A--A seq2
ACGT seq3
TTTC seq4

>>> m = alignment.substitutions
>>> print(m)
    A   C   G   T
A 3.0 0.5 0.0 2.5
C 0.5 1.0 0.0 2.0
G 0.0 0.0 1.0 1.0
T 2.5 2.0 1.0 1.0

請注意，矩陣是對稱的，計數平均分配在對角線的兩側。例如，對齊結果中 A 和 T 之間的總替換次數為 3.5 + 3.5 = 7。

在計算替換矩陣時，會考慮與序列相關的任何權重。例如，給定以下多重序列對齊結果：

GTATC  0.5
AT--C  0.8
CTGTC  1.0

對於第一欄，我們有：

('A', 'G') : 0.5 * 0.8 = 0.4
('C', 'G') : 0.5 * 1.0 = 0.5
('A', 'C') : 0.8 * 1.0 = 0.8
property alignment

回傳基於 MultipleSeqAlignment 物件的 Alignment 物件。

這會複製每個 SeqRecord 與無間隙的序列。將來對 MultipleSeqAlignment 中原始記錄的任何變更都不會影響 Alignment 中新的記錄。

class Bio.Align.Alignment(sequences, coordinates=None)

基底類別：object

表示序列對齊結果。

Alignment 物件具有一個 .sequences 屬性，用於儲存已對齊的序列（Seq、MutableSeq、SeqRecord 或字串物件），以及一個 .coordinates 屬性，用於儲存將對齊定義為 NumPy 陣列的序列座標。

其他常用屬性（可能存在，也可能不存在）是：
  • annotations - 具有描述

    對齊結果的註釋的字典；

  • column_annotations - 具有描述對齊結果中每個

    欄的註釋的字典；

  • score - 對齊分數。

classmethod infer_coordinates(lines)

從列印的對齊結果推斷座標（已淘汰）。

此方法主要用於 Biopython 的對齊結果剖析器，但也可能適用於其他用途。

對於由 N 個序列組成的對齊結果，以 N 行列印，且具有相同數量的欄，其中間隙以破折號表示，此方法將計算定義對齊結果的序列座標。座標會以整數的 NumPy 陣列形式傳回，可用於建立 Alignment 物件。

這是三個序列 TAGGCATACGTG、AACGTACGT 和 ACGCATACTTG 的對齊結果範例，其中第二個和第三個序列中有間隙。

>>> from Bio.Align import Alignment
>>> lines = ["TAGGCATACGTG",
...          "AACG--TACGT-",
...          "-ACGCATACTTG",
...         ]
>>> sequences = [line.replace("-", "") for line in lines]
>>> sequences
['TAGGCATACGTG', 'AACGTACGT', 'ACGCATACTTG']
>>> coordinates = Alignment.infer_coordinates(lines)
>>> print(coordinates)
[[ 0  1  4  6 11 12]
 [ 0  1  4  4  9  9]
 [ 0  0  3  5 10 11]]
>>> alignment = Alignment(sequences, coordinates)
classmethod parse_printed_alignment(lines)

從列印的對齊結果推斷序列和座標。

此方法主要用於 Biopython 的對齊結果剖析器，但也可能適用於其他用途。

對於由 N 個序列組成的對齊結果，以 N 行列印，且具有相同數量的欄，其中間隙以破折號表示，此方法將計算定義對齊結果的序列座標。它會傳回一個元組 (sequences, coordinates)，其中 sequences 是移除間隙後的 N 個序列的列表，而 coordinates 是一個二維 NumPy 整數陣列。序列和座標可以一起用於建立 Alignment 物件。

這是三個序列 TAGGCATACGTG、AACGTACGT 和 ACGCATACTTG 的對齊結果範例，其中第二個和第三個序列中有間隙。請注意，輸入序列是位元組物件。

>>> from Bio.Align import Alignment
>>> from Bio.Seq import Seq
>>> lines = [b"TAGGCATACGTG",
...          b"AACG--TACGT-",
...          b"-ACGCATACTTG",
...         ]
>>> sequences, coordinates = Alignment.parse_printed_alignment(lines)
>>> sequences
[b'TAGGCATACGTG', b'AACGTACGT', b'ACGCATACTTG']
>>> print(coordinates)
[[ 0  1  4  6 11 12]
 [ 0  1  4  4  9  9]
 [ 0  0  3  5 10 11]]
>>> sequences = [Seq(sequence) for sequence in sequences]
>>> sequences
[Seq('TAGGCATACGTG'), Seq('AACGTACGT'), Seq('ACGCATACTTG')]
>>> alignment = Alignment(sequences, coordinates)
>>> print(alignment)
                  0 TAGGCATACGTG 12
                  0 AACG--TACGT-  9
                  0 -ACGCATACTTG 11
__init__(sequences, coordinates=None)

初始化新的 Alignment 物件。

參數
  • sequences - 已對齊的序列（Seq、MutableSeq、SeqRecord、

    或字串物件）的列表。

  • coordinates - 定義對齊結果的序列座標。

    如果為 None（預設值），則假設序列彼此對齊，且沒有任何間隙。

__array__(dtype=None)
__add__(other)

將兩個比對結果以逐列方式合併。

例如：

>>> import numpy as np
>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> from Bio.Align import Alignment
>>> a1 = SeqRecord(Seq("AAAAC"), id="Alpha")
>>> b1 = SeqRecord(Seq("AAAC"), id="Beta")
>>> c1 = SeqRecord(Seq("AAAAG"), id="Gamma")
>>> a2 = SeqRecord(Seq("GTT"), id="Alpha")
>>> b2 = SeqRecord(Seq("TT"), id="Beta")
>>> c2 = SeqRecord(Seq("GT"), id="Gamma")
>>> left = Alignment([a1, b1, c1],
...                  coordinates=np.array([[0, 3, 4, 5],
...                                        [0, 3, 3, 4],
...                                        [0, 3, 4, 5]]))
>>> left.annotations = {"tool": "demo", "name": "start"}
>>> left.column_annotations = {"stats": "CCCXC"}
>>> right = Alignment([a2, b2, c2],
...                   coordinates=np.array([[0, 1, 2, 3],
...                                         [0, 0, 1, 2],
...                                         [0, 1, 1, 2]]))
>>> right.annotations = {"tool": "demo", "name": "end"}
>>> right.column_annotations = {"stats": "CXC"}

現在，讓我們看看這兩個對齊結果。

>>> print(left)
Alpha             0 AAAAC 5
Beta              0 AAA-C 4
Gamma             0 AAAAG 5

>>> print(right)
Alpha             0 GTT 3
Beta              0 -TT 2
Gamma             0 G-T 2

然後將它們相加。

>>> combined = left + right
>>> print(combined)
Alpha             0 AAAACGTT 8
Beta              0 AAA-C-TT 6
Gamma             0 AAAAGG-T 7

為了使此操作生效，兩個比對結果必須具有相同的序列數量（在此範例中，它們都具有 3 列）。

>>> len(left)
3
>>> len(right)
3
>>> len(combined)
3

這些序列是 SeqRecord 物件，並且可以相加。有關註解處理方式的詳細資訊，請參閱 SeqRecord 文件。這個範例的特殊之處在於，兩個原始比對結果共享相同的名稱，這表示當列相加時，它們也會獲得相同的名稱。

任何共同的註解都會保留，但不同的註解會遺失。這與 SeqRecord 註解中使用的行為相同，旨在防止不適當的值意外傳播。

>>> combined.annotations
{'tool': 'demo'}

類似地，任何常見的每欄註釋都會合併。

>>> combined.column_annotations
{'stats': 'CCCXCCXC'}
property frequencies

傳回比對結果中每個欄位中每個字母的頻率。

間隙以破折號（“-”）字元表示。例如：

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> aligner.mode = "global"
>>> alignments = aligner.align("GACCTG", "CGATCG")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 -GACCT-G 6
                  0 -||--|-| 8
query             0 CGA--TCG 6

>>> alignment.frequencies
{'-': array([1., 0., 0., 1., 1., 0., 1., 0.]), 'G': array([0., 2., 0., 0., 0., 0., 0., 2.]), 'A': array([0., 0., 2., 0., 0., 0., 0., 0.]), 'C': array([1., 0., 0., 1., 1., 0., 1., 0.]), 'T': array([0., 0., 0., 0., 0., 2., 0., 0.])}
>>> aligner.mode = "local"
>>> alignments = aligner.align("GACCTG", "CGATCG")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 GACCT-G 6
                  0 ||--|-| 7
query             1 GA--TCG 6

>>> alignment.frequencies
{'G': array([2., 0., 0., 0., 0., 0., 2.]), 'A': array([0., 2., 0., 0., 0., 0., 0.]), 'C': array([0., 0., 1., 1., 0., 1., 0.]), 'T': array([0., 0., 0., 0., 2., 0., 0.]), '-': array([0., 0., 1., 1., 0., 1., 0.])}
property target

針對成對比對，傳回 self.sequences[0]。

property query

針對成對比對，傳回 self.sequences[1]。

__eq__(other)

檢查兩個 Alignment 物件是否指定相同的比對結果。

__ne__(other)

檢查兩個 Alignment 物件是否具有不同的比對結果。

__lt__(other)

檢查 self 是否應位於 other 之前。

__le__(other)

檢查 self 是否應位於 other 之前或與 other 相等。

__gt__(other)

檢查 self 是否應位於 other 之後。

__ge__(other)

檢查 self 是否應位於 other 之後或與 other 相等。

__getitem__(key)

傳回 self[key]。

索引形式如下

self[:, :]

傳回 Alignment 物件的副本；

self[:, i:] self[:, :j] self[:, i:j] self[:, iterable] (其中 iterable 傳回整數)

傳回一個新的 Alignment 物件，該物件跨越選取的欄位；

self[k, i] self[k, i:] self[k, :j] self[k, i:j] self[k, iterable] (其中 iterable 傳回整數) self[k]（相當於 self[k, :]）

傳回字串，其中包含選定欄位的對齊序列（包含間隙），其中 k = 0 代表目標序列，而 k = 1 代表查詢序列；以及

self[:, i]

傳回字串，其中包含比對結果中選取的欄位。

>>> from Bio.Align import PairwiseAligner
>>> aligner = PairwiseAligner()
>>> alignments = aligner.align("ACCGGTTT", "ACGGGTT")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 ACCGG-TTT 8
                  0 ||-||-||- 9
query             0 AC-GGGTT- 7

>>> alignment[0, :]
'ACCGG-TTT'
>>> alignment[1, :]
'AC-GGGTT-'
>>> alignment[0]
'ACCGG-TTT'
>>> alignment[1]
'AC-GGGTT-'
>>> alignment[0, 1:-2]
'CCGG-T'
>>> alignment[1, 1:-2]
'C-GGGT'
>>> alignment[0, (1, 5, 2)]
'C-C'
>>> alignment[1, ::2]
'A-GT-'
>>> alignment[1, range(0, 9, 2)]
'A-GT-'
>>> alignment[:, 0]
'AA'
>>> alignment[:, 5]
'-G'
>>> alignment[:, 1:]  
<Alignment object (2 rows x 8 columns) at 0x...>
>>> print(alignment[:, 1:])
target            1 CCGG-TTT 8
                  0 |-||-||- 8
query             1 C-GGGTT- 7

>>> print(alignment[:, 2:])
target            2 CGG-TTT 8
                  0 -||-||- 7
query             2 -GGGTT- 7

>>> print(alignment[:, 3:])
target            3 GG-TTT 8
                  0 ||-||- 6
query             2 GGGTT- 7

>>> print(alignment[:, 3:-1])
target            3 GG-TT 7
                  0 ||-|| 5
query             2 GGGTT 7

>>> print(alignment[:, ::2])
target            0 ACGTT 5
                  0 |-||- 5
query             0 A-GT- 3

>>> print(alignment[:, range(1, 9, 2)])
target            0 CG-T 3
                  0 ||-| 4
query             0 CGGT 4

>>> print(alignment[:, (2, 7, 3)])
target            0 CTG 3
                  0 -|| 3
query             0 -TG 2
__format__(format_spec)

以指定檔案格式傳回比對作為字串。

self.format() 的封裝函式。

format(fmt='', *args, **kwargs)

以指定檔案格式傳回比對作為字串。

參數
  • fmt - 檔案格式。可接受的值為空字串，

    以建立比對結果的人工可讀表示方式，或 Bio.Align 支援的任何比對檔案格式（某些格式尚未實作）。

所有其他引數都會傳遞至格式特定的寫入器函式。
  • mask - 僅限 PSL 格式。指定是否遮罩目標中的重複區域

    序列，並應在 PSL 檔案的 repMatches 欄位中回報，而不是在 matches 欄位中回報。可接受的值為 None：不遮罩（預設值）；「lower」：以小寫字元遮罩；「upper」：以大寫字元遮罩。

  • wildcard - 僅限 PSL 格式。在目標或查詢序列中，將與萬用字元的比對結果

    回報在 PSL 檔案的 nCount 欄位中，而不是在 matches、misMatches 或 repMatches 欄位中。預設值為 'N'。

  • md - 僅限 SAM 格式。若為 True，則從

    比對結果計算 MD 標記，並將其包含在輸出中。若為 False（預設值），則不會在輸出中包含 MD 標記。

__str__()

傳回比對結果的人工可讀字串表示方式。

針對序列比對，每一行最多有 80 個欄位。前 10 個欄位會顯示（可能會截斷的）序列名稱，這可能是 SeqRecord 的 id 屬性，否則成對比對的名稱為「target」或「query」。接下來的 10 個欄位會顯示序列座標，在 Python 中照常使用從零開始的計數。其餘 60 個欄位會顯示序列，並使用破折號表示間隙。在比對結果結尾，結束座標會顯示在序列的右側，同樣以從零開始的座標顯示。

成對比對在兩個序列之間有一行額外的行，顯示序列是否符合（'|'）或不符合（'。'），或者是否存在間隙（'-'）。此行顯示的座標是欄位索引，這在擷取子比對結果時會很有用。

例如：

>>> from Bio.Align import PairwiseAligner
>>> aligner = PairwiseAligner()

>>> seqA = "TTAACCCCATTTG"
>>> seqB = "AAGCCCCTTT"
>>> seqC = "AAAGGGGCTT"

>>> alignments = aligner.align(seqA, seqB)
>>> len(alignments)
1
>>> alignment = alignments[0]
>>> print(alignment)
target            0 TTAA-CCCCATTTG 13
                  0 --||-||||-|||- 14
query             0 --AAGCCCC-TTT- 10

請注意，seqC 是 seqB 的反向互補。將其與反向鏈比對會得出相同的比對結果，但查詢座標會切換

>>> alignments = aligner.align(seqA, seqC, strand="-")
>>> len(alignments)
1
>>> alignment = alignments[0]
>>> print(alignment)
target            0 TTAA-CCCCATTTG 13
                  0 --||-||||-|||- 14
query            10 --AAGCCCC-TTT-  0
__repr__()

傳回比對結果的表示方式，包含其形狀。

表示形式不能與 eval() 一起使用來重新建立物件，而這通常對於簡單的 Python 物件是可行的。例如：

<Alignment object (2 rows x 14 columns) at 0x10403d850>

十六進位字串是物件的記憶體位址，可用於區分不同的 Alignment 物件。如需詳細資訊，請參閱 help(id)。

>>> import numpy as np
>>> from Bio.Align import Alignment
>>> alignment = Alignment(("ACCGT", "ACGT"),
...                       coordinates = np.array([[0, 2, 3, 5],
...                                               [0, 2, 2, 4],
...                                              ]))
>>> print(alignment)
target            0 ACCGT 5
                  0 ||-|| 5
query             0 AC-GT 4

>>> alignment  
<Alignment object (2 rows x 5 columns) at 0x...>
__len__()

傳回比對中的序列數量。

property length

傳回比對結果長度，也就是列印時的欄位數。

比對結果長度是在列印時，比對結果中的欄位數，且等於符合數量、不符合數量以及目標和查詢中間隙總長度的總和。比對區段以外的序列區段不包含在欄位數中。

例如：

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> aligner.mode = "global"
>>> alignments = aligner.align("GACCTG", "CGATCG")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 -GACCT-G 6
                  0 -||--|-| 8
query             0 CGA--TCG 6

>>> alignment.length
8
>>> aligner.mode = "local"
>>> alignments = aligner.align("GACCTG", "CGATCG")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 GACCT-G 6
                  0 ||--|-| 7
query             1 GA--TCG 6

>>> len(alignment)
2
>>> alignment.length
7
property shape

以兩個整數值的元組形式傳回比對結果的形狀。

第一個整數值是比對結果中序列的數量，由 len(alignment) 傳回，對於成對比對，此值永遠為 2。

第二個整數值是在列印時，比對結果中的欄位數，且等於符合數量、不符合數量以及目標和查詢中間隙總長度的總和。比對區段以外的序列區段不包含在欄位數中。

例如：

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> aligner.mode = "global"
>>> alignments = aligner.align("GACCTG", "CGATCG")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 -GACCT-G 6
                  0 -||--|-| 8
query             0 CGA--TCG 6

>>> len(alignment)
2
>>> alignment.shape
(2, 8)
>>> aligner.mode = "local"
>>> alignments = aligner.align("GACCTG", "CGATCG")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 GACCT-G 6
                  0 ||--|-| 7
query             1 GA--TCG 6

>>> len(alignment)
2
>>> alignment.shape
(2, 7)
property aligned

傳回彼此對齊的子序列索引。

此屬性會傳回目標和查詢序列中，彼此對齊的子序列開始和結束索引。如果目標 (t) 和查詢 (q) 之間的比對由 N 個區塊組成，您會得到兩個長度為 N 的元組

(((t_start1, t_end1), (t_start2, t_end2), …, (t_startN, t_endN)),

((q_start1, q_end1), (q_start2, q_end2), …, (q_startN, q_endN)))

例如：

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> alignments = aligner.align("GAACT", "GAT")
>>> alignment = alignments[0]
>>> print(alignment)
target            0 GAACT 5
                  0 ||--| 5
query             0 GA--T 3

>>> alignment.aligned
array([[[0, 2],
        [4, 5]],

       [[0, 2],
        [2, 3]]])
>>> alignment = alignments[1]
>>> print(alignment)
target            0 GAACT 5
                  0 |-|-| 5
query             0 G-A-T 3

>>> alignment.aligned
array([[[0, 1],
        [2, 3],
        [4, 5]],

       [[0, 1],
        [1, 2],
        [2, 3]]])

請注意，不同的比對結果可能會讓相同的子序列彼此對齊。特別是，如果比對結果僅在間隙放置方面彼此不同，則可能會發生這種情況。

>>> aligner.mismatch_score = -10
>>> alignments = aligner.align("AAACAAA", "AAAGAAA")
>>> len(alignments)
2
>>> print(alignments[0])
target            0 AAAC-AAA 7
                  0 |||--||| 8
query             0 AAA-GAAA 7

>>> alignments[0].aligned
array([[[0, 3],
        [4, 7]],

       [[0, 3],
        [4, 7]]])
>>> print(alignments[1])
target            0 AAA-CAAA 7
                  0 |||--||| 8
query             0 AAAG-AAA 7

>>> alignments[1].aligned
array([[[0, 3],
        [4, 7]],

       [[0, 3],
        [4, 7]]])

此屬性可用於識別在對齊序列方面彼此相同的比對結果。

property indices

傳回比對結果中每個字母的序列索引。

此屬性會傳回 2D NumPy 陣列，其中包含比對結果中每個字母的序列索引。間隙以 -1 表示。此陣列具有與比對結果相同的列數和欄數，如 self.shape 所指定。

例如：

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> aligner.mode = "local"

>>> alignments = aligner.align("GAACTGG", "AATG")
>>> alignment = alignments[0]
>>> print(alignment)
target            1 AACTG 6
                  0 ||-|| 5
query             0 AA-TG 4

>>> alignment.indices
array([[ 1,  2,  3,  4,  5],
       [ 0,  1, -1,  2,  3]])
>>> alignment = alignments[1]
>>> print(alignment)
target            1 AACTGG 7
                  0 ||-|-| 6
query             0 AA-T-G 4

>>> alignment.indices
array([[ 1,  2,  3,  4,  5,  6],
       [ 0,  1, -1,  2, -1,  3]])

>>> alignments = aligner.align("GAACTGG", "CATT", strand="-")
>>> alignment = alignments[0]
>>> print(alignment)
target            1 AACTG 6
                  0 ||-|| 5
query             4 AA-TG 0

>>> alignment.indices
array([[ 1,  2,  3,  4,  5],
       [ 3,  2, -1,  1,  0]])
>>> alignment = alignments[1]
>>> print(alignment)
target            1 AACTGG 7
                  0 ||-|-| 6
query             4 AA-T-G 0

>>> alignment.indices
array([[ 1,  2,  3,  4,  5,  6],
       [ 3,  2, -1,  1, -1,  0]])
property inverse_indices

傳回每個序列中每個字母的比對欄位索引。

此屬性會回傳一個 1D NumPy 陣列的列表；陣列的數量等於對齊序列的數量，而每個陣列的長度等於對應序列的長度。對於每個序列中的每個字母，陣列包含對齊中的對應列索引。未包含在對齊中的字母會以 -1 表示。

例如：

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> aligner.mode = "local"

>>> alignments = aligner.align("GAACTGG", "AATG")
>>> alignment = alignments[0]
>>> print(alignment)
target            1 AACTG 6
                  0 ||-|| 5
query             0 AA-TG 4

>>> alignment.inverse_indices
[array([-1,  0,  1,  2,  3,  4, -1]), array([0, 1, 3, 4])]
>>> alignment = alignments[1]
>>> print(alignment)
target            1 AACTGG 7
                  0 ||-|-| 6
query             0 AA-T-G 4

>>> alignment.inverse_indices
[array([-1,  0,  1,  2,  3,  4,  5]), array([0, 1, 3, 5])]
>>> alignments = aligner.align("GAACTGG", "CATT", strand="-")
>>> alignment = alignments[0]
>>> print(alignment)
target            1 AACTG 6
                  0 ||-|| 5
query             4 AA-TG 0

>>> alignment.inverse_indices
[array([-1,  0,  1,  2,  3,  4, -1]), array([4, 3, 1, 0])]
>>> alignment = alignments[1]
>>> print(alignment)
target            1 AACTGG 7
                  0 ||-|-| 6
query             4 AA-T-G 0

>>> alignment.inverse_indices
[array([-1,  0,  1,  2,  3,  4,  5]), array([5, 3, 1, 0])]
sort(key=None, reverse=False)

就地排序對齊的序列。

預設情況下，如果可用，則使用其 id 屬性，否則使用其序列內容，按字母順序排序序列。例如，

>>> from Bio.Align import PairwiseAligner
>>> aligner = PairwiseAligner()
>>> aligner.gap_score = -1
>>> alignments = aligner.align("AATAA", "AAGAA")
>>> len(alignments)
1
>>> alignment = alignments[0]
>>> print(alignment)
target            0 AATAA 5
                  0 ||.|| 5
query             0 AAGAA 5

>>> alignment.sort()
>>> print(alignment)
target            0 AAGAA 5
                  0 ||.|| 5
query             0 AATAA 5

或者，可以提供一個鍵函數，將每個序列映射到一個排序值。例如，您可以根據每個序列的 GC 含量進行排序。

>>> from Bio.SeqUtils import gc_fraction
>>> alignment.sort(key=gc_fraction)
>>> print(alignment)
target            0 AATAA 5
                  0 ||.|| 5
query             0 AAGAA 5

您可以透過傳遞 reverse=True 來反轉排序順序

>>> alignment.sort(key=gc_fraction, reverse=True)
>>> print(alignment)
target            0 AAGAA 5
                  0 ||.|| 5
query             0 AATAA 5

現在序列會依遞減的 GC 含量值排序。

map(alignment)

將對齊映射到 self.target 並傳回產生的對齊。

在這裡，self.query 和 alignment.target 是相同的序列。

一個典型的例子是，self 是染色體和轉錄本之間的成對比對，參數是轉錄本和序列（例如，透過 RNA-seq 取得）之間的成對比對，而我們想要找到序列與染色體的比對

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> aligner.mode = 'local'
>>> aligner.open_gap_score = -1
>>> aligner.extend_gap_score = 0
>>> chromosome = "AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA"
>>> transcript = "CCCCCCCGGGGGG"
>>> alignments1 = aligner.align(chromosome, transcript)
>>> len(alignments1)
1
>>> alignment1 = alignments1[0]
>>> print(alignment1)
target            8 CCCCCCCAAAAAAAAAAAGGGGGG 32
                  0 |||||||-----------|||||| 24
query             0 CCCCCCC-----------GGGGGG 13

>>> sequence = "CCCCGGGG"
>>> alignments2 = aligner.align(transcript, sequence)
>>> len(alignments2)
1
>>> alignment2 = alignments2[0]
>>> print(alignment2)
target            3 CCCCGGGG 11
                  0 ||||||||  8
query             0 CCCCGGGG  8

>>> alignment = alignment1.map(alignment2)
>>> print(alignment)
target           11 CCCCAAAAAAAAAAAGGGG 30
                  0 ||||-----------|||| 19
query             0 CCCC-----------GGGG  8

>>> format(alignment, "psl")
'8\t0\t0\t0\t0\t0\t1\t11\t+\tquery\t8\t0\t8\ttarget\t40\t11\t30\t2\t4,4,\t0,4,\t11,26,\n'

映射對齊不取決於序列內容。如果我們刪除序列內容，則會在 PSL 格式中找到相同的對齊（儘管我們顯然會失去列印序列對齊的能力）

>>> alignment1.target = Seq(None, len(alignment1.target))
>>> alignment1.query = Seq(None, len(alignment1.query))
>>> alignment2.target = Seq(None, len(alignment2.target))
>>> alignment2.query = Seq(None, len(alignment2.query))
>>> alignment = alignment1.map(alignment2)
>>> format(alignment, "psl")
'8\t0\t0\t0\t0\t0\t1\t11\t+\tquery\t8\t0\t8\ttarget\t40\t11\t30\t2\t4,4,\t0,4,\t11,26,\n'

map 方法也可以用於提升不同基因組組裝之間的對齊。在這種情況下，self 是兩個基因組組裝之間的 DNA 對齊，而參數是轉錄本針對其中一個基因組組裝的比對

>>> np.set_printoptions(threshold=5)  # print 5 array elements per row
>>> chain = Align.read("Blat/panTro5ToPanTro6.over.chain", "chain")
>>> chain.sequences[0].id
'chr1'
>>> len(chain.sequences[0].seq)
228573443
>>> chain.sequences[1].id
'chr1'
>>> len(chain.sequences[1].seq)
224244399
>>> print(chain.coordinates)
[[122250000 122250400 122250400 ... 122909818 122909819 122909835]
 [111776384 111776784 111776785 ... 112019962 112019962 112019978]]

顯示黑猩猩基因組組裝 panTro5 上 chr1 的範圍 122250000:122909835 與黑猩猩基因組組裝 panTro6 上 chr1 的範圍 111776384:112019978 對齊。

>>> alignment = Align.read("Blat/est.panTro5.psl", "psl")
>>> alignment.sequences[0].id
'chr1'
>>> len(alignment.sequences[0].seq)
228573443
>>> alignment.sequences[1].id
'DC525629'
>>> len(alignment.sequences[1].seq)
407
>>> print(alignment.coordinates)
[[122835789 122835847 122840993 122841145 122907212 122907314]
 [       32        90        90       242       242       344]]

這顯示表達序列標籤 DC525629 的核苷酸範圍 32:344 與黑猩猩基因組組裝 panTro5 上 chr1 的範圍 122835789:122907314 對齊。

請注意，目標序列鏈 chain.sequences[0].seq 和目標序列 alignment.sequences[0] 的長度相同

>>> len(chain.sequences[0].seq) == len(alignment.sequences[0].seq)
True

我們交換鏈的目標和查詢，使得鏈的查詢對應於比對的目標

>>> chain = chain[::-1]
>>> chain.sequences[0].id
'chr1'
>>> len(chain.sequences[0].seq)
224244399
>>> chain.sequences[1].id
'chr1'
>>> len(chain.sequences[1].seq)
228573443
>>> print(chain.coordinates)
[[111776384 111776784 111776785 ... 112019962 112019962 112019978]
 [122250000 122250400 122250400 ... 122909818 122909819 122909835]]

現在，我們可以透過在鏈上呼叫 map，並將 alignment 作為引數，來取得 DC525629 針對黑猩猩基因組組裝 panTro6 的座標

>>> lifted_alignment = chain.map(alignment)
>>> lifted_alignment.sequences[0].id
'chr1'
>>> len(lifted_alignment.sequences[0].seq)
224244399
>>> lifted_alignment.sequences[1].id
'DC525629'
>>> len(lifted_alignment.sequences[1].seq)
407
>>> print(lifted_alignment.coordinates)
[[111982717 111982775 111987921 111988073 112009200 112009302]
 [       32        90        90       242       242       344]]

這顯示表達序列標籤 DC525629 的核苷酸範圍 32:344 與黑猩猩基因組組裝 panTro6 上 chr1 的範圍 111982717:112009302 對齊。請注意，DC525629 在黑猩猩基因組組裝 panTro5 上的基因組跨度為 122907314 - 122835789 = 71525 bp，而在 panTro6 上，基因組跨度為 112009302 - 111982717 = 26585 bp。

mapall(alignments)

將每個對齊映射到 self，並傳回映射的對齊。

property substitutions

回傳一個陣列，其中包含對齊結果中字母替換的次數。

作為一個範例，考慮兩個 RNA 序列的序列對齊

>>> from Bio.Align import PairwiseAligner
>>> target = "ATACTTACCTGGCAGGGGAGATACCATGATCACGAAGGTGGTTTTCCCAGGGCGAGGCTTATCCATTGCACTCCGGATGTGCTGACCCCTGCGATTTCCCCAAATGTGGGAAACTCGACTGCATAATTTGTGGTAGTGGGGGACTGCGTTCGCGCTTTCCCCTG"  # human spliceosomal small nuclear RNA U1
>>> query = "ATACTTACCTGACAGGGGAGGCACCATGATCACACAGGTGGTCCTCCCAGGGCGAGGCTCTTCCATTGCACTGCGGGAGGGTTGACCCCTGCGATTTCCCCAAATGTGGGAAACTCGACTGTATAATTTGTGGTAGTGGGGGACTGCGTTCGCGCTATCCCCCG"  # sea lamprey spliceosomal small RNA U1
>>> aligner = PairwiseAligner()
>>> aligner.gap_score = -10
>>> alignments = aligner.align(target, query)
>>> len(alignments)
1
>>> alignment = alignments[0]
>>> print(alignment)
target            0 ATACTTACCTGGCAGGGGAGATACCATGATCACGAAGGTGGTTTTCCCAGGGCGAGGCTT
                  0 |||||||||||.||||||||..|||||||||||..|||||||..|||||||||||||||.
query             0 ATACTTACCTGACAGGGGAGGCACCATGATCACACAGGTGGTCCTCCCAGGGCGAGGCTC

target           60 ATCCATTGCACTCCGGATGTGCTGACCCCTGCGATTTCCCCAAATGTGGGAAACTCGACT
                 60 .|||||||||||.|||..|.|.||||||||||||||||||||||||||||||||||||||
query            60 TTCCATTGCACTGCGGGAGGGTTGACCCCTGCGATTTCCCCAAATGTGGGAAACTCGACT

target          120 GCATAATTTGTGGTAGTGGGGGACTGCGTTCGCGCTTTCCCCTG 164
                120 |.||||||||||||||||||||||||||||||||||.|||||.| 164
query           120 GTATAATTTGTGGTAGTGGGGGACTGCGTTCGCGCTATCCCCCG 164

>>> m = alignment.substitutions
>>> print(m)
     A    C    G    T
A 28.0  1.0  2.0  1.0
C  0.0 39.0  1.0  2.0
G  2.0  0.0 45.0  0.0
T  2.0  5.0  1.0 35.0

請注意，矩陣不是對稱的：行對應於目標序列，列對應於查詢序列。例如，目標序列中與查詢序列中的 C 對齊的 T 的數量為

>>> m['T', 'C']
5.0

而查詢序列中與查詢序列中的 T 對齊的 C 的數量為

>>> m['C', 'T']
2.0

對於某些應用（例如，從替換矩陣定義評分矩陣），可能偏好對稱矩陣，這可以計算如下

>>> m += m.transpose()
>>> m /= 2.0
>>> print(m)
     A    C    G    T
A 28.0  0.5  2.0  1.5
C  0.5 39.0  0.5  3.5
G  2.0  0.5 45.0  0.5
T  1.5  3.5  0.5 35.0

現在矩陣是對稱的，計數在對角線的兩側平均分配

>>> m['C', 'T']
3.5
>>> m['T', 'C']
3.5

對齊中 T 和 C 之間的替換總數為 3.5 + 3.5 = 7。

counts()

傳回成對比對的識別、不匹配和間隙數。

>>> aligner = PairwiseAligner(mode='global', match_score=2, mismatch_score=-1)
>>> for alignment in aligner.align("TACCG", "ACG"):
...     print("Score = %.1f:" % alignment.score)
...     c = alignment.counts()  # namedtuple
...     print(f"{c.gaps} gaps, {c.identities} identities, {c.mismatches} mismatches")
...     print(alignment)
...
Score = 6.0:
2 gaps, 3 identities, 0 mismatches
target            0 TACCG 5
                  0 -||-| 5
query             0 -AC-G 3

Score = 6.0:
2 gaps, 3 identities, 0 mismatches
target            0 TACCG 5
                  0 -|-|| 5
query             0 -A-CG 3

這會將成對比對中的每對字母分類為間隙、完全匹配或不匹配。它被定義為一個方法（而非屬性），以便將來可以採用可選的引數，以允許自訂行為。這三個值會以具名元組的形式傳回。這是針對對齊中的所有序列對計算的。

reverse_complement()

反向互補對齊並傳回它。

>>> sequences = ["ATCG", "AAG", "ATC"]
>>> coordinates = np.array([[0, 2, 3, 4], [0, 2, 2, 3], [0, 2, 3, 3]])
>>> alignment = Alignment(sequences, coordinates)
>>> print(alignment)
                  0 ATCG 4
                  0 AA-G 3
                  0 ATC- 3

>>> rc_alignment = alignment.reverse_complement()
>>> print(rc_alignment)
                  0 CGAT 4
                  0 C-TT 3
                  0 -GAT 3

如果存在屬性 column_annotations，則會將其與反向互補的對齊相關聯，其值會反向排列。

>>> alignment.column_annotations = {"score": [3, 2, 2, 2]}
>>> rc_alignment = alignment.reverse_complement()
>>> print(rc_alignment.column_annotations)
{'score': [2, 2, 2, 3]}
__hash__ = None
class Bio.Align.AlignmentsAbstractBaseClass

基礎：ABC

序列對齊的抽象基礎類別。

大多數使用者不需要使用此類別。它在內部用作類別列表的 Alignments 類別以及 Bio.Align.interfaces 中的 AlignmentIterator 類別的基底類別，後者本身是 Bio/Align/ 中對齊剖析器的抽象基底類別。

__iter__()

以 Alignment 物件的形式疊代對齊。

任何子類別都「不應該」覆寫此方法。

abstract __next__()

傳回下一個對齊。

abstract rewind()

倒轉疊代器，使其從頭開始循環遍歷對齊。

abstract __len__()

傳回對齊的數量。

__abstractmethods__ = frozenset({'__len__', '__next__', 'rewind'})
class Bio.Align.Alignments(alignments=())

基礎：AlignmentsAbstractBaseClass、list

__init__(alignments=())
__next__()

傳回下一個對齊。

rewind()

倒轉疊代器，使其從頭開始循環遍歷對齊。

__len__()

傳回對齊的數量。

__abstractmethods__ = frozenset({})
class Bio.Align.PairwiseAlignments(seqA, seqB, score, paths)

基礎：AlignmentsAbstractBaseClass

實作成對比對器傳回的成對比對的疊代器。

此類別也支援索引，這對於增加的索引來說很快，但對於大量對齊的隨機存取來說可能很慢。

請注意，即使對於相對較短的序列，如果它們彼此對齊不良，成對比對器也可以傳回天文數字的對齊。因此，我們建議先檢查對齊的數量，該數量可以透過 len(alignments) 存取，即使對齊的數量非常大，也可以快速計算出來。

__init__(seqA, seqB, score, paths)

初始化新的 PairwiseAlignments 物件。

參數

  • seqA - 第一個序列，以純字串形式表示，沒有間隙。

  • seqB - 第二個序列，以純字串形式表示，沒有間隙。

  • score - 對齊分數。

  • paths - 對回溯矩陣中路徑的疊代器；

    每條路徑定義一個對齊。

您通常會透過呼叫 aligner.align(seqA, seqB) 來取得 PairwiseAlignments 物件，其中 aligner 是 PairwiseAligner 物件或 CodonAligner 物件。

__len__()

傳回對齊的數量。

__getitem__(index)
__next__()

傳回下一個對齊。

rewind()

倒轉疊代器，使其從頭開始循環遍歷對齊。

__abstractmethods__ = frozenset({})
class Bio.Align.PairwiseAligner(scoring=None, **kwargs)

基礎類別：PairwiseAligner

使用動態規劃執行成對序列比對。

這提供了在兩個序列之間取得全域和局部比對的功能。全域比對找出兩個序列中所有字元的最佳一致性。局部比對僅找出最佳比對的子序列。

要執行成對序列比對，首先要建立一個 PairwiseAligner 物件。此物件會儲存比對和不比對的分數，以及間隙分數。通常，比對分數是正數，而不比對分數和間隙分數是負數或零。預設情況下，比對分數為 1，而不比對分數和間隙分數為零。根據間隙分數的值，PairwiseAligner 物件會自動選擇適當的比對演算法（Needleman-Wunsch、Smith-Waterman、Gotoh 或 Waterman-Smith-Beyer 全域或局部比對演算法）。

使用兩個序列作為引數呼叫比對器的 “score” 方法將計算兩個序列之間的比對分數。使用兩個序列作為引數呼叫比對器的 “align” 方法將會傳回一個產生器，產生兩個序列之間的比對結果。

一些範例

>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> alignments = aligner.align("TACCG", "ACG")
>>> for alignment in sorted(alignments):
...     print("Score = %.1f:" % alignment.score)
...     print(alignment)
...
Score = 3.0:
target            0 TACCG 5
                  0 -|-|| 5
query             0 -A-CG 3

Score = 3.0:
target            0 TACCG 5
                  0 -||-| 5
query             0 -AC-G 3

將比對器模式指定為局部以產生局部比對

>>> aligner.mode = 'local'
>>> alignments = aligner.align("TACCG", "ACG")
>>> for alignment in sorted(alignments):
...     print("Score = %.1f:" % alignment.score)
...     print(alignment)
...
Score = 3.0:
target            1 ACCG 5
                  0 |-|| 4
query             0 A-CG 3

Score = 3.0:
target            1 ACCG 5
                  0 ||-| 4
query             0 AC-G 3

執行全域比對。相同字元給予 2 分，每個不相同字元扣 1 分。

>>> aligner.mode = 'global'
>>> aligner.match_score = 2
>>> aligner.mismatch_score = -1
>>> for alignment in aligner.align("TACCG", "ACG"):
...     print("Score = %.1f:" % alignment.score)
...     print(alignment)
...
Score = 6.0:
target            0 TACCG 5
                  0 -||-| 5
query             0 -AC-G 3

Score = 6.0:
target            0 TACCG 5
                  0 -|-|| 5
query             0 -A-CG 3

與上述相同，但現在開啟間隙時扣 0.5 分，延伸間隙時扣 0.1 分。

>>> aligner.open_gap_score = -0.5
>>> aligner.extend_gap_score = -0.1
>>> aligner.target_end_gap_score = 0.0
>>> aligner.query_end_gap_score = 0.0
>>> for alignment in aligner.align("TACCG", "ACG"):
...     print("Score = %.1f:" % alignment.score)
...     print(alignment)
...
Score = 5.5:
target            0 TACCG 5
                  0 -|-|| 5
query             0 -A-CG 3

Score = 5.5:
target            0 TACCG 5
                  0 -||-| 5
query             0 -AC-G 3

比對函式也可以使用 Biopython 中已包含的已知矩陣

>>> from Bio.Align import substitution_matrices
>>> aligner = Align.PairwiseAligner()
>>> aligner.substitution_matrix = substitution_matrices.load("BLOSUM62")
>>> alignments = aligner.align("KEVLA", "EVL")
>>> alignments = list(alignments)
>>> print("Number of alignments: %d" % len(alignments))
Number of alignments: 1
>>> alignment = alignments[0]
>>> print("Score = %.1f" % alignment.score)
Score = 13.0
>>> print(alignment)
target            0 KEVLA 5
                  0 -|||- 5
query             0 -EVL- 3

您也可以在建構 PairwiseAligner 物件時，透過將屬性作為關鍵字引數提供，來直接設定屬性的值

>>> aligner = Align.PairwiseAligner(mode='global', match_score=2, mismatch_score=-1)
>>> for alignment in aligner.align("TACCG", "ACG"):
...     print("Score = %.1f:" % alignment.score)
...     print(alignment)
...
Score = 6.0:
target            0 TACCG 5
                  0 -||-| 5
query             0 -AC-G 3

Score = 6.0:
target            0 TACCG 5
                  0 -|-|| 5
query             0 -A-CG 3
__init__(scoring=None, **kwargs)

依照關鍵字引數指定的內容初始化 PairwiseAligner。

如果 scoring 為 None，則使用預設評分方案，比對 = 1.0，不比對 = 0.0，間隙分數 = 0.0。如果 scoring 為 “blastn”、“megablast” 或 “blastp”，則分別使用 BLASTN、MEGABLAST 或 BLASTP 的預設取代矩陣和間隙分數。

迴圈處理剩餘的關鍵字引數，並將它們設定為物件的屬性。

__setattr__(key, value)

實作 setattr(self, name, value)。

align(seqA, seqB, strand='+')

使用 PairwiseAligner 傳回兩個序列的比對結果。

score(seqA, seqB, strand='+')

使用 PairwiseAligner 傳回兩個序列的比對分數。

__getstate__()
__setstate__(state)
class Bio.Align.CodonAligner(codon_table=None, anchor_len=10)

基礎類別：CodonAligner

將核苷酸序列比對到胺基酸序列。

此類別實作動態規劃演算法，將核苷酸序列比對到胺基酸序列。

__init__(codon_table=None, anchor_len=10)

為特定的遺傳密碼初始化 CodonAligner。

參數

  • codon_table - 代表遺傳密碼的 CodonTable 物件。如果 codon_table 為 None，則使用標準遺傳密碼。

score(seqA, seqB)

傳回蛋白質序列和核苷酸序列的比對分數。

參數

  • seqA - 胺基酸的蛋白質序列（純字串、Seq、MutableSeq 或 SeqRecord）。

  • seqB - 核苷酸序列（純字串、Seq、MutableSeq 或 SeqRecord）；接受 DNA 和 RNA 序列。

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> aligner = CodonAligner()
>>> dna = SeqRecord(Seq('ATGTCTCGT'), id='dna')
>>> pro = SeqRecord(Seq('MSR'), id='pro')
>>> score = aligner.score(pro, dna)
>>> print(score)
3.0
>>> rna = SeqRecord(Seq('AUGUCUCGU'), id='rna')
>>> score = aligner.score(pro, rna)
>>> print(score)
3.0

這是一個 DNA 序列中發生讀碼框架移位的範例

>>> dna = "ATGCTGGGCTCGAACGAGTCCGTGTATGCCCTAAGCTGAGCCCGTCG"
>>> pro = "MLGSNESRVCPKLSPS"
>>> len(pro)
16
>>> aligner.frameshift_score = -3.0
>>> score = aligner.score(pro, dna)
>>> print(score)
13.0

在以下範例中，讀碼框架移位的位置不明確

>>> dna = 'TTTAAAAAAAAAAATTT'
>>> pro = 'FKKKKF'
>>> len(pro)
6
>>> aligner.frameshift_score = -1.0
>>> alignments = aligner.align(pro, dna)
>>> print(alignments.score)
5.0
>>> len(alignments)
3
>>> print(next(alignments))
target            0 F  K  K  K   4
query             0 TTTAAAAAAAAA 12

target            4 K  F    6
query            11 AAATTT 17

>>> print(next(alignments))
target            0 F  K  K   3
query             0 TTTAAAAAA 9

target            3 K  K  F    6
query             8 AAAAAATTT 17

>>> print(next(alignments))
target            0 F  K   2
query             0 TTTAAA 6

target            2 K  K  K  F    6
query             5 AAAAAAAAATTT 17

>>> print(next(alignments))
Traceback (most recent call last):
...
StopIteration
align(seqA, seqB)

將核苷酸序列比對到其對應的蛋白質序列。

參數

  • seqA - 胺基酸的蛋白質序列（純字串、Seq、MutableSeq 或 SeqRecord）。

  • seqB - 核苷酸序列（純字串、Seq、MutableSeq 或 SeqRecord）；接受 DNA 和 RNA 序列。

傳回 Alignment 物件的迭代器。

>>> from Bio.Seq import Seq
>>> from Bio.SeqRecord import SeqRecord
>>> aligner = CodonAligner()
>>> dna = SeqRecord(Seq('ATGTCTCGT'), id='dna')
>>> pro = SeqRecord(Seq('MSR'), id='pro')
>>> alignments = aligner.align(pro, dna)
>>> alignment = alignments[0]
>>> print(alignment)
pro               0 M  S  R   3
dna               0 ATGTCTCGT 9

>>> rna = SeqRecord(Seq('AUGUCUCGU'), id='rna')
>>> alignments = aligner.align(pro, rna)
>>> alignment = alignments[0]
>>> print(alignment)
pro               0 M  S  R   3
rna               0 AUGUCUCGU 9

這是一個 DNA 序列中發生讀碼框架移位的範例

>>> dna = "ATGCTGGGCTCGAACGAGTCCGTGTATGCCCTAAGCTGAGCCCGTCG"
>>> pro = "MLGSNESRVCPKLSPS"
>>> alignments = aligner.align(pro, dna)
>>> alignment = alignments[0]
>>> print(alignment)
target            0 M  L  G  S  N  E  S   7
query             0 ATGCTGGGCTCGAACGAGTCC 21

target            7 R  V  C  P  K  L  S  P  S   16
query            20 CGTGTATGCCCTAAGCTGAGCCCGTCG 47
Bio.Align.write(alignments, target, fmt, *args, **kwargs)

將比對結果寫入檔案。

參數

  • alignments - Alignments 物件、Alignment 物件的迭代器或單一 Alignment。

  • target - 要寫入的檔案或類檔案物件，或是檔案名稱字串。

  • fmt - 描述檔案格式的字串（不區分大小寫）。

請注意，如果提供檔案或類檔案物件，您的程式碼應在呼叫此函式後關閉 target，或呼叫 .flush()，以確保資料寫入磁碟。

傳回寫入的比對結果數（以整數表示）。

Bio.Align.parse(source, fmt)

剖析比對檔案並傳回比對結果的迭代器。

參數

  • source - 要從中讀取的檔案或類檔案物件，或是檔案名稱字串。

  • fmt - 描述檔案格式的字串（不區分大小寫）。

典型用法，開啟檔案以讀取，並迴圈處理比對結果

>>> from Bio import Align
>>> filename = "Exonerate/exn_22_m_ner_cigar.exn"
>>> for alignment in Align.parse(filename, "exonerate"):
...    print("Number of sequences in alignment", len(alignment))
...    print("Alignment score:", alignment.score)
Number of sequences in alignment 2
Alignment score: 6150.0
Number of sequences in alignment 2
Alignment score: 502.0
Number of sequences in alignment 2
Alignment score: 440.0

對於諸如 bigMaf 之類的延遲載入檔案格式，僅在需要時才讀取檔案內容，請確保在擷取比對資料時檔案保持開啟狀態。

當檔案只包含一個比對結果時，可以使用 Bio.Align.read(…) 函式。

Bio.Align.read(handle, fmt)

剖析包含一個比對結果的檔案，並傳回該比對結果。

參數

  • source - 要從中讀取的檔案或類檔案物件，或是檔案名稱字串。

  • fmt - 描述檔案格式的字串（不區分大小寫）。

此函式用於剖析僅包含一個比對結果的比對檔案。例如，讀取 Clustal 檔案

>>> from Bio import Align
>>> alignment = Align.read("Clustalw/opuntia.aln", "clustal")
>>> print("Alignment shape:", alignment.shape)
Alignment shape: (7, 156)
>>> for sequence in alignment.sequences:
...     print(sequence.id, len(sequence))
gi|6273285|gb|AF191659.1|AF191 146
gi|6273284|gb|AF191658.1|AF191 148
gi|6273287|gb|AF191661.1|AF191 146
gi|6273286|gb|AF191660.1|AF191 146
gi|6273290|gb|AF191664.1|AF191 150
gi|6273289|gb|AF191663.1|AF191 150
gi|6273291|gb|AF191665.1|AF191 156

如果檔案包含零個記錄或多個記錄，則會引發例外狀況。例如

>>> from Bio import Align
>>> filename = "Exonerate/exn_22_m_ner_cigar.exn"
>>> alignment = Align.read(filename, "exonerate")
Traceback (most recent call last):
    ...
ValueError: More than one alignment found in file

如果要讀取包含多個比對結果的檔案，請使用 Bio.Align.parse 函式。