<jupyter_start><jupyter_text>BiopythonBiopython è un package che mette a disposizione funzionalità in ambito bioinformatico, principalmente manipolare sequenze, leggere i formati standard tipici della Bioinformatica (ad esempio `EMBL`, `FASTA`, `FASTQ`) e accedere alle banche dati. Installare il package `Bio` di Biopython.<jupyter_code>!conda install -y -c conda-forge biopython<jupyter_output><empty_output><jupyter_text>Importare il package `Bio`.<jupyter_code>import Bio<jupyter_output><empty_output><jupyter_text>Per vedere cosa contiene basta usare la funzione `help()` e passare come argomento il nome del package.<jupyter_code>help(Bio)<jupyter_output><empty_output><jupyter_text>Cosa vediamo?- `Seq` e `MutableSeq`, classi per rappresentare una sequenza biologica (DNA, RNA o proteina)- `SeqRecord`, classe per rappresentare una sequenza biologica annotata- `Bio.SeqIO`,  interfaccia input/output per formati standard (`EMBL`, `FASTA`, `FASTQ`, etc.)  Oggetti `Seq` e `MutableSeq` per rappresentare sequenze Le classi `Seq` e `MutableSeq` appartengono al modulo `Seq` che definisce le classi per manipolare sequenze biologiche. `Seq` rappresenta una sequenza immutabile mentre `MutableSeq` rappresenta una sequenza mutabile. Importare il modulo `Seq`.<jupyter_code>from Bio import Seq<jupyter_output><empty_output><jupyter_text>Per vedere cosa contiene basta usare la funzione `help()` e passare come argomento il nome `Seq`.<jupyter_code>help(Bio.Seq)<jupyter_output><empty_output><jupyter_text>Importare le due classi `Seq` e `MutableSeq`.<jupyter_code>from Bio.Seq import Seq
from Bio.Seq import MutableSeq<jupyter_output><empty_output><jupyter_text>Per vedere cosa contengono basta usare la funzione `help()` e passare come argomento il nome delle classi.<jupyter_code>help(Seq)
help(MutableSeq)<jupyter_output><empty_output><jupyter_text>Costruzione di un oggetto di tipo `Seq` L'espressione:           Seq(primary_string)     restituisce un oggetto `Seq` che rappresenta la sequenza primaria specificata da `primary_string` passata come argomento.Costruire una sequenza `my_seq1` che ha sequenza primaria `GTGGATTGCCGGAAATTT`.<jupyter_code>my_seq1 = Seq('GTGGATTGCCGGAAATTT')<jupyter_output><empty_output><jupyter_text>Stampare la sequenza.<jupyter_code>my_seq1<jupyter_output><empty_output><jupyter_text>Convertire la sequenza in un oggetto di tipo `str`.<jupyter_code>str(my_seq1)<jupyter_output><empty_output><jupyter_text>Lunghezza di una sequenza La funzione `len()` restituisce la lunghezza della sequenza passata come argomento.Ottenere la lunghezza della sequenza `my_seq1`<jupyter_code>len(my_seq1)<jupyter_output><empty_output><jupyter_text>Qualche metodo degli oggetti di tipo `Seq` - `lower()` e `upper()` restituiscono la versione in minuscolo e in maiuscolo della sequenza invocante. Ottenere la versione in minuscolo della sequenza `my_seq1`.<jupyter_code>my_seq1.lower()<jupyter_output><empty_output><jupyter_text>- `find()` restituisce la prima occorrenza di una sottostringa nella sequenza invocante. Produrre la prima occorrenza di `GATT` nella sequenza `my_seq1`.<jupyter_code>my_seq1.find('GATT')<jupyter_output><empty_output><jupyter_text>- `count()` restituisce il numero di occorrenze non sovrapposte di una data sottostringa nella sequenza invocante. Creare la sequenza `AAAAAA` e contare il numero di occorrenze non sovrapposte di `AAA`.<jupyter_code>Seq('AAAAA').count('AA')<jupyter_output><empty_output><jupyter_text>- `count_overlap()` restituisce il numero di occorrenze sovrapposte di una data sottostringa nella sequenza invocante. Contare il numero di occorrenze sovrapposte di `AAA` nella sequenza precedente.<jupyter_code>Seq('AAAAA').count_overlap('AA')<jupyter_output><empty_output><jupyter_text>- `tomutable()` restituisce una copia mutabile (oggetto di tipo `MutableSeq`) della sequenza invocante. Creare una sequenza mutabile a partire dalla sequenza immutabile che ha sequenza primaria `ACTTTGAAAG`.<jupyter_code>Seq('ACTTTGAAAG').tomutable()<jupyter_output><empty_output><jupyter_text>Accesso alla sequenza L'espressione:    my_seq[my_index]    restituisce il carattere alla posizione di indice `my_index` della sequenza `my_seq`.Accedere al quarto carattere della sequenza `my_seq1`.<jupyter_code>my_seq1
my_seq1[3]<jupyter_output><empty_output><jupyter_text>L'espressione di *slicing*:    my_seq[start:end:step]    restituisce i caratteri della sequenza `my_seq` a partire dalla posizione di indice `start` fino alla posizione immediatamente prima a quella di indice `end`, con un passo `step`.Accedere alla sottosequenza di `my_seq1` che va dal quinto al decimo carattere.<jupyter_code>my_seq1
my_seq1[4:10]<jupyter_output><empty_output><jupyter_text>Ottenere tramite un'operazione di *slicing* il reverse di `my_seq1`.<jupyter_code>my_seq1[::-1]<jupyter_output><empty_output><jupyter_text>Verifica della presenza di una sottostringa in una sequenzaL'espressione:    my_str in my_seqrestituisce `True` se la stringa `my_str` occorre nella sequenza `my_seq`Verificare la presenza della stringa `CC` nella sequenza `my_seq1`.<jupyter_code>my_seq1
'CC' in my_seq1<jupyter_output><empty_output><jupyter_text>Attraversamento di una sequenzaL'operatore `in` può essere utilizzato per attraversare i caratteri di una sequenza, nel seguente modo:    for my_char in my_seq:        do_something    Attraversare la sequenza `my_seq1` e stampare ogni singolo carattere.<jupyter_code>for c in my_seq1:
    print(c)<jupyter_output><empty_output><jupyter_text>Concatenazione di sequenzeL'operatore `+` permette di concatenare sequenze.Concatenare due sequenze di DNA uguali a `ACGT`.<jupyter_code>Seq('ACGT') + Seq('ACGT')<jupyter_output><empty_output><jupyter_text>Ripetizione di sequenzeL'operatore `*` permette di ripetere sequenze.Ripetere due volte una sequenza di DNA uguale a `ACGT`.<jupyter_code>Seq('ACGT') * 2<jupyter_output><empty_output><jupyter_text>Confronto tra sequenzeL'espressione:    my_seq1 == my_seq2    restituisce `True` se la sequenza primaria di `my_seq1` è uguale a quella di `my_seq2`.Confrontare due sequenze con sequenza primaria `ACGT`.<jupyter_code>Seq('ACGT') == Seq('ACGT')<jupyter_output><empty_output><jupyter_text>Complement e Reverse&Complement di una sequenza di DNA o di RNA    - Il metodo `complement()` restituisce il complemento della sequenza invocante.Costruire la sequenza `ACGTGAGGACCCTTT` e ottenere il suo complement.<jupyter_code>Seq('ACGTGAGGACCCTTT').complement()<jupyter_output><empty_output><jupyter_text>- Il metodo `reverse_complement()` restituisce il reverse&complement della sequenza invocante.Costruire la sequenza `ACGTGAGGACCCTTT`, e ottenere il suo reverse&complement.<jupyter_code>Seq('ACGTGAGGACCCTTT').reverse_complement()<jupyter_output><empty_output><jupyter_text>**NOTA BENE**`: complement()` e `reverse_complement()` tengono conto dell'alfabeto ambiguo di DNA e di RNA (cioé dello IUPAC CODE).L'alfabeto ambiguo di DNA o di RNA è `{A,C,G,T|U,R,Y,W,S,M,K,H,B,V,D,N}` con `T` se DNA e `U` se RNA. Cioè è l'estensione dell'alfabeto dei quattro nucleoitidi con lettere che rappresentano ambiguità tra nucleotidi.Precisamente:    R 	A or G    Y 	C or T|U    S 	G or C    W 	A or T|U    K 	G or T|U    M 	A or C    B 	C or G or T|U    D 	A or G or T|    H 	A or C or T|U    V 	A or C or G    N 	any baseCostruire la sequenza `BBBB` e ottenere il suo complement.<jupyter_code>Seq('BBBB').complement()<jupyter_output><empty_output><jupyter_text>Trascrizione di una sequenza di DNA- Il metodo `transcribe()` restituisce il risultato della trascrizione della sequenza di DNA invocante, intesa come sostituzione di tutti i caratteri `T` con caratteri `U`.Costruire la sequenza `ACGTGAGGACCCTTT` e ottenere la sua trascrizione.<jupyter_code>Seq('ACGTGAGGACCCTTT').transcribe()<jupyter_output><empty_output><jupyter_text>- Il metodo `back_transcribe()` restituisce il risultato della retrotrascrizione della sequenza di RNA invocante, intesa come sostituzione di tutti i caratteri `U` con caratteri `T`.Costruire la sequenza `ACGUGAGGACCCUUU` e ottenere la sua retrotrascrizione.<jupyter_code>Seq('ACGUGAGGACCCUUU').back_transcribe()<jupyter_output><empty_output><jupyter_text>Traduzione di una sequenza di DNA o di RNA- Il metodo `translate()` restituisce il risultato della traduzione della sequenza di DNA o di RNA invocante secondo il codice genetico. La lunghezza della sequenza invocante deve essere un multiplo di tre.Costruire la sequenza `ACGUGAGGACCCUUU` e ottenere la sua trascrizione.<jupyter_code>Seq('ACGUGAGGACCCUUU').translate()<jupyter_output><empty_output><jupyter_text>Costruire la sequenza `ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG` e ottenere la sua traduzione.<jupyter_code>Seq('ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG').translate()<jupyter_output><empty_output><jupyter_text>Specificando l'attributo `to_stop` uguale a `True`, la traduzione viene fermata al primo codone di stop incontrato. Ottenere la traduzione della sequenza precedente fino al primo codone di stop che si incontra.<jupyter_code>Seq('ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG').translate(to_stop = True)<jupyter_output><empty_output><jupyter_text>Sequenze mutabiliLe sequenze mutabili sono oggetti di tipo `MutableSeq`. Creare la sequenza mutabile `ACTTTGAAAG`.<jupyter_code>my_seq = MutableSeq('ACTTTGAAAG')<jupyter_output><empty_output><jupyter_text>Cambiare in una `T` la prima base.<jupyter_code>my_seq[0] = 'T'
my_seq<jupyter_output><empty_output><jupyter_text>Qualche metodo degli oggetti di tipo `MutableSeq` - `remove()` rimuove dalla sequenza invocante la prima occorrenza del carattere passato come argomento. Costruire la sequenza `AAACCCTTTGGG` nella variabile `my_seq`.<jupyter_code>my_seq = MutableSeq('AAACCCTTTGGG')<jupyter_output><empty_output><jupyter_text>Rimuovere dalla sequenza `my_seq` la prima occorrenza di `C`.<jupyter_code>my_seq.remove('C')
my_seq<jupyter_output><empty_output><jupyter_text>- `reverse()` opera il reverse sulla sequenza invocante. Invertire la sequenza `my_seq`.<jupyter_code>my_seq.reverse()
my_seq<jupyter_output><empty_output><jupyter_text>- `complement()` opera il complement sulla sequenza invocante. Trasformare in complement la sequenza `my_seq`.<jupyter_code>my_seq.complement()
my_seq<jupyter_output><empty_output><jupyter_text>- `reverse_complement()` opera il reverse&complement sulla sequenza invocante. Trasformare in reverse&complement la sequenza `my_seq`.<jupyter_code>my_seq.reverse_complement()
my_seq<jupyter_output><empty_output><jupyter_text>- `toseq()` restituisce una copia immutabile della sequenza invocante. Ottenere dalla sequenza `my_seq` un oggetto immutabile di tipo `Seq`.<jupyter_code>my_seq.toseq()<jupyter_output><empty_output><jupyter_text>L'oggetto di tipo `SeqRecord` La classe `SeqRecord` appartiene al modulo `SeqRecord` e permette di rappresentare (e manipolare) sequenze annotate.Importare il modulo `SeqRecord`.<jupyter_code>from Bio import SeqRecord<jupyter_output><empty_output><jupyter_text>Per vedere cosa contiene basta invocare la funzione `help()` passando come argomento il nome del modulo.<jupyter_code>help(Bio.SeqRecord)<jupyter_output><empty_output><jupyter_text>La classe `SeqRecord` rappresenta una sequenza annotata, cioè un oggetto di tipo `Seq` con l'aggiunta di informazioni.<jupyter_code>from Bio.SeqRecord import SeqRecord<jupyter_output><empty_output><jupyter_text>Per vedere cosa contiene basta invocare la funzione `help()` passando come argomento il nome della classe.<jupyter_code>help(SeqRecord)<jupyter_output><empty_output><jupyter_text>Un oggetto di tipo `SeqRecord` contiene i seguenti attributi:- `seq`: oggetto di tipo `Seq` che rappresenta la sequenza biologica- `id`: oggetto di tipo `str` che fornisce l'identificatore univoco (*Accession Number*) della sequenza- `name`: oggetto di tipo `str` che fornisce il nome della sequenza (può anche essere l'*Accession Number* stesso)- `description`: oggetto di tipo `str` che fornisce la descrizione della sequenza- `annotations`: oggetto di tipo `dict` che fornisce le informazioni sulla sequenza. Le chiavi sono i nomi delle informazioni e i valori sono le informazioni associate- `letter_annotations`: oggetto di tipo `dict` che annota la sequenza lettera per lettera. Le chiavi sono i nomi delle informazioni e i valori sono liste che forniscono le informazioni per ognuna delle lettere della sequenza- `features`: oggetto di tipo `list` che contiene oggetti di tipo `SeqFeature` che forniscono le *features* annotate sulla sequenza- `dbxrefs`: oggetto di tipo `list` che contiene oggetti di tipo `str` che forniscono le cross-references alle banche dati in cui è memorizzata la sequenzaLa classe `SeqRecord` è il tipo di oggetto che viene manipolato dalle funzioni di input/output del modulo `SeqIO` di Biopython, che è il modulo per leggere/scrivere sequenze nei formati standard (`EMBL`,`FASTA`, `FASTQ`, etc.), .  Costruzione di una sequenza annotata "da zero" Di solito gli oggetti di tipo `SeqRecord` vengono ottenuti dalla lettura di un file in uno dei formati standard della Bioinformatica, ma una sequenza annotata può anche essere costruita da zero tramite il suo costruttore `SeqRecord()`, a cui può essere passato come argomento un oggetto di tipo `Seq`.Costruire la sequenza annotata con sequenza primaria `AGCCGTTTTAAAAAGCCGTTTTAAAAAGCCGTTTTAAAAAGCCGTTTTAAAAAGCCGTTTTAAAA` nella variabile `annotated_sequence`.<jupyter_code>annotated_sequence = SeqRecord(Seq('AGCCGTTTTAAAAAGCCGTTTTAAAAAGCCGTTTTAAAAAGCCGTTTTAAAAAGCCGTTTTAAAA'))<jupyter_output><empty_output><jupyter_text>Stampare le sequenza.<jupyter_code>print(annotated_sequence)
annotated_sequence.seq<jupyter_output><empty_output><jupyter_text>In questo caso, solo l'attributo `seq` non è *unknown* e contiene la sequenza passata come argomento.L'attributo `annotations` contiene un dizionario vuoto.<jupyter_code>annotated_sequence.annotations<jupyter_output><empty_output><jupyter_text>Assegnare all'attributo `annotations` il dizionario `{'type' : 'dna_molecule'}`.<jupyter_code>annotated_sequence.annotations = {'type' : 'dna_molecule'}<jupyter_output><empty_output><jupyter_text>L'attributo `letter_annotations` contiene un dizionario vuoto.<jupyter_code>annotated_sequence.letter_annotations<jupyter_output><empty_output><jupyter_text>L'attributo `features` contiene una lista vuota.<jupyter_code>annotated_sequence.features<jupyter_output><empty_output><jupyter_text>Associare a questo punto alla sequenza annotata l'identificatore univoco `AA00000` e il nome `AA00000`,<jupyter_code>annotated_sequence.id = 'AA00000'
annotated_sequence.name = 'AA00000'<jupyter_output><empty_output><jupyter_text>Aggiungere la descrizione `Questa e' una sequenza annotata di prova`.<jupyter_code>annotated_sequence.description = "Questa e' una sequenza annotata di prova"
print(annotated_sequence)<jupyter_output><empty_output><jupyter_text>Ottenere la sequenza primaria della sequenza annotata come oggetto di tipo `str`.<jupyter_code>str(annotated_sequence)<jupyter_output><empty_output><jupyter_text>Ottenere la prima base.<jupyter_code>annotated_sequence[0]<jupyter_output><empty_output><jupyter_text>Ottenere le prime dieci basi.<jupyter_code>annotated_sequence[:10]<jupyter_output><empty_output><jupyter_text>Ottenere la versione in minuscolo.<jupyter_code>annotated_sequence.lower()<jupyter_output><empty_output><jupyter_text>Formattazione di una sequenza annotata Il metodo `format()` degli oggetti di tipo `SeqRecord` restituisce la stringa ottenuta formattando la sequenza annotata invocante nel formato specificato dalla stringa passata come argomento.Formattare in `FASTA` la sequenza annotata `annotated_sequence`.<jupyter_code>annotated_sequence
print(annotated_sequence.format('fasta'))<jupyter_output><empty_output><jupyter_text>Il package `SeqIO` `SeqIO` è il modulo per leggere/scrivere un file in uno dei formati standard (`EMBL`, `FASTA`, `FASTQ`, etc.).<jupyter_code>from Bio import SeqIO<jupyter_output><empty_output><jupyter_text>Per vedere cosa contiene basta invocare la funzione `help()` passando come argomento il nome del modulo.<jupyter_code>help(SeqIO)<jupyter_output><empty_output><jupyter_text>Funzioni principali- `read()` legge un file composto da un solo *record* e restituisce un oggetto di tipo `SeqRecord`:        read(file_name, format)- `parse()` legge un file composto da più *record* e restituisce un generatore di oggetti di tipo `SeqRecord`:        parse(file_name, format)        - `write()` scrive record di tipo `SeqRecord` in un file in un certo formato:        write(records, file_name, format) **ESERCIZIO1**: Leggere l'unico *record* del file `ENm006.fa`, che contiene una sequenza genomica di riferimento, e assegnarlo alla variabile `fasta_record`.<jupyter_code>fasta_record = SeqIO.read('./ENm006.fa', 'fasta')<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `seq` dell'oggetto `SeqRecord` restituito.<jupyter_code>fasta_record.seq<jupyter_output><empty_output><jupyter_text>Ottenere la sequenza primaria come oggetto di tipo `str`.<jupyter_code>str(fasta_record.seq)<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `id`.<jupyter_code>fasta_record.id<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `name`.<jupyter_code>fasta_record.name<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `description`.<jupyter_code>fasta_record.description<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `annotations`.<jupyter_code>fasta_record.annotations<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `letter_annotations`.<jupyter_code>fasta_record.letter_annotations<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `features`.<jupyter_code>fasta_record.features<jupyter_output><empty_output><jupyter_text>Produrre l'attributo `dbxrefs`.<jupyter_code>fasta_record.dbxrefs<jupyter_output><empty_output><jupyter_text>Scrivere il record in un file in formato `embl` dopo essersi assicurati che l'alfabeto sia quello del DNA.<jupyter_code>fasta_record.seq.alphabet = Bio.Alphabet.DNAAlphabet()
SeqIO.write(fasta_record, './prova.embl', 'embl')<jupyter_output><empty_output><jupyter_text>**ESERCIZIO2**: Leggere i *record* del file `ests.fa`, contenente frammenti di trascritto (ESTs) relativi a un gene umano, e assegnarli al generatore `fasta_records_gen`.<jupyter_code>fasta_records_gen = SeqIO.parse('./ests.fa', 'fasta')<jupyter_output><empty_output><jupyter_text>I *record* (oggetti `SeqRecord`) possono essere estratti uno alla volta dal generatore tramite scansione con un ciclo `for`. Stampare uno dopo l'altro i *record* separandoli con la stringa `//`.<jupyter_code>for r in fasta_records_gen:
    print(r)
    print('//')<jupyter_output><empty_output><jupyter_text>In alternativa, i *record* possono essere estratti in una lista (da processare in seguito) invocando la funzione `list()` e passando come argomento il generatore stesso.**NB**: una volta che il generatore è stato *consumato*, esso risulta vuoto. Quindi prima di costruire la lista occorre invocare di nuovo il metodo `parse()` per ricostruirlo.<jupyter_code>fasta_record_gen = SeqIO.parse('ests.fa', 'fasta')<jupyter_output><empty_output><jupyter_text>Ottenere dal generatore la lista dei *record* e assegnarla alla variabile `fasta_record_list`.<jupyter_code>fasta_record_list = list(fasta_record_gen)
fasta_record_list<jupyter_output><empty_output><jupyter_text>Ottenere il numero dei *record* (numero degli ESTs) contenuti nel file `ests.fa`.<jupyter_code>len(fasta_record_list)<jupyter_output><empty_output><jupyter_text>Estrarre per il primo EST:- la sequenza primaria (come oggetto di tipo `str`)<jupyter_code>str(fasta_record_list[0].seq)<jupyter_output><empty_output><jupyter_text>- l'identificatore univoco<jupyter_code>fasta_record_list[0].id<jupyter_output><empty_output><jupyter_text>- il nome<jupyter_code>fasta_record_list[0].name<jupyter_output><empty_output><jupyter_text>- la descrizione<jupyter_code>fasta_record_list[0].description<jupyter_output><empty_output><jupyter_text>Ottenere la formattazione `FASTA` del primo EST e stamparla.<jupyter_code>print(fasta_record_list[0].format('fasta'))<jupyter_output><empty_output><jupyter_text>**ESERCIZIO3**: leggere il file `input.fq`, che contiene quattro reads in formato `FASTQ`, e assegnarli alla variabile `fastq_records`.<jupyter_code>fastq_records = SeqIO.parse('./input.fq', 'fastq')<jupyter_output><empty_output><jupyter_text>Ottenere la lista dei *records* (come oggetto di tipo `list`) e assegnarla alla variabile `fastq_record_list`.<jupyter_code>fastq_record_list = list(fastq_records)<jupyter_output><empty_output><jupyter_text>Ottenere la sequenza primaria (come oggetto di tipo `str`) del primo *record* (read).<jupyter_code>str(fastq_record_list[0].seq)<jupyter_output><empty_output><jupyter_text>Ottenere l'identificatore del primo *record*.<jupyter_code>fastq_record_list[0].id<jupyter_output><empty_output><jupyter_text>Ottenere il dizionario delle annotazioni per lettera del primo *record*.<jupyter_code>fastq_record_list[0].letter_annotations<jupyter_output><empty_output><jupyter_text>Ottenere la formattazione in `FASTQ` del primo *record* e stamparla.<jupyter_code>print(fastq_record_list[0].format('fastq'))<jupyter_output><empty_output><jupyter_text>**ESERCIZIO4**: leggere l'unico record del file `M10051.txt`, che contiene una sequenza di mRNA in formato `EMBL`, e assegnarlo alla variabile `embl_record`.<jupyter_code>embl_record = SeqIO.read('./M10051.txt', 'embl')<jupyter_output><empty_output><jupyter_text>Ottenere la sequenza primaria del record (come oggetto di tipo `str`).<jupyter_code>str(embl_record.seq)<jupyter_output><empty_output><jupyter_text>Produrre tutti gli attributi del record.<jupyter_code>embl_record.id
embl_record.name
embl_record.description
embl_record.annotations
embl_record.letter_annotations
embl_record.features
embl_record.dbxrefs<jupyter_output><empty_output><jupyter_text>L'attributo `features` fornisce una lista di oggetti di tipo `SeqFeature` che rappresentano le *features* annotate sulla sequenza.Un oggetto di tipo `SeqFeature` possiede i seguenti attributi:- `type`: stringa che definisce il tipo di *feature* rappresentata- `location`: oggetto di tipo `FeatureLocation` che fornisce la localizzazione della *feature* sulla sequenzaUn oggetto di tipo `FeatureLocation` possiede a sua volta i seguenti attributi:- `start`: oggetto di tipo `ExactPosition` che fornisce lo start della localizzazione- `end`: oggetto di tipo `ExactPosition` che fornisce l'end della localizzazioneLa *feature* con `type` uguale a `CDS` rappresenta la coding sequence della sequenza. Accedere quindi al terzo oggetto della lista delle *features* (cioé la coding sequence della sequenza di mRNA) e recuperare lo start e l'end della coding sequence.<jupyter_code>cds_start = int(embl_record.features[2].location.start)
cds_end = int(embl_record.features[2].location.end)<jupyter_output><empty_output><jupyter_text>**NB**: la start position viene fornita 0-based mentre l'end position viene fornita 1-based.Effettuare lo slicing della sequenza per ottenere la coding sequence.<jupyter_code>cds_sequence = embl_record[cds_start:cds_end]<jupyter_output><empty_output><jupyter_text>Formattare la coding sequence in formato `FASTA` e stamparla.<jupyter_code>print(cds_sequence.format('fasta'))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09278747433264888, 'fraction_numerical': 0.0038501026694045173, 'mean_word_length': 8.426209677419354, 'pattern_counts': {'":': 0, '<': 369, '<?xml version=': 0, '>': 369, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '92', 'dir': 'jupyter-structured-clean-dedup', 'id': '399906', 'license': 'CC0-1.0', 'n_tokens_mistral': 8473, 'n_tokens_neox': 8387, 'n_words': 2025, 'path': 'laboratorio/lezione15-26nov21/lezione-biopython.ipynb', 'repo_name': 'bioinformatica-corso/Materiale', 'size': '23376'}