Нахождение комплемента последовательности ДНК

Question

Я должен перевести комплемент последовательности ДНК в аминокислоты

TTTCAATACTAGCATGACCAAAGTGGGAACCCCCTTACGTAGCATGACCCATATATATATATATA
TATATATATATATATGGGTCATGCTACGTAAGGGGGTTCCCACTTTGGTCATGCTAGTATTGAAA
+1 TyrIleTyrIleTyrGlySerCysTyrValArgGlyPheProLeuTrpSerCysStpTyrStp
+2 IleTyrIleTyrMetGlyHisAlaThrOc*GlyGlySerHisPheGlyHisAlaSerIleglu
+3 TyrIleTyrIleTrpValMetLeuArgLysGlyValProThrLeuValMetLeuValLeuLys

• Первая последовательность - это нормальная последовательность,
• Второй является дополнительной последовательностью,
• Одна с +1 - это аминокислотная последовательность, соответствующая моей комплементарной последовательности
• Последовательность с +2 - это аминокислотная последовательность, соответствующая моей комплементарной последовательности, начиная со второго основания
• Одна с +3 является аминокислотной последовательностью, соответствующей моей комплементарной последовательности, начинающейся с третьего основания

я попробовал следующий код, чтобы получить свои результаты, но так я получаю просто дополнительный результат. без разделения

seq = "CCGGAAGAGCTTACTTAG"
basecomplement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'}

def translate(seq):

    x = 0
    aaseq = []
    while True:
        try:
            aaseq.append(basecomplement[seq[x:x+1]])
            x += 1

        except (IndexError, KeyError):
            break
    return aaseq

for frame in range(1):
    #print(translate(seq[frame:]))

    rseqn= (''.join(item.split('|')[0] for item in translate(seq[frame:])))

    rseqn = list(rseqn)
    rseqn.reverse()

    print( rseqn)

Может ли кто-нибудь помочь мне получить мои результаты?

Answer 1

Кажется, вы взяли какой-то код и попытались использовать его, даже не понимая, что он делает. Если вы прочтете связанный вопрос, вы заметите, что у автора этого вопроса был словарь строк аминокислотных кодов, разделенных |, Призыв к split должен был извлечь вторую часть каждой строки кода, например, из "F|Phe" ты хочешь получить "Phe" и именно поэтому этот плакат нуждался в split, У вас нет таких строк, поэтому вы не должны использовать эту часть кода.

Во-вторых, я рекомендую Хоакину использовать BioPython, поскольку это, безусловно, правильный инструмент для работы, но для целей обучения: первое, что вам нужно знать, - это выполнить четыре задачи:

1. Вычислить обратный комплемент последовательности оснований ДНК
2. Разбить обратную комплементарную последовательность на группы по 3 основания
3. Конвертировать каждую группу в код аминокислоты
4. Положите коды аминокислот в строку

Код в связанном ответе не обрабатывает первый шаг. Для этого вы можете использовать translate метод строковых объектов Python. Сначала вы используете maketrans создать словарь перевода, который отобразит ключ => значение,

basecomplement = str.maketrans({'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'})

а затем вы можете написать метод для получения обратного дополнения,

def reverse_complement(seq):
    return seq.translate(basecomplement)[::-1]

translate Метод ответа Хоакина на другой вопрос реализует шаги 2 и 3. На самом деле это можно сделать более эффективно, используя grouper рецепт от itertools, Сначала вам понадобится словарь, отображающий базовые триплеты на аминокислоты,

amino_acids = {'TAT': 'Tyr', ...}

и затем вы можете использовать это, чтобы преобразовать любую последовательность оснований,

amino_acids[''.join(a)] for a in zip(*([iter(rseq)]*3))

В порядке объяснения, zip(*([iter(rseq)]*3)) группирует персонажей по три за раз. Но это как кортежи, а не строки, например, для 'TATATA' вы получите ('T', 'A', 'T'), ('A', 'T', 'A'), поэтому вам нужно присоединиться к каждому кортежу, чтобы создать строку. Это то что ''.join(a) делает. Затем вы ищите строку в таблице аминокислот, которая выполняется amino_acids[...],

Наконец, вам нужно объединить все полученные коды аминокислот вместе, что может быть сделано внешним ''.join(...), Таким образом, вы можете определить метод следующим образом:

def to_amino_acids(seq):
    return ''.join(amino_acids[''.join(a)] for a in zip(*([iter(rseq)]*3)))

Обратите внимание, что вам не нужно .split('|') если ваш amino_acids словарь содержит несколько представлений, разделенных |,

Наконец, чтобы сделать это для трех разных способов преобразования оснований в аминокислоты, то есть для трех кадров, вы должны использовать что-то похожее на последний цикл в ответе Хоакина,

rseq = reverse_complement(seq)
for frame in range(3):
    # print the frame number
    print('+', frame+1, end=' ')
    # translate the base sequence to amino acids and print it
    print(to_amino_acids(rseq[frame:]))

Обратите внимание, что этот цикл выполняется три раза, чтобы напечатать три разных кадра. Нет смысла иметь цикл, если вы просто собираетесь запустить его один раз.

Answer 2

Использование:

for frame in range(1):
    rseqn = reversed([item for item in translate(seq[frame:])])
    rseqn = ''.join(rseqn)

    print(rseqn)

это дает правильную дополнительную (обращенную) последовательность:

CTAAGTAAGCTCTTCCGG

Обратите внимание, что вам не нужен цикл for (текущий фактически ничего не делает) для определения комплементарных последовательностей ДНК или РНК, поскольку он не зависит от каркаса трансляции.

Сказав это, однако, я должен подчеркнуть, что ВСЕ ваш код может быть упрощен в четыре строки, если вы начнете использовать BioPython для ваших Биоинформационных задач:

>>> from Bio import SeqIO
>>> from Bio.Alphabet import NucleotideAlphabet
>>> dna = SeqIO.Seq("CCGGAAGAGCTTACTTAG", NucleotideAlphabet())
>>> dna.reverse_complement()
Seq('CTAAGTAAGCTCTTCCGG', NucleotideAlphabet())
>>> 

Answer 3

Я немного почистил код:

seq = "CCGGAAGAGCTTACTTAG"
basecomplement = {'A': 'T', 'C': 'G', 'G': 'C', 'T': 'A'}

def translate(seq):
    aaseq = []
    for character in seq:
        aaseq.append(basecomplement[character])
    return aaseq

for frame in range(1):
    rseqn= (''.join(item.split('|')[0] for item in translate(seq[frame:])))
    rseqn = rseqn[::-1]
    print( rseqn)

Посмотрите, работает ли это для вас.

То, что вы делаете, это преобразование rseqn в список, обратный список и распечатка списка. Код, который я написал, никогда не преобразует rseqn в список. rseqn изначально является строкой и строкой rseqn = rseqn[::-1] переворачивает строку для вас. Итак, наконец, то, что вы печатаете, - это строка, а не список, и, следовательно, разделений нет.