Bio.Align包

子包

子模块

模块内容

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

此模块中最重要的内容之一是MultipleSeqAlliance类，用于Bio.AlignIO模块。

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

基类：tuple

__getnewargs__()

将自我返回为一个简单的二元组。 由复制和腌制使用。

__match_args__ = ('gaps', 'identities', 'mismatches')
static __new__(_cls, gaps, identities, mismatches)

创建AlignmentCounts（间隙、身份、不匹配）的新实例

__replace__(**kwds)

返回新的AlignmentCounts对象，用新值替换指定字段

__repr__()

返回格式良好的表示字符串

__slots__ = ()
gaps

字段号0的收件箱

identities

字段号1的收件箱

mismatches

字段2的收件箱

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

基类：object

代表经典的多序列比对（GMA）。

我们指的是长度相同的序列（通常以行形式显示）的集合（通常带有插入或填充的间隔字符）。然后，数据可以被视为具有明确定义的列的字母矩阵。

您通常会通过使用AlignIO模块加载对齐文件来创建一个MTA：

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

初始化新的MultipleSeqEqualition对象。

论点：
  • records -SeqRecord对象的列表（或迭代器），其

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

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

    没有。

  • 注释-有关整个对齐的信息（字典）。

  • entry_annotations -每列注释（受限制的字典）。

    它保存长度与列数匹配的Python序列（列表、字符串、元组）。一个典型的用途是二级结构共有字符串。

您通常会使用Bio.AlignIO从文件加载GMA，但您也可以从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

另请参阅路线的格式方法。

__repr__()

返回对象的表示形式以进行调试。

该表示不能与eval（）一起使用来重新创建对象，而这通常可以使用简单的Python对象。 例如：

<Bio.Align. MultipleSeqEqualition实例（2条长度为14的记录），位于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（align）获取序列数（即行数），使用align.get_align_long（）获取最长序列的长度（即列数）。

如果您将对齐方式看作是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（对齐）：

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

由于对齐对象允许迭代作为SeqRecords的行，因此您可以将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)

通过将两个行数相同的路线相加将它们组合在一起。

如果您有两个多重序列比对（GMA），则有两种方法可以考虑添加它们-按行或按列。使用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对象（代表一列）、字符串（代表一个字符）或其他对齐方式（代表对齐方式的部分或全部）。

对齐 [r,c] 提供一个字符作为字符串对齐 [r] 给出一行作为SeqRecord对齐 [r,:] 给出一行作为SeqRecord对齐 [:,c] 给出一列作为Seq

对齐 [:] 并对齐 [:,:] 提供路线的副本

其他任何内容都会提供子对齐，例如对齐 [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])

您可以使用integer索引将对齐的一行作为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

这包括对步骤的支持，即对齐 [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

还有一个相反的参数，所以如果您想按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。未来对MultipleSeqAlliance中原始记录的任何更改都不会影响该对齐中的新记录。

__firstlineno__ = 63
__static_attributes__ = ('_per_col_annotations', '_records', 'annotations', 'column_annotations')
class Bio.Align.Alignment(sequences, coordinates=None)

基类：object

代表序列对齐。

对齐对象具有 .sequences 存储对齐的序列（Seq、MutableSeq、SeqRecord或字符串对象）的属性，以及 .coordinates 将定义对齐的序列坐标存储为NumPy数组的属性。

其他常用属性（可能存在，也可能不存在）包括：
  • 注释 - 一本带有描述

    对齐;

  • entry_annotations -包含描述每个条目的注释的词典

    对齐中的列;

  • 评分 - 对齐分数。

classmethod infer_coordinates(lines)

从打印的对齐中推断坐标（已废除）。

该方法主要用于Biopython的对齐解析器，尽管它可能用于其他目的。

对于由N个序列组成的比对，打印为具有相同列数的N条线，其中间隙由虚线表示，此方法将计算定义比对的序列坐标。坐标以NumPy整元数组的形式返回，可用于创建对齐对象。

这是三个序列TAGCATACGTG、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条线，其中间隙由虚线表示，此方法将计算定义比对的序列坐标。它返回数组（序列、坐标），其中序列是去除间隙后的N个序列的列表，坐标是2D NumPy整组。序列和坐标可一起用于创建对齐对象。

这是三个序列TAGCATACGTG、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)

初始化新的对齐对象。

论点：
  • 序列 - 序列列表（Seq、MutableSeq、SeqRecord、

    或字符串对象）。

  • 坐标-定义对齐的序列坐标。

    如果无（默认值），则假设序列彼此对齐，没有任何间隙。

__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

返回自我。序列 [0] 进行成对对齐。

property query

返回自我。序列 [1] 进行成对对齐。

__eq__(other)

检查两个对齐对象是否指定相同的对齐。

__ne__(other)

检查两个对齐对象是否具有不同的对齐方式。

__lt__(other)

检查自己是否应该排在他人之前。

__le__(other)

检查自己是否应该先于他人或等于他人。

__gt__(other)

检查自己是否应该在别人之后。

__ge__(other)

检查自己是否应该排在他人之后或等于他人。

__getitem__(key)

回归自我 [key] .

表格指数

自我 [:, :]

返回对齐对象的副本;

自我 [:, i:] 自我 [:, :j] 自我 [:, i:j] 自我 [:, iterable] （其中可迭代返回integer）

返回跨越所选列的新对齐对象;

自我 [k, i] 自我 [k, i:] 自我 [k, :j] 自我 [k, i:j] 自我 [k, iterable] （其中可迭代返回integer）self [k] （相当于自己 [k, :] )

返回具有所选列的对齐序列（包括间隔）的字符串，其中k = 0代表目标，k = 1代表查询序列;以及

自我 [:, 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(fmt='', *args, **kwargs)

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

论点：
  • fmt - 文件格式。可接受的值是空字符串，

    创建对齐的人类可读表示或支持的任何对齐文件格式 Bio.Align (some尚未实施）。

所有其他参数都传递给格式特定的编写器函数：
  • 掩模 - 仅限PSL格式。指定目标中是否重复区域

    序列被屏蔽，应在 repMatches PSL文件的字段，而不是 matches 领域可接受值为无 ：无掩码（默认）;“lower”：按小写字符掩码;“upper”：按大写字符掩码。

  • 格式-仅限PSL格式。向收件箱报告对齐情况

    中的目标或查询序列中的 nCount PSL文件的字段，而不是 matches , misMatches ，或者 repMatches 领域的默认值为“N”。

  • MD - 仅限Sam格式。如果为True，则根据以下公式计算MD标签

    对齐并将其包含在输出中。如果为False（默认），则不要在输出中包括MD标签。

__str__()

返回对齐方式的人类可读字符串表示形式。

对于序列比对，每条线最多有80列。前10列显示（可能被截断）序列名称，它可能是SeqRecord的id属性，或者是成对比对的“目标”或“查询”。接下来的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对象。 例如：

<0x10403d850处的对齐对象（2行x 14列）>

十六进制字符串是对象的内存地址，可用于区分不同的对齐对象。 有关更多信息，请参阅帮助（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（对齐）返回的对齐中的序列数，对于成对对齐，该值始终为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. select和alignment.target是相同的序列。

一个典型的例子是，self是染色体和转录本之间的成对比对，论点是转录本和序列之间的成对比对（例如，通过RN-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'

地图方法还可用于提升不同基因组组装之间的对齐。在这种情况下，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]]

表明黑猩猩基因组组装panTro 5上chr1的范围122250000：122909835与黑猩猩基因组组装panTro 6上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]]

这表明表达序列标签DC 525629的核苷酸范围32：344与黑猩猩基因组组装panTro5的chr1的范围122835789：122907314比对。

请注意，目标序列链。序列 [0] .seq和目标序列比对.序列 [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]]

现在，我们可以通过调用链上的地图来获得DC 525629针对黑猩猩基因组组装panTro 6的坐标，以对齐为参数：

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

这表明表达的序列标签DC 525629的第32：344个碱基范围与黑猩猩基因组组装panTro 6的chr 1的第111982717：112009302个碱基范围对齐。请注意，DC 525629在黑猩猩基因组组装panTro 5上的基因组跨度为122907314 - 122835789 = 71525个碱基对，而在panTro 6上的基因组跨度为112009302 - 111982717 = 26585个碱基对。

mapall(alignments)

将每个路线映射到自身，并返回映射的路线。

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]}
__firstlineno__ = 1003
__hash__ = None
__static_attributes__ = ('coordinates', 'sequences')
class Bio.Align.AlignmentsAbstractBaseClass

基类：ABC

用于序列比对的抽象碱基。

大多数用户不需要使用此类。它在内部用作类似列表的Alignments类和Bio.Align. interners中AlignmentIterator类的Base，后者本身是Bio/Align/中对齐解析器的抽象Base。

__iter__()

将路线作为路线对象迭代。

此方法不应被任何子集重写。

abstractmethod __next__()

返回下一个对齐方式。

abstractmethod rewind()

倒带迭代器，让它从一开始就在对齐中循环。

abstractmethod __len__()

返回对齐数量。

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

基类：AlignmentsAbstractBaseClass, list

__init__(alignments=())
__next__()

返回下一个对齐方式。

rewind()

倒带迭代器，让它从一开始就在对齐中循环。

__len__()

返回对齐数量。

__abstractmethods__ = frozenset({})
__annotations__ = {}
__firstlineno__ = 3670
__static_attributes__ = ('_index',)
class Bio.Align.PairwiseAlignments(seqA, seqB, score, paths)

基类：AlignmentsAbstractBaseClass

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

此类还支持索引，这对于增加索引来说速度很快，但对于随机访问大量对齐可能会很慢。

请注意，如果成对对齐器彼此对齐不良，即使对于相对较短的序列，它们也可以返回天文数字的对齐。因此，我们建议首先检查对齐的数量，可以访问为len（对齐），即使对齐的数量非常大，也可以快速计算该数量。

__init__(seqA, seqB, score, paths)

初始化新的PairwiseAlignments对象。

论点：

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

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

  • 分数-对齐分数。

  • 路径-追溯矩阵中路径的迭代器;

    每条路径定义一条路线。

您通常会通过调用alignner. ign（seqA，seqB）来获取PairwiseAlignments对象，其中alignner是PairwiseAlignner对象或CodonAlignner对象。

__len__()

返回对齐数量。

__getitem__(index)
__next__()

返回下一个对齐方式。

rewind()

倒带迭代器，让它从一开始就在对齐中循环。

__abstractmethods__ = frozenset({})
__annotations__ = {}
__firstlineno__ = 3691
__static_attributes__ = ('_alignment', '_index', '_paths', 'score', 'sequences')
class Bio.Align.PairwiseAligner(scoring=None, **kwargs)

基类：PairwiseAligner

使用动态编程执行成对序列比对。

这提供了获得两个序列之间的全局和局部比对的功能。 全局对齐会找到两个序列中所有字符之间的最佳一致性。 局部对齐只找到最好对齐的子索。

要执行成对序列比对，首先创建PairwiseAligner对象。 此对象存储匹配和不匹配分数以及差距分数。 通常，匹配分数为正值，而不匹配分数和差距分数为负值或零。 默认情况下，匹配分数为1，不匹配和差距分数为零。 根据空位分数的值，PairwiseAligner对象自动选择适当的比对算法（Needleman-Wunsch、Smith-Waterman、Gotoh或Waterman-Smith-Beyer全局或局部比对算法，或快速最佳全局序列比对算法）。

快速最优全局序列比对算法（FOGMAA）永远不会被自动选择。如果您想使用FOGMAA，则必须将“mode”属性设置为“fogsaa”。顾名思义，它只能查找全局对齐，不能用于局部对齐。如果匹配分数小于不匹配分数或任何差距分数或任何差距分数大于不匹配分数，FOGMAA将发出警告，并可能返回不正确的结果。

在具有两个序列作为参数的对齐器上调用“评分”方法将计算两个序列之间的对齐评分。在具有两个序列作为参数的对齐器上调用“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。

如果评分为“无”，则使用默认评分方案match = 1.0、match = 0.0、gap score = 0.0如果评分为“blaecycle”、“megablast”或“blastp”，则分别使用BLASYS、MEGABLAST或BLASTP的默认替代矩阵和gap score。

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

__setattr__(key, value)

实现setattr（self、Name、Value）。

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

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

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

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

__getstate__()

泡菜的帮手。

__setstate__(state)
__firstlineno__ = 3759
__static_attributes__ = ('extend_gap_score', 'match_score', 'mismatch_score', 'mode', 'open_gap_score', 'query_internal_extend_gap_score', 'query_internal_open_gap_score', 'query_left_extend_gap_score', 'query_left_open_gap_score', 'query_right_extend_gap_score', 'query_right_open_gap_score', 'substitution_matrix', 'target_internal_extend_gap_score', 'target_internal_open_gap_score', 'target_left_extend_gap_score', 'target_left_open_gap_score', 'target_right_extend_gap_score', 'target_right_open_gap_score', 'wildcard')
class Bio.Align.CodonAligner(codon_table=None, anchor_len=10)

基类：CodonAligner

将核苷酸序列与氨基酸序列对齐。

此类实现动态编程算法来将核苷序列与氨基酸序列进行比对。

__init__(codon_table=None, anchor_len=10)

初始化特定遗传密码的CodonAligner。

论点：

  • podon_table -代表遗传密码的CodonTable对象。如果密码子表为无，则使用标准遗传密码。

__firstlineno__ = 4032
__static_attributes__ = ('codon_table',)
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序列都被接受。

返回对齐对象的迭代器。

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

  • 目标 - 要写入的文件或类似文件的对象，或字符串形式的文件名。

  • fmt - 描述文件格式的字符串（不区分大小写）。

请注意，如果提供文件或类似文件的对象，您的代码应在调用此函数后关闭目标，或调用.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 - 描述文件格式的字符串（不区分大小写）。

此函数用于解析恰好包含一个对齐的对齐文件。 例如，读取Classal文件：

>>> 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函数。