Bio.Align包

子包

子模块

模块内容

用于处理序列比对的代码。

本模块中最重要的内容之一是MultipleSeqAlignment类，它在Bio.AlignIO模块中使用。

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

注意-此对象替换了模块Bio.Align.Generic中定义的较旧的对齐对象，但不能完全向后兼容。

注-本发明不试图对具有比比对短得多的多个测序读数的下一代测序中使用的类型的比对进行建模，并且通常存在具有特殊状态的共识或参考序列。

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

初始化新的MultipleSeqAlignment对象。

参数：
  • 记录-SeqRecord对象的列表(或迭代器)，其

    序列都是相同长度的。这可能是一个空列表。

  • 字母表-仅用于向后兼容；其值应始终

    什么都不做。

  • 注释-有关整个路线的信息(词典)。

  • COLUMN_ANNOTIONS-每列注释(受限字典)。

    它保存长度与列数匹配的Python序列(列表、字符串、元组)。典型的用途将是二级结构共识串。

通常使用Bio.AlignIO从文件加载MSA，但也可以从SeqRecord对象列表加载MSA：

>>> 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实例(2条长度为14的记录)位于a3c184c>

祸不单行字符串是对象的内存地址，参见help(Id)。这提供了一种直观区分相同大小的路线的简单方法。

__format__(format_spec)

以指定文件格式的字符串形式返回对齐。

格式应为Bio.AlignIO支持作为输出格式的小写字符串(如“Fasta”、“clustal”、“Phylip”、“斯德哥尔摩”等)，用于将对齐转换为字符串。

例如：

>>> 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.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_aligence_length()获取最长序列的长度(即列数)。

如果您认为对齐方式类似于SeqRecord对象的列表，则很容易记住这一点。

get_alignment_length()

返回对齐的最大长度。

路线中的所有对象应该(希望)具有相同的长度。此函数将通过查找比对中序列的最大长度来遍历并找到此长度。

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

因为Align对象允许作为SeqRecords在行上迭代，所以您可以对第二个比对使用Extended方法(假设其序列与原始比对具有相同的长度)。

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)，则有两种方式可以考虑添加它们-按行或按列。使用Extended方法按行添加。使用加法运算符Add by Column。例如,

>>> 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对象(表示单列)、字符串(表示单个字符)或另一个对齐(表示部分或全部对齐)。

对齐 [r,c] 将单个字符作为字符串对齐 [r] 将行指定为SeqRecord对齐 [r,:] 将行指定为SeqRecord对齐 [:,c] 将列指定为序列

对齐 [:] 并对齐 [:,:] 提供一份路线复印件

任何其他选项都会给出子对齐，例如对齐 [0:2] 或对齐 [0：2，：] 仅使用行0和1对齐 [：，1：3] 仅使用列1和列2对齐 [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

这包括对步骤的支持，即对齐 [开始：结束：步骤] ，可用于选择每隔一秒的序列：

>>> 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数组或矩阵对象的人都应该对此很熟悉。

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
>>> print(align1)
Alignment with 3 rows and 4 columns
ACGC Chicken
ACGT Human
ACGG Mouse
>>> align1.sort(key = lambda record: GC(record.seq))
>>> print(align1)
Alignment with 3 rows and 4 columns
ACGT Human
ACGC Chicken
ACGG Mouse

还有一个相反的参数，所以如果您想要按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
class Bio.Align.PairwiseAlignment(target, query, path, score)

基类：object

表示成对序列比对。

在内部，将成对对齐存储为通过回溯矩阵的路径，即对应于回溯矩阵中的路径顶点的索引对的元组。

__init__(target, query, path, score)

初始化新的PairwiseAlignment对象。

参数：

  • 目标-第一个序列，作为纯字符串，没有间隙。

  • 查询-第二个序列，作为纯字符串，没有空格。

  • 路径-通过回溯矩阵的路径，定义

    对齐。

  • 分数-对齐分数。

通常情况下，您可以通过迭代PairwiseAlignments对象来获得PairwiseAlignment对象。

__eq__(other)

返回self==value。

__ne__(other)

返回SELF！=值。

__lt__(other)

返回self<value。

__le__(other)

返回self<=value。

__gt__(other)

返回self>value。

__ge__(other)

返回self>=value。

__getitem__(key)

回归自我 [key] 。

目前，这仅针对表单的索引实现

自我 [:, :]

它返回PairwiseAlignation对象的副本，并且

自我 [：，我：] 自我 [：，：J] 自我 [：，i：j]

它返回一个跨越指示列的新PairwiseAlignment对象。

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

>>> alignment[:, 1:]  
<Bio.Align.PairwiseAlignment object at ...>
>>> print(alignment[:, 1:])
ACCGG-TTT
 |-||-||-
AC-GGGTT-

>>> print(alignment[:, 2:])
ACCGG-TTT
  -||-||-
AC-GGGTT-

>>> print(alignment[:, 3:])
ACCGG-TTT
   ||-||-
 ACGGGTT-

>>> print(alignment[:, 3:-1])
ACCGG-TTT
   ||-||
 ACGGGTT
__format__(format_spec)

默认对象格式化程序。

format(fmt='', **kwargs)

以指定文件格式的字符串形式返回对齐。

参数：
  • FMT-文件格式。可接受的值为
    “”创建人类可读的

    对齐(默认)；

    “bed”：在中创建一条表示路线的线

    浏览器可扩展数据(BED)文件格式；

    “PSL”：在中创建表示路线的线

    BLAT生成的图形空间布局(PSL)文件格式；

    “SAM”：在中创建表示路线的直线

    序列比对/图谱(SAM)格式。

  • 掩码-仅限PSL格式。指定是否在目标中重复区域

    序列被屏蔽，并且应该在 repMatches 字段，而不是在 matches 田野。可接受的值为None：无掩码(默认)；“LOWER”：小写字符掩码；“UPPER”：大写字符掩码。

  • 通配符-仅限PSL格式。将路线报告为通配符

    中的目标或查询序列中的字符 nCount 字段，而不是在 matches ， misMatches ，或 repMatches 菲尔兹。默认值为“N”。

__str__()

返回str(Self)。

__len__()

返回比对中的序列数，始终为2。

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)
-GACCT-G
-||--|-|
CGA--TCG

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

>>> 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)
GAACT
||--|
GA--T

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

>>> alignment.aligned
(((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])
AAAC-AAA
|||--|||
AAA-GAAA

>>> alignments[0].aligned
(((0, 3), (4, 7)), ((0, 3), (4, 7)))
>>> print(alignments[1])
AAA-CAAA
|||--|||
AAAG-AAA

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

该属性可用于识别就其比对序列而言彼此相同的比对。

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)
AATAA
||.||
AAGAA

>>> alignment.sort()
>>> print(alignment)
AAGAA
||.||
AATAA

或者，可以提供将每个序列映射到排序值的键函数。例如，您可以对每个序列的GC内容进行排序。

>>> from Bio.SeqUtils import GC
>>> alignment.sort(key=GC)
>>> print(alignment)
AATAA
||.||
AAGAA

您可以通过传递以下参数来颠倒排序顺序 reverse=True ：

>>> alignment.sort(key=GC, reverse=True)
>>> print(alignment)
AAGAA
||.||
AATAA

现在通过递减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)
AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA
        |||||||-----------||||||
        CCCCCCC-----------GGGGGG

>>> sequence = "CCCCGGGG"
>>> alignments2 = aligner.align(transcript, sequence)
>>> len(alignments2)
1
>>> alignment2 = alignments2[0]
>>> print(alignment2)
CCCCCCCGGGGGG
   ||||||||
   CCCCGGGG

>>> alignment = alignment1.map(alignment2)
>>> print(alignment)
AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA
           ||||-----------||||
           CCCC-----------GGGG

>>> 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'
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)
ATACTTACCTGGCAGGGGAGATACCATGATCACGAAGGTGGTTTTCCCAGGGCGAGGCTTATCCATTGCACTCCGGATGTGCTGACCCCTGCGATTTCCCCAAATGTGGGAAACTCGACTGCATAATTTGTGGTAGTGGGGGACTGCGTTCGCGCTTTCCCCTG
|||||||||||.||||||||..|||||||||||..|||||||..|||||||||||||||..|||||||||||.|||..|.|.|||||||||||||||||||||||||||||||||||||||.||||||||||||||||||||||||||||||||||.|||||.|
ATACTTACCTGACAGGGGAGGCACCATGATCACACAGGTGGTCCTCCCAGGGCGAGGCTCTTCCATTGCACTGCGGGAGGGTTGACCCCTGCGATTTCCCCAAATGTGGGAAACTCGACTGTATAATTTGTGGTAGTGGGGGACTGCGTTCGCGCTATCCCCCG

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

并且查询序列TAT中与查询序列中的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。

__hash__ = None
class Bio.Align.PairwiseAlignments(seqA, seqB, score, paths)

基类：object

在对齐器返回的成对对齐上实现迭代器。

该类还支持索引，这对于增加索引很快，但是对于随机访问大量的比对可能很慢。

请注意，如果成对比对彼此比对较差，则即使对于相对较短的序列，成对比对也可能返回天文数字的比对。因此，我们建议首先检查路线的数量(可作为LEN(路线)访问)，即使路线的数量非常多，也可以快速计算出来。

__init__(seqA, seqB, score, paths)

初始化新的PairwiseAlignments对象。

参数：

  • SEQA-第一个序列，作为纯字符串，没有间隙。

  • seqB-第二个序列，作为纯字符串，没有间隙。

  • 分数-对齐分数。

  • 路径-回溯矩阵中路径上的迭代器；

    每条路径定义一条路线。

通常可以通过调用aligner.ign(seqA，seqB)来获得PairwiseAlignments对象，其中aligner是一个PairwiseAligner对象。

__len__()
__getitem__(index)
__iter__()
__next__()
class Bio.Align.PairwiseAligner(**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:
TACCG
-|-||
-A-CG

Score = 3.0:
TACCG
-||-|
-AC-G

将对齐器模式指定为本地以生成本地对齐：

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

Score = 3.0:
TACCG
 ||-|
 AC-G

进行全局对齐。相同的字符给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:
TACCG
-||-|
-AC-G

Score = 6.0:
TACCG
-|-||
-A-CG

同上，不同之处在于现在打开缺口时扣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:
TACCG
-|-||
-A-CG

Score = 5.5:
TACCG
-||-|
-AC-G

对齐函数还可以使用已包含在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)
KEVLA
-|||-
-EVL-

您还可以在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:
TACCG
-||-|
-AC-G

Score = 6.0:
TACCG
-|-||
-A-CG
__init__(**kwargs)

使用关键字参数作为属性初始化新的PairwiseAligner。

循环关键字参数，并将它们设置为对象上的属性。

__setattr__(key, value)

实现setattr(self，name，value)。

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

使用PairwiseAligner返回两个序列的比对。

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

使用PairwiseAligner返回两个序列的比对分数。

__getstate__()
__setstate__(state)