Практикум 12: Pfam, домен Zn_clus, JalView

1. Программа сравнения выравниваний

import sys

def read_file(filename):
    seqs = []
    current = ""
    
    for line in open(filename):
        line = line.strip()
        if not line:
            continue
        if line[0] == '>':
            if current:
                seqs.append(current)
                current = ""
        else:
            current = current + line
    
    if current:
        seqs.append(current)
    
    return seqs

def compare(file1, file2, out=None):
    s1 = read_file(file1)
    s2 = read_file(file2)
    
    if len(s1) != len(s2):
        print(f"Ошибка: разное количество последовательностей!")
        return
    
    n = len(s1)
    m1 = len(s1[0])
    m2 = len(s2[0])
    
  
    all_pairs = []
    used_j = set()
    
    for i in range(m1):
        for j in range(m2):
            if j in used_j:
                continue
            ok = True
            for k in range(n):
                if s1[k][i] != s2[k][j]:
                    ok = False
                    break
            if ok:
                all_pairs.append((i+1, j+1))
                used_j.add(j)
                break
    
   
    all_pairs.sort()
    
   
    blocks = []
    single_pairs = []
    
    if all_pairs:
        block_start1 = all_pairs[0][0]
        block_start2 = all_pairs[0][1]
        prev1 = all_pairs[0][0]
        prev2 = all_pairs[0][1]
        
        for k in range(1, len(all_pairs)):
            curr1, curr2 = all_pairs[k]
            if curr1 == prev1 + 1 and curr2 == prev2 + 1:
                prev1 = curr1
                prev2 = curr2
            else:
                block_len = prev1 - block_start1 + 1
                if block_len >= 2:
                    blocks.append((block_start1, prev1, block_start2, prev2))
                else:
                    single_pairs.append((block_start1, block_start2))
                block_start1 = curr1
                block_start2 = curr2
                prev1 = curr1
                prev2 = curr2
        
        block_len = prev1 - block_start1 + 1
        if block_len >= 2:
            blocks.append((block_start1, prev1, block_start2, prev2))
        else:
            single_pairs.append((block_start1, block_start2))
    
   
    if out:
        f = open(out, 'w')
        f.write("Блоки одинаково выровненных колонок:\n")
        for b in blocks:
            f.write(f"({b[0]},{b[1]})=({b[2]},{b[3]})\n")
        if single_pairs:
            f.write("\nОдиночные одинаковые колонки:\n")
            for p in single_pairs:
                f.write(f"{p[0]}\t{p[1]}\n")
        f.close()
        print(f"Результат записан в: {out}")
    
    total_in_blocks = sum(b[1] - b[0] + 1 for b in blocks)
    print(f"Длина 1 выравнивания: {m1}")
    print(f"Длина 2 выравнивания: {m2}")
    print(f"Найдено блоков: {len(blocks)}")
    print(f"Колонок в блоках: {total_in_blocks}")
    print(f"Одиночных колонок: {len(single_pairs)}")
    print(f"Всего одинаковых колонок: {total_in_blocks + len(single_pairs)}")
    print(f"% в блоках от 1 выравнивания: {round(100*total_in_blocks/m1, 1)}")
    print(f"% в блоках от 2 выравнивания: {round(100*total_in_blocks/m2, 1)}")

if len(sys.argv) == 2 and sys.argv[1] == '-h':
    print('Использование: python compare.py файл1 файл2 [выход]')
    print('Файлы: выравнивание в формате FASTA')
    print('Выход: блоки (s1,f1)=(s2,f2) длиной >= 2')
    print('       и список одиночных одинаковых колонок')
elif len(sys.argv) >= 3:
    out = sys.argv[3] if len(sys.argv) > 3 else None
    compare(sys.argv[1], sys.argv[2], out)
else:
    print('Укажите два файла. -h для справки')

2. Сравнение трёх программ MSA на примере фосфолипаз A2

Белки:
P00602 — Naja mossambica (кобра)
Q3C2C1 — Acanthaster planci (терновый венец)
P00630 — Apis mellifera (пчела)

Длины выравниваний:
ClustalO: 212 колонок, MAFFT: 228 колонок, MUSCLE: 193 колонки.

Результаты попарного сравнения (программа compare.py)

python compare.py mafft.fa muscle.fa ma_mu.txt

Результат записан в: ma_mu.txt
Длина 1 выравнивания: 228
Длина 2 выравнивания: 193
Найдено блоков: 7
Колонок в блоках: 65
Одиночных колонок: 36
Всего одинаковых колонок: 101
% в блоках от 1 выравнивания: 28.5
% в блоках от 2 выравнивания: 33.7

Блоки одинаково выровненных колонок:
(1,8)=(1,8)
(17,23)=(17,23)
(38,64)=(38,64)
(66,78)=(66,78)
(82,84)=(82,84)
(88,92)=(88,92)
(164,165)=(172,173)

Одиночные одинаковые колонки:
15      15
16      10
28      28
35      13
36      36
65      34
79      118
80      165
81      117
86      93
94      24
95      95
97      86
100     119
102     103
105     11
116     96
126     131
128     29

python compare.py mafft.fa clustalo.fa ma_cl.txt

Результат записан в: ma_cl.txt
Длина 1 выравнивания: 228
Длина 2 выравнивания: 212
Найдено блоков: 8
Колонок в блоках: 61
Одиночных колонок: 68
Всего одинаковых колонок: 129
% в блоках от 1 выравнивания: 26.8
% в блоках от 2 выравнивания: 28.8

Блоки одинаково выровненных колонок:
(29,34)=(33,38)
(53,55)=(67,69)
(64,75)=(54,65)
(85,95)=(75,85)
(123,125)=(108,110)
(155,164)=(139,148)
(170,173)=(154,157)
(179,190)=(163,174)

Одиночные одинаковые колонки:
3       27
6       26
8       18
13      11
18      112
19      103
21      121
22      117
23      111
28      149
36      102
51      70
52      197
56      177
57      185
58      71
61      159
62      66

Сравнение	Длина 1	Длина 2	Блоков	В блоках	Одиночных	Всего	% в блоках (1)	% в блоках (2)
MAFFT vs MUSCLE	228	193	7	65	36	101	28.5%	33.7%
MAFFT vs ClustalO	228	212	8	61	68	129	26.8%	28.8%

Анализ

MAFFT делает самые длинные выравнивания (228 колонок) — вставляет больше гэпов.
MUSCLE делает самые компактные выравнивания (193 колонки) — меньше гэпов.
ClustalO занимает промежуточное положение (212 колонок).
MAFFT vs ClustalO: 129 одинаковых колонок (больше всего), 8 блоков, 61 колонка в блоках (26.8–28.8%).
MAFFT vs MUSCLE: 101 одинаковая колонка, 7 блоков, 65 колонок в блоках (28.5–33.7%). Выше процент в блоках относительно MUSCLE (33.7%).
MAFFT (B) больше похож на ClustalO (A): 129 общих колонок против 101 у MUSCLE. Ближе по длине выравнивания (228 vs 212, разница 16 колонок; у MUSCLE 193 — разница 19).

3. Сравнение структурного (PDBeFold) и последовательностного (MUSCLE) выравнивания для домена Zn_clus

Выбраны 3 белка (PDB ID): 1PYI, 1AW6, 2ERG

Длина 1 выравнивания (PDBeFold): 162
Длина 2 выравнивания (MUSCLE): 110
Найдено блоков: 1
Колонок в блоках: 2
Одиночных колонок: 2
Всего одинаковых колонок: 4
% в блоках от 1 выравнивания: 1.2
% в блоках от 2 выравнивания: 1.8

Результат сравнения двух выравниваний — структурного (PDBeFold) и по последовательности (MUSCLE) — для трёх белков домена Zn_clus показывает очень низкое перекрытие: всего 4 колонки выровнены одинаково (из 110–162 позиций), что составляет 1.2% и 1.8% от длины каждого выравнивания.

Что это означает?
MUSCLE выравнивает первичные последовательности, минимизируя замены и гэпы. Для дивергентных белков Zn_clus результат — короткое выравнивание (110 позиций) с пробелами.
PDBeFold выравнивает трёхмерные структуры, поэтому он может сопоставлять пространственно эквивалентные остатки даже при низкой идентичности последовательности. Его выравнивание длиннее (162 позиции).
Одинаковые колонки — это позиции, где в обоих выравниваниях напротив друг друга стоят одинаковые буквы. Их мало, так как методы по-разному расставляют гэпы и выбирают пары.

Вывод: Низкое совпадение не означает ошибку. Оно иллюстрирует принципиальную разницу между выравниванием по последовательности (MUSCLE) и по структуре (PDBeFold). Для консервативных по структуре, но дивергентных по последовательности доменов (таких как Zn_clus) совпадение ожидаемо малое. Визуально же структуры наложатся хорошо, даже если первичные последовательности разошлись.

Рисунок 1. Пространственное сравнение структур в Pymol

4. Краткое описание программы MSA: MUSCLE

MUSCLE (сокращение от MUltiple Sequence Comparison by Log‑Expectation) — популярный инструмент для множественного выравнивания нуклеотидных и белковых последовательностей. Алгоритм построения выравнивания выглядит следующим образом: сначала MUSCLE делает черновое выравнивание, оценивая расстояния между последовательностями через k‑меры и применяя прогрессивный метод. А потом начинает улучшать результат итеративно — пересчитывает профили, удаляет последовательности, переставляет их, чтобы добиться более точного выравнивания. В основе всего этого лежит log‑expectation score (логарифмическое ожидание), который как раз и повышает точность.

Рисунок 2. Алгоритм построения выравнивания MUSCLE

Отличие от других программ MSA:

MAFFT — основной конкурент MUSCLE. На наборах из десятков тысяч последовательностей MAFFT более эффективен, тогда как MUSCLE предпочтителен для средних наборов (сотни – несколько тысяч). При выравнивании сильно дивергировавших последовательностей MAFFT иногда дает более точные результаты.

Clustal Omega — программа имеет высокую скоростью выполнения и достаточно проста в использовании, но уступает MUSCLE в точности выравнивания сложных белковых доменов.

[1] Edgar, R.C. (2004). MUSCLE: multiple sequence alignment with high accuracy and high throughput. Nucleic Acids Research, 32(5), 1792–1797. https://doi.org/10.1093/nar/gkh340

Отчёт по практикуму 12 | Мисюрёва Анастасия | 2026

Практикум 12: Алгоритмы и программы множественного выравнивания.

Мисюрёва Анастасия | Факультет биоинженерии и биоинформатики МГУ