Argomenti Trattati:

[1] Biosequenze
[2] Parsing

Parte 1 - BIOSEQUENZE
Autore: Davide FARO'

PREFAZIONE

Il tutorial che segue è tratto dalla documentazione ufficiale su Biopython.

[Ultima release: Biopython 1.44]

Bipython-1.44.tar.gz

Bipython-1.44.zip

Biopython Official Tutorial

Documentazione completa delle Classi [API Documentation]

Esso è stato volutamente diviso in diverse sezioni in modo da rendere più pratica e veloce la localizzazione degli argomenti di interesse e cominciare a lavorare con questa libreria. L'autore da per scontata la conoscenza del linguaggio Python e di alcuni concetti di Bioinformatica e, considerando il fatto che la libreria Biopython è molto complessa ed in continua evoluzione, il materiale inserito non pretende di essere esaustivo sull'argomento.

Python 2.5 Quick Reference

COSA E' BIOPYTHON ?

Biopython è una complessa libreria di classi scritte in Python che raccoglie molteplici "oggetti biologici" che possono trovare applicazione pratica nello sviluppo di molti tools.


LAVORARE CON LE BIOSEQUENZE

L’ oggetto di primaria importanza in bioinformatica è la sequenza, una successione di caratteri che possono rappresentare DNA, RNA o Proteine. L’approccio utilizzato da Biopython per rappresentare una sequenza è quello di utilizzare una classe nella quale stipare le informazioni necessarie a trattare la sequenza stessa, come oggetto complesso o come una normale stringa.

La classe Seq definita nel file Bio/Seq.py contiene due importanti proprietà:

data: qui è conservata la sequenza
alphabet: un oggetto che descrive come considerare ogni singolo carattere della sequenza

L’oggetto alphabet è importante in quanto, in bioinformatica, una sequenza non è una normale stringa e alphabet ci aiuta ad avere la sicurezza di stare lavorando con un oggetto specifico: DNA, RNA o Proteina. Gli alfabeti sono definiti nel modulo Bio/Alphabet e sono quelli normalmente definiti dallo standard IUPAC http://www.chem.qmw.ac.uk/iupac.

Bio/Alpahabet/IUPAC.py contiene le definizioni di base per DNA, RNA e Proteine ma è un modulo che può essere esteso, la classe base per istanziare una proteina è IUPACProtein ma esiste anche una estensione di essa ExtendedIUPACProtein che definisce elementi addizionali non comuni quali: “Asx” (Asparagina), “Sec” (Selenocisteina) etc. Per il DNA la scelta cade tra le classi: IUPACUnambiguousDNA per la definizione dei caratteri base del DNA, IUPACAmbiguousDNA per tutti gli altri usi possibili ed ExtendedIUPACDNA che permette l’estensione dei caratteri base, lo stesso vale per l’RNA.

I vantaggi nell’uso degli alfabeti sono 2: primo, questi danno una idea del tipo di dato contenuto nella proprietà data e secondo, questi costringono a usare oggetti sequenza coerenti da un punto di vista biologico.

Nell’esempio che segue creremo un sequenza non ambigua di DNA, il costruttore della classe Seq prende in input l’oggetto data che è la stringa e l’oggetto alphabet.

>>> from Bio.Alphabet import IUPAC
>>> my_alpha = IUPAC.unambiguous_dna
>>> from Bio.Seq import Seq
>>> my_seq = Seq(’GATCGATGGGCCTATATAGGATCGAAAATCGC’, my_alpha)
>>> print my_seq
Seq(’GATCGATGGGCCTATATAGGATCGAAAATCGC’, IUPACUnambiguousDNA())

L’oggetto sequenza appena creato può essere trattato come una normale stringa python, proviamo ad eseguire una operazione di slicing sull’oggetto sequenza:

>>> my_seq[4:12]
Seq(’GATGGGCC’, IUPACUnambiguousDNA())

Due cose sono degne di nota nell’esempio precedente: la sequenza è indicizzata come in un normale array, cioè partendo da zero, la seconda cosa è che le operazioni sulle sequenze sono performanti come quelle sulle stringhe e gli oggetti risultanti conservano le caratteristiche della sequenza come gli alfabeti, per esempio:

>>> len(my_seq)
32
>>> new_seq = my_seq[0:5]
>>> print new_seq
Seq(’GATCG’, IUPACUnambiguousDNA())
>>> my_seq + new_seq
Seq(’GATCGATGGGCCTATATAGGATCGAAAATCGCGATCG’, IUPACUnambiguousDNA())
>>> my_seq[5]
’A’
>>> my_seq == new_seq
True

Come vedete, la caratterizzazione data dagli alfabeti viene conservata. Questo ci permette di non confondere le cose, nell’esempio che segue proviamo a creare due sequenze di tipo diverso, poi si proverà a fonderle assieme ma …

>>> protein_seq = Seq(’EVRNAK’, IUPAC.protein)
>>> dna_seq = Seq(’ACGT’, IUPAC.unambiguous_dna)
>>> protein_seq + dna_seq
Traceback (most recent call last):
File "stdin", line 1, in ?
File "/usr/local/lib/python1.6/site-packages/Bio/Seq.py", line 42, in __add__
raise TypeError, ("incompatable alphabets", str(self.alphabet),
TypeError: (’incompatable alphabets’, ’IUPACProtein()’, ’IUPACUnambiguousDNA()’)

… si riceve un messaggio di errore dall’interprete che si accorge di aver a che fare con oggetti diversi.

Se si vuole trasformare l’oggetto sequenza in una normale stringa, basta chiamare il metodo tostring() sull’oggetto sequenza.

>>> my_seq.tostring()
’GATCGATGGGCCTATATAGGATCGAAAATCGC’

L’oggetto sequenza è immutabile di default (Biopython mette a disposizione una classse per creare un oggetto sequenza mutabile: MutableSeq). Nell’esempio che segue si cercherà di cambiare il valore nella posizione 5.

>>> my_seq[5] = ’G’
Traceback (most recent call last):
File "stdin", line 1, in ?
AttributeError: ’Seq’ instance has no attribute ’__setitem__’

Naturalmente se si vuole si può trasformare la sequenza immutabile in una mutabile, invocando il metodo tomutable() come segue:

>>> mutable_seq = my_seq.tomutable()
>>> print mutable_seq
MutableSeq(’GATCGATGGGCCTATATAGGATCGAAAATCGC’, IUPACUnambiguousDNA())
>>> mutable_seq[5] = ’T’
>>> print mutable_seq
MutableSeq(’GATCGTTGGGCCTATATAGGATCGAAAATCGC’, IUPACUnambiguousDNA())
>>> mutable_seq.remove(’T’)
>>> print mutable_seq
MutableSeq(’GACGTTGGGCCTATATAGGATCGAAAATCGC’, IUPACUnambiguousDNA())
>>> mutable_seq.reverse()
>>> print mutable_seq
MutableSeq(’CGCTAAAAGCTAGGATATATCCGGGTTGCAG’, IUPACUnambiguousDNA())

TRASCRIZIONE E TRADUZIONE

Vediamo adesso come applicare un pò di biologia alle sequenze. Biopython contiene due moduli importanti per la trascrizione e per la traduzione, nell’esempio che segue trascriviamo la nostra sequenza di DNA in una di RNA.

>>> from Bio import Transcribe
>>> transcriber = Transcribe.unambiguous_transcriber
>>> my_rna_seq = transcriber.transcribe(my_seq)
>>> print my_rna_seq
Seq(’GAUCGAUGGGCCUAUAUAGGAUCGAAAAUCGC’, IUPACUnambiguousRNA())

La nuova sequenza di RNA generata viene creata con il giusto alfabeto, l’operazione è reversibile.

>>> transcriber.back_transcribe(my_rna_seq)
Seq(’GATCGATGGGCCTATATAGGATCGAAAATCGC’, IUPACUnambiguousDNA())

Per la traduzione, al fine di generare la corrispettiva proteina, da un oggetto sequenza di DNA, Biopython usa delle tabelle di traduzione. Le scelte principali ricadono su due di queste tabelle, quella di traduzione standard per vertebrati e quella specifica per DNA mitocondriale di vertebrati, indicate con due numeri: 1 e 2 rispettivamente.

>>> from Bio import Translate
>>> standard_translator = Translate.unambiguous_dna_by_id[1]
>>> mito_translator = Translate.unambiguous_dna_by_id[2]
>>> my_seq = Seq(’GCCATTGTAATGGGCCGCTGAAAGGGTGCCCGA’, IUPAC.unambiguous_dna)
>>> standard_translator.translate(my_seq)
Seq(’AIVMGR*KGAR’, IUPACProtein())
>>> mito_translator.translate(my_seq)
Seq(’AIVMGRWKGAR’, IUPACProtein())

L'oggetto traduttore, traduce alla cieca fino alla fine della sequenza, se in questa ci sono punti di stop segnati da un carattere '*', si può interrompere la traduzione fino a quel punto con il metodo translate_to_stop(sequenza)

>>> standard_translator.translate_to_stop(my_seq)
Seq(’AIVMGR’, IUPACProtein())

E’ ovviamente possibile effettuare l'operazione contraria, dalla sequenza di aminoacidi (Proteina) risalire alla sequenza di DNA che l’ha generata.

>>> my_protein = Seq(’AVMGRWKGGRAAG’, IUPAC.protein)
>>> standard_translator.back_translate(my_protein)
Seq(’GCTGTTATGGGTCGTTGGAAGGGTGGTCGTGCTGCTGGT’, IUPACUnambiguousDNA())

[Torna su]