Biopython: operaciones de secuencia avanzadas

En este capítulo, discutiremos algunas de las funciones de secuencia avanzadas proporcionadas por Biopython.

Complemento y complemento inverso

La secuencia de nucleótidos se puede complementar a la inversa para obtener una nueva secuencia. Además, la secuencia complementada se puede complementar a la inversa para obtener la secuencia original. Biopython proporciona dos métodos para hacer esta funcionalidad:complement y reverse_complement. El código para esto se da a continuación:

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

Aquí, el método del complemento () permite complementar una secuencia de ADN o ARN. El método reverse_complement () complementa e invierte la secuencia resultante de izquierda a derecha. Se muestra a continuación:

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

Biopython usa la variable ambiguous_dna_complement proporcionada por Bio.Data.IUPACData para realizar la operación 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'} 
>>>

Contenido de GC

Se prevé que la composición de la base del ADN genómico (contenido de GC) afecte significativamente el funcionamiento del genoma y la ecología de las especies. El contenido de GC es el número de nucleótidos de GC dividido por el total de nucleótidos.

Para obtener el contenido de nucleótidos de GC, importe el siguiente módulo y realice los siguientes pasos:

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

Transcripción

La transcripción es el proceso de cambiar la secuencia de ADN en secuencia de ARN. El proceso de transcripción biológica real está realizando un complemento inverso (TCAG → CUGA) para obtener el ARNm considerando el ADN como hebra molde. Sin embargo, en bioinformática y por lo tanto en Biopython, normalmente trabajamos directamente con la cadena codificante y podemos obtener la secuencia de ARNm cambiando la letra T por U.

Un ejemplo simple de lo anterior es el siguiente:

>>> 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 revertir la transcripción, T se cambia a U como se muestra en el siguiente código:

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

Para obtener la hebra de la plantilla de ADN, complete a la inversa el ARN transcrito como se indica a continuación:

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

Traducción

La traducción es un proceso de traducción de la secuencia de ARN en secuencia de proteína. Considere una secuencia de ARN como se muestra a continuación:

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

Ahora, aplique la función translate () al código anterior -

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

La secuencia de ARN anterior es simple. Considere la secuencia de ARN, AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA y aplique translate () -

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

Aquí, los codones de parada se indican con un asterisco '*'.

En el método translate () es posible detenerse en el primer codón de parada. Para realizar esto, puede asignar to_stop = True en translate () de la siguiente manera:

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

Aquí, el codón de parada no se incluye en la secuencia resultante porque no contiene uno.

Tabla de traducción

La página de códigos genéticos del NCBI proporciona una lista completa de las tablas de traducción utilizadas por Biopython. Veamos un ejemplo de tabla estándar para visualizar el 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 tabla para traducir el ADN en proteína y para encontrar el codón de parada.