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

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 (текущий фактически ничего не делает) для определения комплементарных последовательностей ДНК или РНК, поскольку он не зависит от рамки трансляции.

Сказав это, однако, я должен подчеркнуть, что ALL Ваш код может быть упрощен в четыре строки, если вы начнете использовать 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] переворачивает строку для вас. Итак, наконец, то, что вы печатаете - это строка, а не список, и, следовательно, разделений нет.