Biopython - Operações de sequência avançada

Neste capítulo, discutiremos alguns dos recursos avançados de sequência fornecidos pelo Biopython.

Complemento e Complemento Inverso

A sequência de nucleotídeos pode ser complementada reversamente para obter uma nova sequência. Além disso, a sequência complementada pode ser complementada reversamente para obter a sequência original. Biopython fornece dois métodos para fazer essa funcionalidade -complement e reverse_complement. O código para isso é fornecido abaixo -

>>> from Bio.Alphabet import IUPAC 
>>> nucleotide = Seq('TCGAAGTCAGTC', IUPAC.ambiguous_dna) 
>>> nucleotide.complement() 
Seq('AGCTTCAGTCAG', IUPACAmbiguousDNA()) 
>>>

Aqui, o método complement () permite complementar uma sequência de DNA ou RNA. O método reverse_complement () complementa e reverte a sequência resultante da esquerda para a direita. É mostrado abaixo -

>>> nucleotide.reverse_complement() 
Seq('GACTGACTTCGA', IUPACAmbiguousDNA())

Biopython usa a variável ambiguous_dna_complement fornecida por Bio.Data.IUPACData para fazer a operação de complemento.

>>> from Bio.Data import IUPACData 
>>> import pprint 
>>> pprint.pprint(IUPACData.ambiguous_dna_complement) {
   'A': 'T',
   'B': 'V',
   'C': 'G',
   'D': 'H',
   'G': 'C',
   'H': 'D',
   'K': 'M',
   'M': 'K',
   'N': 'N',
   'R': 'Y',
   'S': 'S',
   'T': 'A',
   'V': 'B',
   'W': 'W',
   'X': 'X',
   'Y': 'R'} 
>>>

Conteúdo GC

Prevê-se que a composição da base do DNA genômico (conteúdo GC) afete significativamente o funcionamento do genoma e a ecologia das espécies. O conteúdo de GC é o número de nucleotídeos de GC dividido pelo total de nucleotídeos.

Para obter o conteúdo de nucleotídeos do GC, importe o módulo a seguir e execute as seguintes etapas -

>>> from Bio.SeqUtils import GC 
>>> nucleotide = Seq("GACTGACTTCGA",IUPAC.unambiguous_dna) 
>>> GC(nucleotide) 
50.0

Transcrição

A transcrição é o processo de transformar a sequência de DNA em sequência de RNA. O processo de transcrição biológica real está realizando um complemento reverso (TCAG → CUGA) para obter o mRNA considerando o DNA como a fita modelo. No entanto, em bioinformática e no Biopython, normalmente trabalhamos diretamente com a fita codificadora e podemos obter a sequência de mRNA alterando a letra T para U.

Um exemplo simples para o acima é o seguinte -

>>> from Bio.Seq import Seq 
>>> from Bio.Seq import transcribe 
>>> from Bio.Alphabet import IUPAC 
>>> dna_seq = Seq("ATGCCGATCGTAT",IUPAC.unambiguous_dna) >>> transcribe(dna_seq) 
Seq('AUGCCGAUCGUAU', IUPACUnambiguousRNA()) 
>>>

Para reverter a transcrição, T é alterado para U conforme mostrado no código abaixo -

>>> rna_seq = transcribe(dna_seq) 
>>> rna_seq.back_transcribe() 
Seq('ATGCCGATCGTAT', IUPACUnambiguousDNA())

Para obter a fita modelo de DNA, complemente reverso o RNA transcrito de volta, conforme indicado abaixo -

>>> rna_seq.back_transcribe().reverse_complement() 
Seq('ATACGATCGGCAT', IUPACUnambiguousDNA())

Tradução

A tradução é um processo de tradução da sequência de RNA em sequência de proteína. Considere uma sequência de RNA como mostrado abaixo -

>>> rna_seq = Seq("AUGGCCAUUGUAAU",IUPAC.unambiguous_rna) 
>>> rna_seq 
Seq('AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG', IUPACUnambiguousRNA())

Agora, aplique a função translate () ao código acima -

>>> rna_seq.translate() 
Seq('MAIV', IUPACProtein())

A seqüência de RNA acima é simples. Considere a sequência de RNA, AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA e aplique translate () -

>>> rna = Seq('AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA', IUPAC.unambiguous_rna) 
>>> rna.translate() 
Seq('MAIVMGR*KGAR', HasStopCodon(IUPACProtein(), '*'))

Aqui, os códons de parada são indicados com um asterisco '*'.

É possível no método translate () parar no primeiro códon de parada. Para fazer isso, você pode atribuir to_stop = True em translate () da seguinte maneira -

>>> rna.translate(to_stop = True) 
Seq('MAIVMGR', IUPACProtein())

Aqui, o códon de parada não está incluído na sequência resultante porque não contém um.

Tabela de Tradução

A página de códigos genéticos do NCBI fornece uma lista completa das tabelas de tradução usadas pelo Biopython. Vejamos um exemplo de tabela padrão para visualizar o código -

>>> from Bio.Data import CodonTable 
>>> table = CodonTable.unambiguous_dna_by_name["Standard"] 
>>> print(table) 
Table 1 Standard, SGC0
   | T       | C       | A       | G       | 
 --+---------+---------+---------+---------+-- 
 T | TTT F   | TCT S   | TAT Y   | TGT C   | T
 T | TTC F   | TCC S   | TAC Y   | TGC C   | C
 T | TTA L   | TCA S   | TAA Stop| TGA Stop| A
 T | TTG L(s)| TCG S   | TAG Stop| TGG W   | G 
 --+---------+---------+---------+---------+--
 C | CTT L   | CCT P   | CAT H   | CGT R   | T
 C | CTC L   | CCC P   | CAC H   | CGC R   | C
 C | CTA L   | CCA P   | CAA Q   | CGA R   | A
 C | CTG L(s)| CCG P   | CAG Q   | CGG R   | G 
 --+---------+---------+---------+---------+--
 A | ATT I   | ACT T   | AAT N   | AGT S   | T
 A | ATC I   | ACC T   | AAC N   | AGC S   | C
 A | ATA I   | ACA T   | AAA K   | AGA R   | A
 A | ATG M(s)| ACG T   | AAG K   | AGG R   | G 
 --+---------+---------+---------+---------+--
 G | GTT V   | GCT A   | GAT D   | GGT G   | T
 G | GTC V   | GCC A   | GAC D   | GGC G   | C
 G | GTA V   | GCA A   | GAA E   | GGA G   | A
 G | GTG V   | GCG A   | GAG E   | GGG G   | G 
 --+---------+---------+---------+---------+-- 
>>>

Biopython usa esta tabela para traduzir o DNA em proteína, bem como para encontrar o códon de parada.