Bio.pairwise2 模块

使用动态规划算法进行成对序列比对。

此模块提供了获取两个序列之间的全局和局部比对的函数。全局比对找到两个序列中所有字符之间的最佳一致性。局部比对只找到最佳比对的子序列。局部比对必须具有正分才能被报告，并且不会为“零计数”匹配而扩展。这意味着局部比对始终以正计数匹配开始和结束。

在进行比对时，可以指定匹配分数和间隙罚分。匹配分数表示两个序列中两个字符比对的兼容性。高度兼容的字符应给予正分数，不兼容的字符应给予负分数或 0。间隙罚分应为负数。

此模块中比对函数的名称遵循约定 <比对类型>XX，其中 <比对类型> 为“global”或“local”，XX 为一个 2 字符代码，指示它接受的参数。第一个字符表示匹配（和不匹配）的参数，第二个字符表示间隙罚分的参数。

匹配参数是

CODE  DESCRIPTION & OPTIONAL KEYWORDS
x     No parameters. Identical characters have score of 1, otherwise 0.
m     A match score is the score of identical chars, otherwise mismatch
      score. Keywords ``match``, ``mismatch``.
d     A dictionary returns the score of any pair of characters.
      Keyword ``match_dict``.
c     A callback function returns scores. Keyword ``match_fn``.

间隙罚分参数是

CODE  DESCRIPTION & OPTIONAL KEYWORDS
x     No gap penalties.
s     Same open and extend gap penalties for both sequences.
      Keywords ``open``, ``extend``.
d     The sequences have different open and extend gap penalties.
      Keywords ``openA``, ``extendA``, ``openB``, ``extendB``.
c     A callback function returns the gap penalties.
      Keywords ``gap_A_fn``, ``gap_B_fn``.

所有不同的比对函数都包含在对象 align 中。例如

>>> from Bio import pairwise2
>>> alignments = pairwise2.align.globalxx("ACCGT", "ACG")

为了更好的可读性，必需参数可以使用可选关键字

>>> alignments = pairwise2.align.globalxx(sequenceA="ACCGT", sequenceB="ACG")

结果是两个字符串之间比对的列表。每个比对都是一个命名元组，包含两个比对的序列、分数以及比对的开始和结束位置

>>> print(alignments)
[Alignment(seqA='ACCGT', seqB='A-CG-', score=3.0, start=0, end=5), ...

可以通过索引或名称访问比对的每个元素

>>> alignments[0][2]
3.0
>>> alignments[0].score
3.0

要获得比对的漂亮打印输出，请使用模块的 format_alignment 方法

>>> from Bio.pairwise2 import format_alignment
>>> print(format_alignment(*alignments[0]))
ACCGT
| || 
A-CG-
  Score=3

所有比对函数都具有以下参数

两个序列：字符串、Biopython 序列对象或列表。列表对于提供包含由一个以上字母编码的残基的序列很有用。
penalize_extend_when_opening: 布尔值（默认值：False）。是否在打开间隙时计算扩展罚分。如果为 false，则 1 个间隙仅被罚“打开”罚分，否则被罚“打开+扩展”。
penalize_end_gaps: 布尔值。是否计算比对末尾的间隙。默认情况下，它们在全局比对中计算，但在局部比对中不计算。将 penalize_end_gaps 设置为 (布尔值, 布尔值) 允许您分别为两个序列指定比对末尾的间隙是否应计算。
gap_char: 字符串（默认值：'-'）。在返回的比对中用作间隙字符的字符。如果您的输入序列是列表，则必须将其更改为 ['-']。
force_generic: 布尔值（默认值：False）。始终使用通用的、非缓存的动态规划函数（慢！）。用于调试。
score_only: 布尔值（默认值：False）。只获取最佳分数，不恢复任何比对。函数的返回值是分数。更快，占用内存更少。
one_alignment_only: 布尔值（默认值：False）。只恢复一个比对。

比对函数的其他参数取决于调用的函数。一些例子

找到两个序列之间的最佳全局比对。相同的字符得 1 分。不匹配或间隙不扣分。

>>> for a in pairwise2.align.globalxx("ACCGT", "ACG"):
...     print(format_alignment(*a))
ACCGT
| || 
A-CG-
  Score=3

ACCGT
|| | 
AC-G-
  Score=3

与之前相同，但使用局部比对。请注意，format_alignment 将只显示序列的比对部分，以及起始位置。

>>> for a in pairwise2.align.localxx("ACCGT", "ACG"):
...     print(format_alignment(*a))
1 ACCG
  | ||
1 A-CG
  Score=3

1 ACCG
  || |
1 AC-G
  Score=3

要恢复 format_alignemt 的“历史”行为，即还显示两个序列的未比对部分，请使用新的关键字参数 full_sequences

>>> for a in pairwise2.align.localxx("ACCGT", "ACG"):
...     print(format_alignment(*a, full_sequences=True))
ACCGT
| || 
A-CG-
  Score=3

ACCGT
|| | 
AC-G-
  Score=3

执行全局比对。相同的字符得 2 分，每个不同的字符扣 1 分。不惩罚间隙。

>>> for a in pairwise2.align.globalmx("ACCGT", "ACG", 2, -1):
...     print(format_alignment(*a))
ACCGT
| || 
A-CG-
  Score=6

ACCGT
|| | 
AC-G-
  Score=6

与上面相同，只是现在打开间隙时扣 0.5 分，扩展间隙时扣 0.1 分。

>>> for a in pairwise2.align.globalms("ACCGT", "ACG", 2, -1, -.5, -.1):
...     print(format_alignment(*a))
ACCGT
| || 
A-CG-
  Score=5

ACCGT
|| | 
AC-G-
  Score=5

请注意，您可以使用关键字来提高可读性，例如

>>> a = pairwise2.align.globalms("ACGT", "ACG", match=2, mismatch=-1, open=-.5,
...                              extend=-.1)

根据罚分，一个序列中的间隙后面可能紧跟着另一个序列中的间隙。如果您不喜欢这种行为，请增加间隙打开罚分

>>> for a in pairwise2.align.globalms("A", "T", 5, -4, -1, -.1):
...     print(format_alignment(*a))
A-

-T
  Score=-2

>>> for a in pairwise2.align.globalms("A", "T", 5, -4, -3, -.1):
...     print(format_alignment(*a))
A
.
T
  Score=-4

比对函数也可以使用 Biopython 中已包含的已知矩阵（在 Bio.Align.substitution_matrices 中）

>>> from Bio.Align import substitution_matrices
>>> matrix = substitution_matrices.load("BLOSUM62")
>>> for a in pairwise2.align.globaldx("KEVLA", "EVL", matrix):
...     print(format_alignment(*a))
KEVLA
 ||| 
-EVL-
  Score=13

使用参数 c，您可以定义自己的匹配和间隙函数。例如，要定义仿射对数间隙函数并使用它

>>> from math import log
>>> def gap_function(x, y):  # x is gap position in seq, y is gap length
...     if y == 0:  # No gap
...         return 0
...     elif y == 1:  # Gap open penalty
...         return -2
...     return - (2 + y/4.0 + log(y)/2.0)
...
>>> alignment = pairwise2.align.globalmc("ACCCCCGT", "ACG", 5, -4,
...                                      gap_function, gap_function)

您可以为每个序列定义不同的间隙函数。自定义匹配函数必须接受要比较的两个残基并返回一个分数。

要查看函数参数的描述，请通过 help 函数查看该函数的文档字符串，例如，在 Python 提示符下键入 help(pairwise2.align.localds)。

class Bio.pairwise2.Alignment(seqA, seqB, score, start, end)

基础：tuple

__getnewargs__(): 将自身作为普通元组返回。由 copy 和 pickle 使用。

static __new__(_cls, seqA, seqB, score, start, end): 创建 Alignment(seqA, seqB, score, start, end) 的新实例

__repr__(): 返回格式良好的表示字符串

__slots__ = ()

end: 字段编号 4 的别名

score: 字段编号 2 的别名

seqA: 字段编号 0 的别名

seqB: 字段编号 1 的别名

start: 字段编号 3 的别名

class Bio.pairwise2.identity_match(match=1, mismatch=0)

基础：object

创建用于比对的匹配函数。

match 和 mismatch 是两个残基相等或不相等时要给的分数。默认情况下，match 为 1，mismatch 为 0。

__init__(match=1, mismatch=0): 初始化类。

__call__(charA, charB): 调用已创建的匹配函数实例。

class Bio.pairwise2.dictionary_match(score_dict, symmetric=1)

基础：object

创建用于比对的匹配函数。

属性

score_dict - 一个字典，其中键是元组（残基 1，残基 2），值是这些残基之间的匹配分数。
symmetric - 一个标志，指示分数是否对称。

__init__(score_dict, symmetric=1): 初始化类。

__call__(charA, charB): 调用已创建的字典匹配实例。

class Bio.pairwise2.affine_penalty(open, extend, penalize_extend_when_opening=0)

基础：object

创建用于对齐的间隙函数。

__init__(open, extend, penalize_extend_when_opening=0): 初始化类。

__call__(index, length): 调用已创建的间隙函数实例。

Bio.pairwise2.calc_affine_penalty(length, open, extend, penalize_extend_when_opening): 计算间隙函数的惩罚得分。

Bio.pairwise2.print_matrix(matrix): 打印矩阵以供调试。

Bio.pairwise2.format_alignment(align1, align2, score, begin, end, full_sequences=False)

将对齐格式化为漂亮的字符串。

重要：间隙符号必须为“-”（或[‘-’] 用于列表）！

自 Biopython 1.71 起，相同的匹配项用管道字符显示，不匹配项用点显示，间隙用空格显示。

之前的版本只使用管道字符来指示对齐区域（匹配项、不匹配项和间隙）。

此外，在局部对齐中，如果对齐不包括整个序列，现在只显示对齐的部分，以及对齐子序列的起始位置。起始位置为 1 基，因此起始位置 n 是未对齐序列中的第 n 个碱基/氨基酸。

注意：这与对齐的 begin/end 值不同，begin/end 值给出对齐序列中碱基/氨基酸的 Python 索引（0 基）。

如果您想恢复“历史”行为，这意味着显示整个序列（包括未对齐的部分），请使用full_sequences=True。在这种情况下，未对齐的前导和尾随部分也用匹配行中的空格表示。