Biopython Fundamentals

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 1 di 18. Trattare una sequenza di DNA come una normale string di testo funziona bene finché non hai bisogno del filamento opposto. La semplice string manipulation in Python crolla quando ti rendi conto che la trascrizione biologica non riguarda solo la sostituzione di lettere, ma la direzionalità e codici genetici distinti. È proprio per questo che usiamo Introduzione a Biopython e l'oggetto Seq. Alla base, una sequenza biologica è una string di lettere che rappresentano molecole come DNA, RNA o proteine. In Biopython, la struttura dati centrale è l'oggetto Seq. Fa il wrap del comportamento standard delle string Python, ma aggiunge la consapevolezza biologica direttamente ai dati. Dato che si comporta come una normale string, puoi fare tutto ciò che fai normalmente con il testo. Puoi controllare la lunghezza di una sequenza. Puoi contare quante volte compare uno specifico pattern. Puoi fare uno slice per estrarne una porzione più piccola. Quando fai lo slice di un oggetto Seq, il risultato non è una normale string di testo. È un nuovo oggetto Seq. Questo ti assicura di non perdere mai accidentalmente i metodi biologici quando fai il parse di una sequenza in frammenti più piccoli. Questa è la parte che conta. Le string standard non capiscono la biologia. Il DNA è a doppio filamento e le sequenze vengono lette in una direzione specifica. Se hai una sequenza di DNA codificante e ti serve il filamento opposto, un semplice reverse del testo è biologicamente scorretto. Devi fare il reverse dell'ordine delle lettere e scambiare ogni base con la sua coppia strutturale. L'oggetto Seq gestisce tutto questo con un singolo metodo reverse complement, restituendo un filamento opposto biologicamente accurato. Oltre alla struttura, l'oggetto Seq gestisce direttamente il dogma centrale della biologia molecolare. Prendi una breve sequenza di DNA codificante. Per convertirla in RNA messaggero, chiami il metodo transcribe sulla tua sequenza. Dietro le quinte, questo gestisce le specifiche sostituzioni di lettere, rimpiazzando la timina con l'uracile, e ti restituisce una sequenza di RNA. Se parti dall'RNA e hai bisogno dell'equivalente in DNA, un metodo back transcribe inverte il processo. Una volta che hai la tua sequenza pronta, in genere vuoi la proteina risultante. Chiami il metodo translate. Questo raggruppa automaticamente le lettere della sequenza in triplette, le valuta come codoni e restituisce un nuovo oggetto Seq contenente la sequenza di amminoacidi. La biologia è raramente uniforme e il codice genetico standard non si applica ovunque. Organismi come alcuni batteri, o organelli come i mitocondri dei vertebrati, leggono i codoni in modo diverso. Il metodo translate tiene conto di questo tramite le translation table. Invece di scrivere logica custom per una sequenza mitocondriale, passi semplicemente l'argomento translation table al metodo. Puoi fornire il numero ufficiale della tabella NCBI, come la tabella due per i mitocondri dei vertebrati, oppure il nome della tabella come testo. L'oggetto Seq ricalcola gli amminoacidi usando le regole specifiche di quell'organismo. Il vero potere dell'oggetto Seq è che ti evita di scrivere funzioni di text parsing fragili e soggette a errori per processi biologici consolidati. Se vuoi supportare lo show, puoi cercare DevStoriesEU su Patreon. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 2 di 18. Una string di diecimila lettere di DNA è tecnicamente una sequenza, ma analiticamente è inutile. Senza conoscere la specie da cui proviene, il tipo di molecola o la qualità di lettura, hai solo del testo grezzo. Associare questi metadati cruciali alla sequenza grezza è il compito dei Rich Sequence Data: l'oggetto SeqRecord. Il SeqRecord è un container. Prende una sequenza di base e la racchiude con gli identificatori e le informazioni descrittive necessarie per usarla effettivamente in una pipeline bioinformatica. Ogni SeqRecord si basa su alcuni attributi principali. Il primo è dot seq, che contiene i dati della sequenza vera e propria. Attorno a questo ci sono tre attributi string standard. Dot id contiene l'identificatore primario, in genere un numero di accesso da un database pubblico. Dot name contiene un nome comune più breve o un identificatore del clone. Dot description contiene un testo human-readable che spiega cosa rappresenta effettivamente la sequenza. A volte tre attributi string non sono sufficienti. Quando hai bisogno di memorizzare metadati complessi o custom, usi l'attributo dot annotations. Questo è un dizionario Python standard. Gestisce i metadati a livello di record. Puoi memorizzarci qualsiasi cosa. Se vuoi tenere traccia di come è stata verificata una sequenza, aggiungi semplicemente una nuova chiave chiamata evidence al dizionario e imposti il suo valore a experimental. Ecco il punto fondamentale. Non tutti i metadati si applicano all'intera sequenza nel suo complesso. A volte hai bisogno di dati assegnati a ogni singola lettera. Questo è ciò che fa dot letter annotations. È un altro dizionario, ma ha una regola rigorosa. Qualsiasi list, array o string che assegni come valore in questo dizionario deve avere esattamente la stessa lunghezza della sequenza stessa. Il classico use case è la memorizzazione dei punteggi di qualità Phred di una macchina di sequenziamento. Se la tua sequenza di DNA fittizia è lunga esattamente venti lettere, puoi assegnare una list di venti interi al dizionario dot letter annotations sotto la chiave phred quality. Se provi ad assegnare diciannove o ventuno interi, Biopython lancerà immediatamente un errore. Puoi costruire facilmente un SeqRecord da zero. Per prima cosa, definisci un oggetto sequence. Poi, passi quella sequence al costruttore di SeqRecord. Puoi passare l'identificatore, il nome e la descrizione direttamente lì come argomenti. Una volta che l'oggetto esiste, puoi accedere ai suoi dizionari per iniettare manualmente le tue string custom di evidence o le tue list di punteggi di qualità per singola lettera. In pratica, raramente li costruisci interamente a mano. Di solito li ottieni facendo il parsing di file, e Biopython gestisce i diversi formati di file mappando i dati agli attributi di SeqRecord in modi specifici. Prendi in considerazione un file FASTA standard. FASTA è un formato molto basilare. Quando Biopython lo legge, prende la prima parola dopo il simbolo di maggiore sulla riga di intestazione e la assegna all'attributo dot id. All'attributo dot name viene semplicemente assegnato lo stesso identico valore dell'identificatore. Il resto della riga di intestazione viene riversato direttamente nell'attributo dot description. Dato che FASTA non ha metadati strutturati, il dizionario dot annotations rimane completamente vuoto. I file GenBank offrono un netto contrasto. Contengono dati ricchi e strutturati. Facendo il parsing di GenBank, Biopython assegna il locus e il numero di versione a dot id. Il nome del locus va all'attributo dot name. La riga di definizione viene mappata a dot description. Cosa fondamentale, Biopython popola attivamente il dizionario dot annotations. Estrae i dettagli tassonomici, il tipo di molecola, la divisione del file di dati e la list dei riferimenti pubblicati, inserendoli ordinatamente nel dizionario sotto chiavi standardizzate. La sequenza ti dice il codice biologico sottostante, ma l'oggetto SeqRecord è ciò che in definitiva dà a quel codice il suo contesto. Grazie per aver passato qualche minuto con me. Alla prossima, stammi bene.

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 3 di 18. La tua pipeline bioinformatica crasha a metà di una run. Controlli i log e ti accorgi che uno script a valle si aspettava un file FASTA, ma il tool a monte gli ha passato un file GenBank. Ora devi riscrivere un parser da zero solo per estrarre i dati di sequenza. Oppure, potresti usare Bio dot SeqIO. SeqIO è il modulo standard di Biopython per l'input e l'output di sequenze. Gestisce il parsing di vari formati di file biologici, quindi non devi scrivere espressioni regolari personalizzate o funzioni di manipolazione di string. Fornisci il file path e la format string, e SeqIO gestisce la struttura del file sottostante. Quando leggi i file, SeqIO ti offre due funzioni distinte, e scegliere quella sbagliata è una causa comune di bug. La prima è read. Usi la funzione read quando sei assolutamente certo che il tuo file contenga esattamente un sequence record. Le passi il file path e il formato, come fasta, e restituisce un singolo oggetto sequence record. Se il file è vuoto, o se contiene due o più record, la funzione read solleverà immediatamente un'eccezione e fermerà il tuo script. È strettamente per il mapping uno a uno. Più spesso, hai a che fare con file che contengono molte sequenze. Per questo, usi la funzione parse. A differenza di read, parse non carica tutto in memoria in una volta sola. Invece, restituisce un iterator. Questa è la parte importante. Un iterator fa lo yield di un sequence record alla volta, il che mantiene basso il tuo memory footprint anche se stai elaborando enormi dataset genomici da svariati gigabyte. Considera uno scenario specifico. Hai un file GenBank che contiene dati per diverse specie di orchidee. Vuoi estrarre questi record, ma ti interessano solo le sequenze più lunghe di cento paia di basi. Inoltre, il tool successivo nella tua pipeline richiede il formato FASTA, non GenBank. Puoi gestire la lettura, il filtraggio e la conversione di formato in modo sequenziale. Per prima cosa, crei una lista vuota per contenere le tue sequenze filtrate. Successivamente, imposti un loop usando la funzione parse, puntandola al tuo file GenBank delle orchidee e specificando genbank come format string di input. All'interno del loop, la funzione parse ti consegna un oggetto sequence record ad ogni passaggio. Controlli la lunghezza della sequenza associata a quel record. Se la lunghezza è maggiore di cento, fai l'append del record alla tua lista. Se è più corta, semplicemente lo ignori e passi all'iterazione successiva. Ora hai una lista di record validi e filtrati in memoria. Per salvarli, usi la funzione write. La funzione write richiede tre parametri: la sequenza di record che vuoi salvare, il file path di output e la format string di output. Passi la tua lista di record di orchidee filtrati, specifichi un nuovo nome file e fornisci fasta come format string. Questo è tutto ciò che serve. SeqIO estrae automaticamente gli identificatori e le sequenze rilevanti dai tuoi record GenBank e li formatta correttamente come testo FASTA. Non hai bisogno di costruire manualmente le righe di header o formattare i blocchi di sequenza. Abbinando parse con write, traduci tra formati di file senza sforzo. Il takeaway più utile qui è che SeqIO funge da ponte standardizzato. Forzando tutti i formati di file in una struttura sequence record universale durante lo step di parse, disaccoppia completamente il formato che leggi dal formato che alla fine scrivi. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 4 di 18. Stai facendo lo slicing manuale di una stringa di sequenza per estrarre un gene sul reverse strand. Calcoli le coordinate, inverti la stringa, complementi le basi e fai girare il tuo script. Metà delle volte, ti ritrovi con un errore off-by-one o con dati senza senso. Cercare di fare questi calcoli sulle sequenze a mano è una trappola classica. Invece, dovresti lasciare che sia il parser a fare il lavoro, estraendo i geni con SeqFeature. Un oggetto SeqFeature descrive una regione o un punto di riferimento specifico su una parent sequence. Quando fai il parsing di un file in un formato rich, Biopython popola il tuo sequence record con una lista di questi oggetti feature. Ogni feature ha tre attributi principali che utilizzerai costantemente. Il primo è l'attributo type. Questa è semplicemente una stringa che ti dice cosa rappresenta la feature, come gene, CDS o mRNA. Il secondo è l'attributo qualifiers. Questo è un dizionario che contiene tutti i metadati associati a quella specifica feature. Se ti serve il nome del gene, il locus tag o una nota sul prodotto di traduzione, li recuperi dal dizionario qualifiers. Il terzo, e più importante, è l'attributo location. Questo determina esattamente dove vive matematicamente la feature sulla parent sequence. Si presenta in due forme principali. Una SimpleLocation gestisce tratti di sequenza continui e ininterrotti. Contiene una posizione esatta di start, una posizione esatta di end e il filamento. Il filamento è rappresentato da un intero. È uno per il forward strand e meno uno per il reverse strand. La biologia spesso si rifiuta di essere semplice. I geni sottoposti a splicing negli eucarioti sono spezzati in più esoni lungo il genoma. Per gestire questo, l'attributo location sarà invece una CompoundLocation. Una CompoundLocation è essenzialmente una collection di SimpleLocation unite tra loro. Raggruppa le coordinate frammentate degli esoni e le tratta come un'unica unità logica. Ecco l'intuizione chiave. Non hai bisogno di guardare queste coordinate di location e scriverti la tua notazione di slice in Python per tirare fuori i dati della sequenza dal parent record. Usi il metodo extract associato alla feature stessa. Per usarlo, prendi il tuo oggetto SeqFeature, chiami il metodo extract e passi l'intera parent sequence come argomento. La feature guarda i propri dati di location e fa il lavoro pesante al posto tuo. Se la feature è una SimpleLocation sul forward strand, fa lo slice della sequenza esattamente come ti aspetteresti. Se la feature è sul reverse strand, extract gestisce automaticamente lo slice, genera il reverse complement di quella sequenza e restituisce il risultato biologicamente accurato. Non devi invertire le stringhe o ricordarti di complementare le basi. Fa ancora più lavoro per te quando hai a che fare con una CompoundLocation. Se chiami extract su un gene sottoposto a splicing, Biopython va sulla parent sequence, estrae ogni singolo esone in base alle rispettive SimpleLocation, ne fa automaticamente il reverse complement se il gene è sul minus strand e li cuce tutti insieme nell'ordine corretto. Ti restituisce un pezzo di sequenza continuo e pulito, pronto per la traduzione o l'analisi downstream. Affidarsi al metodo extract elimina i calcoli manuali degli indici che causano errori silenziosi nei dati all'interno delle pipeline bioinformatiche. Vorrei prendermi un momento per ringraziarti per l'ascolto: ci aiuta tantissimo. Buona giornata!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 5 di 18. I classici algoritmi di allineamento basati sulla programmazione dinamica sono notoriamente lenti se scritti in puro Python. Se provi a elaborare migliaia di coppie di sequenze, il tuo script si bloccherà per ore. Biopython risolve questo problema passando al C per il lavoro pesante, offrendoti prestazioni nell'ordine dei millisecondi. Questo episodio parla del Pairwise Sequence Alignment utilizzando l'oggetto PairwiseAligner. Per confrontare esattamente due sequenze, istanzi un PairwiseAligner. Questo singolo oggetto fa da motore di configurazione per l'intero processo. Di default, esegue un allineamento globale, il che significa che forza un match end-to-end tra le due sequenze. Se vuoi solo trovare la sottosequenza con il miglior match nascosta da qualche parte all'interno di una string più grande, cambi l'attributo mode dell'aligner da global a local. L'aligner ha bisogno di regole per decidere cosa costituisce un buon match. Imposti queste regole direttamente come attributi sull'oggetto aligner. Assegni un numero positivo all'attributo match score, e un numero negativo all'attributo mismatch score. Ma le sequenze biologiche mutano anche inserendo o eliminando interi blocchi di lettere, il che crea dei gap nell'allineamento. Ecco l'intuizione chiave. La biologia favorisce fortemente una singola, lunga delezione rispetto a diverse piccole delezioni sparse. Per modellare questa realtà fisica, configuri due gap penalty separate. Assegni un valore negativo elevato all'open gap score per penalizzare la creazione di un nuovo gap. Poi, assegni un valore negativo molto più piccolo all'extend gap score. Questo squilibrio matematico forza l'aligner a raggruppare i gap ogni volta che è possibile. Una volta configurato il tuo aligner, chiami il suo metodo align e gli passi le tue due sequenze. Il metodo non restituisce semplicemente una singola string o un numero finale. Restituisce un iterator di oggetti alignment. Percorsi multipli attraverso una matrice di programmazione dinamica possono produrre esattamente lo stesso score più alto. L'aligner ti dà accesso a tutti questi allineamenti matematicamente ottimali. Dato che restituisce un iterator, la valutazione avviene in modo lazy. Calcola il percorso ottimale successivo solo quando tu lo richiedi, il che protegge il tuo sistema da sovraccarichi di memoria se sequenze altamente ripetitive generano migliaia di allineamenti ugualmente validi. Considera un esempio concreto usando due brevi sequenze di DNA. La sequenza uno è A C C G T. La sequenza due è A C G, il che significa che le mancano la seconda C e la T finale. Per prima cosa, crei l'oggetto aligner. Imposti il match score a due, e il mismatch score a meno uno. Imposti l'open gap score a meno cinque, e l'extend gap score a meno uno. Poi, passi entrambe le sequenze al metodo align. Quando cicli sull'iterator restituito e stampi i risultati, Biopython formatta automaticamente l'output. Impila visivamente le sequenze, tracciando linee verticali tra le basi che fanno match e trattini dove manca una lettera. Vedrai esattamente come l'aligner ha posizionato i caratteri di gap nella seconda sequenza per allineare le lettere che fanno match, massimizzando lo score totale in base alla severa open gap penalty che hai definito. Ricorda che configurare un aligner significa essenzialmente fare il tuning di un modello matematico; l'output ha un significato biologico solo se i tuoi match, mismatch e gap score riflettono accuratamente la specifica relazione evolutiva tra le tue sequenze di input. Per questo episodio è tutto. Grazie per aver ascoltato, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 6 di 18. Apri un file di allineamento in un editor di testo e sembra perfettamente strutturato, come una semplice griglia. Ma prova a fare il parsing solo della terza posizione su cinquanta specie diverse, e all'improvviso ti ritrovi a scrivere cicli annidati e a tenere traccia degli indici delle stringhe. Gestire i Multiple Sequence Alignment non deve essere per forza così frustrante. Per portare un allineamento nel tuo codice, usi il modulo Bio AlignIO. Supponendo che il tuo file di allineamento sia già generato, ti affidi alla funzione read. A questa funzione passi il percorso del file e una stringa che specifica il formato, come phylip o stockholm. La funzione read elabora il file di testo e ti restituisce un oggetto MultipleSeqAlignment. Ecco il punto chiave. L'oggetto MultipleSeqAlignment si comporta esattamente come un array bidimensionale. Se hai mai lavorato con una matrice NumPy, la logica è identica. Le righe in questa griglia sono le tue singole sequenze, che in genere rappresentano organismi o geni diversi. Le colonne sono le posizioni specifiche dei nucleotidi o degli amminoacidi allineate su tutte quelle sequenze. Dato che si comporta come un array 2D, usi la sintassi standard di slicing di Python per manipolare entrambe le dimensioni simultaneamente. Se hai solo bisogno di prendere una sequenza specifica, fai uno slice sulle righe. Accedendo all'indice zero del tuo allineamento, ottieni la primissima sequenza nel file. Questa riga viene restituita come un oggetto SeqRecord standard, completo di ID della sequenza, descrizione e i dati della sequenza biologica stessa. Puoi anche fare un loop direttamente sull'oggetto allineamento, e ti restituirà ogni SeqRecord riga per riga. Questo per quanto riguarda le sequenze. Ora passiamo alle colonne, che è dove la logica 2D ti fa davvero risparmiare tempo. Supponi di aver caricato un allineamento stockholm e di voler isolare una regione iniziale altamente conservata. Ti interessano solo le prime dieci posizioni su ogni singola specie. Invece di iterare su cinquanta sequenze e fare lo slicing di cinquanta stringhe individuali, applichi uno slice 2D direttamente all'oggetto allineamento. Richiedi tutte le righe usando un singolo due punti per la prima dimensione, seguito da una virgola, e poi lo slice da zero a dieci per la seconda dimensione. La sintassi è semplicemente parentesi quadra aperta, due punti, virgola, due punti dieci, parentesi quadra chiusa. Questa singola operazione restituisce un oggetto MultipleSeqAlignment nuovo di zecca contenente solo quelle prime dieci colonne per ogni sequenza. Tutti gli ID delle sequenze originali e i metadati vengono preservati automaticamente nella nuova griglia più piccola. C'è una leggera differenza nel comportamento a seconda di quanto è ampio il tuo slice. Quando fai lo slice di un range di colonne, Biopython mantiene la struttura a griglia e restituisce un oggetto allineamento. Ma se estrai esattamente una singola colonna, diciamo tutte le righe all'indice di colonna cinque, l'oggetto restituisce una singola stringa di plain text contenente solo quei caratteri dall'alto verso il basso. Questa stringa di testo rende eccezionalmente facile calcolare i punteggi di conservazione o identificare i polimorfismi a singolo nucleotide in un sito specifico senza fare l'unpacking di alcun oggetto. Puoi combinare questi slice di righe e colonne per estrarre qualsiasi sottoblocco di cui hai bisogno. Potresti richiedere le righe dalla due alla cinque, e le colonne dalla cinquanta alla sessanta, isolando un dominio specifico per un sottoinsieme di specie. Tratta i tuoi allineamenti come matrici, lascia che l'oggetto MultipleSeqAlignment gestisca il tracciamento delle stringhe, e il tuo codice di estrazione dati si ridurrà quasi a zero. Questo è tutto per questa volta. Alla prossima!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 7 di 18. Devi scaricare diecimila record di sequenze. Se scrivi un normale web scraper per fare richieste al sito dell'NCBI, il tuo indirizzo IP verrà bloccato prima di finire i primi cento. Il National Center for Biotechnology Information vieta esplicitamente lo scraping automatizzato. Per scaricare dati in modo legale e affidabile, devi interrogare i database dell'NCBI in modo programmatico utilizzando Bio punto Entrez. Prima di fare qualsiasi richiesta di rete, devi seguire le linee guida delle API di NCBI. Per prima cosa, devi dirgli chi sei. Puoi farlo impostando la variabile Entrez punto email con il tuo vero indirizzo email. Se il tuo script dovesse andare fuori controllo e sovraccaricare i loro server, utilizzeranno questa email per contattarti prima di bloccare definitivamente il tuo accesso. Secondo, devi rispettare i loro rate limit. L'NCBI limita gli utenti non autenticati a tre richieste al secondo. Biopython gestisce automaticamente questo aspetto imponendo un ritardo in background. Tuttavia, se provi a lanciare più script in parallelo per aggirare questo ritardo, l'NCBI rileverà l'abuso e bloccherà il tuo IP. Rispetta le regole. Il workflow per estrarre dati da Entrez di solito richiede un processo in due step: trovare gli identificatori univoci, e poi scaricare i file veri e propri. Inizi cercando con la funzione Entrez punto esearch. Supponi di voler trovare il gene matK nelle orchidee. Chiami esearch e gli passi il nome del database, che è nucleotide, insieme al tuo termine di ricerca, come orchid organism AND matK gene. Questa funzione di ricerca non restituisce dati di sequenza biologica. Restituisce una response HTTP che si comporta come un file di testo aperto contenente un documento XML. Ecco il punto chiave. Non devi scrivere un parser XML custom o estrarre le stringhe manualmente. Prendi quell'handle di rete e lo passi direttamente alla funzione Entrez punto read. Questo fa il parsing dell'XML e lo traduce in un dictionary Python standard. All'interno di quel dictionary, cerchi semplicemente la chiave chiamata IdList. Questo ti restituisce una list Python contenente gli esatti identificatori GenBank che corrispondono alla tua query sull'orchidea. Una volta che hai quella list di identificatori, passi al secondo step: scaricare i record completi. Per farlo, usi la funzione Entrez punto efetch. Gli passi lo stesso nome del database, nucleotide, insieme a un identificatore dai tuoi risultati di ricerca. Devi anche specificare il formato dei dati che vuoi indietro. Per ottenere un file di testo GenBank standard, imposti l'argomento retrieval type a gb e l'argomento retrieval mode a text. Proprio come la funzione di ricerca, efetch restituisce un network stream, non una raw string. Dato che questo stream simula un file locale, non hai bisogno di salvare prima i dati scaricati sul tuo hard drive. Puoi passare l'handle di rete direttamente a SeqIO punto read, specificare che il formato è genbank, e questo parsa immediatamente lo stream in un oggetto SeqRecord di Biopython. Ora hai la sequenza e tutte le sue annotazioni biologiche caricate in memoria. Quando hai finito, chiudi l'handle per liberare le risorse di rete. L'abitudine più importante quando fai query su NCBI è trattare le tue response API come file stream anziché come text string. Passare questi stream direttamente a Entrez punto read o SeqIO punto read evita un inutile memory overhead e mantiene le tue pipeline di automazione perfettamente pulite. Se trovi utili questi episodi, puoi supportare lo show cercando DevStoriesEU su Patreon. Grazie per l'ascolto, e buon coding a tutti!

Ciao, sono Alex di DEV STORIES DOT EU. Biopython Fundamentals, episodio 8 di 18. Fissare una pagina web che si aggiorna automaticamente mentre una sequenza viene allineata a un database globale è un pessimo modo di impiegare il tuo pomeriggio. Automatizzare questa ricerca in background significa che puoi fare qualcosa di utile mentre Python aspetta. Oggi vedremo come eseguire BLAST su Internet usando Biopython. La funzione di cui hai bisogno si chiama qblast e si trova nel modulo Bio punto Blast punto NCBIWWW. Funge da wrapper per l'API BLAST dell'NCBI, permettendoti di inviare query direttamente dal tuo script esattamente come faresti tramite il loro portale web. Per avviare una ricerca, qblast richiede tre argomenti obbligatori. Il primo è il programma BLAST che vuoi eseguire. Ad esempio, se stai confrontando una sequenza nucleotidica con un database di nucleotidi, devi passare la string blastn. Se stai lavorando con le proteine, devi passare blastp. Il secondo argomento è il database specifico in cui stai effettuando la ricerca. La scelta più comune per i nucleotidi è la string nt, che sta per non-redundant nucleotide database. Se stessi cercando proteine, useresti nr. Il terzo argomento è la query della sequenza stessa. Biopython rende questo input estremamente flessibile. Puoi fornire una semplice string della sequenza grezza, una string multilinea formattata come FASTA record, un oggetto SeqRecord di Biopython, o un identificatore esatto della sequenza come un accession number dell'NCBI. Se vuoi eseguire una ricerca di base, chiami qblast, gli passi blastn come programma, nt come database e la tua string FASTA come query. Python metterà in pausa l'esecuzione qui mentre negozia con i server NCBI, aspettando tutto il tempo necessario affinché l'allineamento remoto finisca. Quando il server remoto termina il job, qblast restituisce un file-like object contenente i tuoi risultati. Dietro le quinte, la funzione richiede questi risultati in formato XML di default. Dovresti assicurarti che rimanga così, poiché XML è il formato standard su cui Biopython si basa per il downstream processing. Ecco il punto chiave. Non passare immediatamente questo web handle restituito a una funzione di parsing. Eseguire una ricerca BLAST remota è computazionalmente oneroso per i server NCBI e richiede molto tempo per te. Se fai il parsing del data stream in tempo reale direttamente dal web handle e il tuo script incontra un errore poche righe più giù, quei dati della sequenza andranno persi dalla memoria. Per correggere il tuo codice e riprovare, dovresti eseguire esattamente la stessa ricerca remota da zero, sprecando la loro banda e il tuo tempo. Il workflow corretto consiste nel salvare immediatamente e in modo permanente l'output grezzo. Nel momento in cui qblast restituisce il web handle, usa le normali operazioni sui file di Python per aprire un nuovo file locale in write mode. Leggi tutto dal web handle, scrivilo direttamente nel tuo nuovo file XML locale e poi chiudi il web handle. Ora hai una copia sicura e statica della tua ricerca BLAST sul tuo disco rigido. Puoi aprire quel file XML locale domani, la prossima settimana o cinquanta volte di seguito durante il debug della tua applicazione, senza dover mai più pingare l'API dell'NCBI una seconda volta. Separa sempre il tuo network retrieval dal tuo data processing scrivendo prima le web response su disco. Questo è tutto per questo episodio. Grazie per l'ascolto e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 9 di 18. Scrivere regular expression per fare lo scraping di file di output in plain-text è un rito di passaggio nella bioinformatica. È anche un anti-pattern. Nel momento in cui un tool di ricerca aggiorna la sua formattazione visiva, il tuo script si rompe. Per avere garanzie strutturali, devi affidarti a dati strutturati. Questo episodio tratta il Parsing Nativo: fare l'unpacking dell'XML di BLAST. Biopython gestisce questo aspetto utilizzando il modulo NCBIXML all'interno del package Bio dot Blast. Invece di salvare i risultati della tua ricerca come un blocco di testo human-readable, li salvi come file XML. Quando apri questo file e passi l'handle alla funzione parse del modulo NCBIXML, non carica un enorme blob di testo in memoria. Restituisce invece un iteratore. Questo iteratore fa lo yield di oggetti strutturati uno alla volta, mantenendo basso il tuo memory footprint anche se la tua ricerca ha restituito enormi quantità di dati. Per utilizzarlo in modo efficiente, devi comprendere la gerarchia a tre livelli che Biopython utilizza per modellare i risultati. Il livello superiore è il BLAST Record. Un record corrisponde esattamente a una sequenza che hai inviato come query. Se hai inviato una singola sequenza, l'iteratore fa lo yield di un record. Se hai inviato cinquanta sequenze, fa lo yield di cinquanta record. All'interno di ogni BLAST Record, troverai una lista di Alignment. Un alignment rappresenta un singolo hit nel database. Ti dice che una specifica sequenza nel database ha fatto match con la tua query, insieme ai metadati relativi a quella entry del database. All'interno di ogni Alignment c'è il terzo livello: le High-scoring Segment Pairs, universalmente note come HSP. Questa è la parte che conta. Un alignment indica semplicemente che due sequenze sono correlate. L'HSP contiene la prova matematica e strutturale di tale relazione. Un singolo alignment può contenere più HSP se le sequenze condividono più regioni distinte di similarità separate da gap non allineati. Estrarre i dati significa scrivere tre loop annidati. Primo, iteri sui record nell'XML di cui hai fatto il parsing. Secondo, iteri sugli alignment all'interno di ciascun record. Terzo, iteri sugli HSP all'interno di ciascun alignment. Una volta che sei dentro quel loop più interno, hai accesso ai dati effettivi del match. È qui che applichi i tuoi filtri statistici. Il filtro più comune è l'e-value, che rappresenta il numero di hit di qualità simile che ti aspetteresti di vedere per caso. Accedi a questo valore tramite l'attributo expect sull'oggetto HSP. Scrivi un controllo condizionale: se HSP dot expect è minore della tua soglia, diciamo zero virgola zero quattro, processi il match. Se è superiore, il match è troppo debole e lo ignori. Per gli hit che passano il tuo filtro, l'oggetto HSP contiene le string di allineamento esatte. L'attributo query contiene la tua sequenza di input con eventuali gap introdotti dall'algoritmo. L'attributo sbjct contiene la sequenza del database che ha fatto match. L'attributo match si colloca concettualmente tra i due, contenendo la rappresentazione dell'allineamento, mappando i match esatti, le sostituzioni positive o i gap. Il vero vantaggio qui è la stabilità. Lasciando che il modulo NCBIXML faccia l'unpacking del file, smetti di affidarti a un fragile text scraping e inizi a interagire con data object definiti che si mappano perfettamente alla realtà biologica di record, alignment e segment pairs. Grazie per aver ascoltato, happy coding a tutti!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 10 di 18. Le proteine vengono spesso memorizzate come una stringa piatta e unidimensionale di lettere, ma funzionano in una complessa realtà tridimensionale. Mappare una sequenza 1D in uno spazio di coordinate 3D richiede una gerarchia rigorosa e prevedibile. Navigare le strutture 3D con Bio.PDB ti fornisce esattamente questa mappa. Quando scarichi un file dal Protein Data Bank, ti arriva come un enorme blocco di testo. Storicamente, questo era il formato punto pdb. Oggi, lo standard è il formato punto cif. Scrivere il tuo codice per leggere questi blocchi di testo riga per riga è un esercizio nella gestione degli edge case. Bio.PDB risolve il problema convertendo il testo in un tree object-oriented. Per farlo, usi PDBParser o MMCIFParser. Crei un'istanza del parser, chiami il suo metodo get structure, fornisci un nome arbitrario per la tua struttura e passi il path del tuo file. Quello che ottieni in risposta è un oggetto Structure. Questo oggetto Structure segue una rigorosa architettura dati nota come SMCRA. Che sta per Structure, Model, Chain, Residue, Atom. Ogni file 3D parsato da Biopython è organizzato in questi cinque livelli annidati. Il livello root è la Structure. Una Structure contiene uno o più Model. Se la proteina è stata risolta tramite cristallografia a raggi X, di solito c'è un solo model. Se è stata risolta tramite NMR, potrebbero esserci decine di model che rappresentano diverse fluttuazioni strutturali. Di solito, prendi semplicemente il primo, che si trova all'index zero. All'interno di un Model, hai le Chain. Molte proteine sono complessi formati da più chain polipeptidiche interagenti. Queste sono tipicamente etichettate con singole lettere maiuscole, come chain A e chain B. All'interno di una Chain, trovi i Residue. Questi sono i singoli amminoacidi che compongono la sequenza. Questo livello contiene anche i ligandi e le molecole d'acqua attaccate a quella specifica chain. Infine, all'interno di un Residue, hai gli Atom. Ecco il punto chiave. Puoi navigare in questo intero tree utilizzando una semplice iterazione o un accesso in stile dictionary. Se scrivi un for loop su una chain, ti restituisce dei residue. Se iteri su un residue, ti restituisce degli atom. Se sai esattamente cosa stai cercando, puoi scendere direttamente in profondità senza fare loop. Se ti servono le coordinate spaziali del carbonio alfa nel centesimo residue della chain A, ti basta concatenare i tuoi lookup. Prendi il tuo oggetto Structure, chiedi il model zero, poi la chain A, poi il residue cento, e infine l'atom chiamato CA. Considera uno scenario pratico: estrarre le coordinate 3D di tutti gli atom in un singolo residue specifico. Per prima cosa, inizializzi il tuo parser e carichi il file in una variabile. Successivamente, isoli il residue target. Crei una variabile e le assegni il risultato del lookup del model zero, della chain A e del residue cinquanta dalla tua structure. Ora, scrivi un for loop standard. Per ogni atom nel residue target, richiedi le sue coordinate. Biopython te le restituisce come un array NumPy che rappresenta le posizioni esatte X, Y e Z nello spazio. Stampi il nome dell'atom e il suo array di coordinate. In poche righe di codice, hai bypassato migliaia di righe di testo grezzo ed estratto gli esatti dati spaziali di cui hai bisogno. La gerarchia SMCRA garantisce che ogni atom in ogni file structure venga trovato usando l'esatta stessa logica. Questo è tutto per questo episodio. Alla prossima!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 11 di 18. Se scrivi un banale nested loop per calcolare la distanza tra ogni atomo di una proteina e ogni atomo di un ligando, il tuo script si bloccherà. Lo spatial indexing risolve questo problema all'istante, ed è proprio di questo che parleremo oggi in Measuring Protein Geometry. L'operazione geometrica fondamentale in Bio dot PDB è trovare la distanza tra due punti nello spazio tridimensionale. Biopython fa l'override dell'operatore di sottrazione standard per gli oggetti Atom. Se prendi un oggetto Atom e sottrai un secondo oggetto Atom, il risultato è un float che rappresenta la distanza euclidea tra di loro. L'unità di misura è sempre in Angstrom. Non devi estrarre le coordinate, elevarle al quadrato o calcolare la radice quadrata a mano. Ti basta sottrarre un atomo dall'altro e avrai la tua distanza esatta. Questo trucco della sottrazione è perfetto per verificare un'interazione specifica e nota, come un singolo legame a idrogeno sospetto. Ma non funziona più quando devi esplorare una prossimità sconosciuta. Supponi di avere un piccolo ligando legato a un grande recettore, e di dover identificare ogni residuo della proteina entro un raggio di cinque Angstrom da quel ligando. Una proteina tipica contiene migliaia di atomi. Confrontare ogni singolo atomo del ligando con ogni singolo atomo della proteina è computazionalmente pesantissimo. La time complexity cresce geometricamente e il tuo script si blocca. Per risolvere questo problema, Bio dot PDB fornisce il modulo Neighbor Search. Invece di confrontare le coppie una per una, Neighbor Search costruisce uno spatial index. Sotto il cofano, costruisce un KD-tree che mappa dove si trova ogni cosa nello spazio tridimensionale, permettendo delle query di prossimità estremamente veloci. Costruisci un oggetto Neighbor Search passandogli una flat list di tutti gli atomi su cui vuoi fare la query. Di solito, estrai ogni atomo dalla tua struttura target, fai il cast di quel generator a una list standard, e la passi al costruttore di Neighbor Search. Questo step di inizializzazione richiede una frazione di secondo, ma fa tutto il lavoro computazionale pesante per organizzare i dati spaziali in anticipo. Una volta costruito l'index, puoi fargli delle query. Il metodo di search principale richiede due argomenti: una coordinata target e un raggio in Angstrom. Quando lanci la search, questa attraversa rapidamente lo spatial tree e restituisce solo le entità che si trovano all'interno di quel confine sferico. Ecco il punto chiave. La search non restituisce solo atomi. Dato che Bio dot PDB si basa sull'architettura SMCRA, Neighbor Search capisce la gerarchia strutturale. Puoi passare un parametro level opzionale alla tua query di search. Se specifichi la lettera R per residuo, l'index guarderà tutti gli atomi entro il tuo raggio di cinque Angstrom, determinerà a quali residui padre appartengono quegli atomi, e restituirà una list pulita di oggetti Residue univoci. Bypassi completamente il livello atomico nei tuoi risultati. Per mappare la nostra binding pocket del ligando, segui un flow molto semplice. Primo, inizializza il Neighbor Search con tutti gli atomi nella catena della proteina. Secondo, itera solo sugli atomi del tuo ligando. Per ogni atomo del ligando, chiama il metodo search con un raggio di cinque Angstrom e richiedi il livello residuo. Infine, raccogli i residui restituiti in un set Python per rimuovere automaticamente eventuali duplicati. Hai appena mappato il binding site in millisecondi. Se devi trovare dei clash interni all'interno di una singola catena ripiegata, Neighbor Search include anche un metodo search all. Ti basta fornire un raggio, e lui restituisce ogni singola coppia di atomi nell'intera struttura che si trovano a una distanza inferiore a quella specificata, evitando completamente il problema del nested loop. Trattare i tuoi dati molecolari come un index geografico ricercabile anziché come una nested list trasforma il tuo codice da lento e strutturale a veloce e spaziale. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 12 di 18. Se hai mai dato un'occhiata a un file Newick raw, sai che è solo un incubo denso e annidato di parentesi e virgole. Scrivere il tuo string parser per capire quale specie è imparentata con quale è un esercizio frustrante. Quello che ti serve è un modo per caricare quel testo direttamente in una struttura dati traversable. Questo è esattamente ciò che Bio dot Phylo offre per gli alberi filogenetici in Python. Bio dot Phylo gestisce il parsing, la manipolazione e il drawing degli alberi evolutivi. L'entry point principale è la funzione read. Le passi un file path e una format string, come newick o phyloxml. La funzione read consuma quel file e restituisce un singolo tree object. Se il tuo file contiene più alberi, usi invece la funzione parse per ottenere una sequenza iterable di alberi. Una volta caricato il file, lavori con due componenti distinti: il Tree object e il Clade object. Il Tree object rappresenta l'intera struttura nel suo complesso. Contiene metadata globali, come il nome dell'albero e se è rooted o unrooted. Ma i veri e propri dati di branching non vivono direttamente nel Tree object. Vivono nei Clade object. Un Clade rappresenta un node specifico e ogni discendente che si dirama da esso. Il Tree object ha un root attribute, che è semplicemente il Clade di partenza per l'intera gerarchia. Ogni branch che parte da quella root è un altro Clade, che contiene i propri sub-clade, a cascata fino alle tips. Navigare questa gerarchia è il punto di forza del modulo. Non scrivi loop ricorsivi manualmente. Per cercare nella struttura, chiami il metodo find clades sul tuo tree. Questo metodo cerca attraverso tutti i nested branch e restituisce un iterable di clade che corrispondono alle proprietà che specifichi. Puoi cercare per nome, per branch length, o persino tramite una custom evaluation function. Se ti interessano solo le estremità assolute dei branch, che rappresentano le specie viventi attuali, usi il metodo get terminals. Questo restituisce immediatamente una flat list dei leaf clade. Puoi anche calcolare metriche strutturali all'istante. Chiamando il metodo total branch length sul tree, sommi le lunghezze di ogni singolo branch nell'intera struttura, ottenendo la distanza evolutiva totale. Considera uno scenario in cui carichi un enorme albero evolutivo di mammiferi. Vuoi isolare solo il branch che contiene i primati per eseguire un'analisi localizzata. Chiami find clades e cerchi il target name Primates. Questo restituisce il Clade object specifico che rappresenta l'antenato comune di tutti i primati. Poiché un Clade contiene naturalmente tutti i suoi discendenti, ora hai un subtree completo e isolato. Puoi passare quel clade dei primati ad altre funzioni di analisi esattamente come faresti con un full tree. A volte hai solo bisogno di guardare la struttura per verificare che la tua estrazione abbia funzionato. Bio dot Phylo include una funzione draw ascii. Passi il tuo tree o il tuo clade isolato a questa funzione, e questa stampa una rappresentazione in plain text direttamente sul tuo terminale. Non è pensata per la pubblicazione, ma ti dà un feedback visivo immediato sulla topologia senza richiederti di configurare plotting library esterne. Ecco il punto chiave. Tradurre le parentesi annidate in native object significa che la topologia diventa un'API, permettendoti di fare slicing delle storie evolutive con method call standard. Se hai trovato utile questo episodio e vuoi supportare lo show, puoi cercare DevStoriesEU su Patreon. Questo è tutto per questo episodio. Grazie per l'ascolto e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 13 di 18. Se provi a trovare un sito di legame per un fattore di trascrizione usando uno string match rigoroso, ti perderai la stragrande maggioranza dei veri segnali biologici. I siti di legame del DNA variano, e le proteine tollerano variazioni in posizioni specifiche della sequenza. Per trovarli in modo affidabile, devi smettere di cercare string fisse e iniziare a cercare profili di probabilità, che è esattamente ciò che ti permette di fare l'analisi dei sequence motif. In Biopython, gestisci tutto questo con il modulo motifs. Parti da un set noto di sequenze allineate che rappresentano il tuo sito di legame. Prendiamo come esempio la classica TATA box. Potresti avere una manciata di brevi sequenze note come T A T A A A, T A T A A T, e T A T A A C. Le definisci come oggetti Seq standard e le passi come una singola list alla funzione create nel modulo motifs. Biopython prende questa list di istanze e le impacchetta in un singolo oggetto motif. Il risultato immediato della creazione di questo oggetto motif è una count matrix. In ogni posizione lungo la lunghezza della tua sequenza, Biopython conta le occorrenze totali di A, C, G e T. Se guardi la prima posizione dei nostri esempi di TATA box, il count per T è tre, e il count per le altre tre lettere è zero. Questa matrix è letteralmente la base di tutte le analisi downstream, ma i raw count hanno una grave limitazione matematica. Se un nucleotide non compare mai in una certa posizione nel tuo piccolo campione di riferimento, la sua probabilità diventa uno zero assoluto. Più avanti, quando moltiplichi le probabilità per dare uno score a una sequenza, un singolo zero azzera l'intero score. Per risolvere questa vulnerabilità, converti la count matrix in una Position-Weight Matrix, o PWM. Ecco l'intuizione chiave. Generi la PWM applicando degli pseudocount. Uno pseudocount aggiunge una minuscola frazione di base a ogni possibile nucleotide in ogni posizione. Riconosce matematicamente che solo perché non hai ancora visto una citosina in posizione due, non significa che una sostituzione in quel punto sia biologicamente impossibile. Appianando gli zeri, la Position-Weight Matrix trasforma i tuoi raw count in distribuzioni di probabilità robuste. Le probabilità da sole sono ancora difficili da usare per il sequence scanning. Devi sapere se un tratto di DNA fa match con il tuo motif meglio di quanto faccia match con una sequenza di background casuale. Gestisci questo passaggio convertendo la tua PWM in una Position-Specific Scoring Matrix, o PSSM. La PSSM calcola dei log-odds score basandosi su una distribuzione nucleotidica di background. Confronta la probabilità che una lettera compaia perché fa parte del tuo motif rispetto alla probabilità che compaia per puro caso. Uno score positivo significa che la sequenza assomiglia attivamente al tuo motif. Uno score negativo significa che assomiglia al rumore di background. Una volta che hai la tua PSSM, puoi andare a caccia di siti di legame non annotati in una lunga sequenza target. Chiami il metodo calculate sulla PSSM e gli passi la tua sequenza di DNA target. Questo metodo fa letteralmente scorrere il tuo motif lungo l'intero target, calcolando lo score per ogni possibile finestra di quella lunghezza. Restituisce un array di score numerici che rappresentano il valore di log-odds in ogni posizione della sequenza. Iteri su questi score e cerchi valori che superano una rigida threshold definita. Se lo score è abbastanza alto, hai probabilmente trovato una TATA box funzionale. Uno string match rigoroso richiede la perfezione, ma i sistemi biologici operano sulla probabilità, e passare dai raw count alle scoring matrix cattura questa realtà. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 14 di 18. GenBank è ottimo quando lavori con gli acidi nucleici. Ma quando hai bisogno di dati su una proteina curati da esperti e revisionati manualmente, come i suoi esatti siti attivi o dove attraversa la membrana cellulare, i database di sequenze standard non bastano. Hai bisogno di un database di proteine specializzato, ed è qui che entra in gioco l'integrazione tra Swiss-Prot ed ExPASy. Swiss-Prot è un database di sequenze proteiche di alta qualità, annotato manualmente. ExPASy è il portale server che ne fornisce l'accesso. Biopython collega questi due elementi. Usa il modulo ExPASy per scaricare i dati da Internet e il modulo SwissProt per parsarli in un object strutturato. Per prima cosa, devi scaricare il record raw da Internet. Lo fai usando il modulo ExPASy, in particolare una funzione chiamata get_sprot_raw. Le passi un accession ID di Swiss-Prot. Ad esempio, se vuoi il record della subunità alfa dell'emoglobina umana, passi il suo accession ID, che è P69905. Chiamare get_sprot_raw con questo ID apre una connessione di rete al server e restituisce un handle ai dati di testo raw. Una volta ottenuto quell'handle di testo raw, lo passi al modulo SwissProt. Chiami la funzione read e le passi il tuo handle. Questo fa il parse del flat file e restituisce un object record di Swiss-Prot. Ecco il punto chiave. Questo object record non è solo una string di sequenza. È un contenitore profondamente strutturato di metadati curati da esperti. Dato che Swiss-Prot è curato manualmente, i campi di questo object sono eccezionalmente ricchi. Puoi accedere all'attribute organism per confermare esattamente a quale specie appartiene la proteina. Puoi controllare l'attribute sequence_length per ottenere all'istante il conteggio degli amminoacidi, senza dover misurare tu stesso la string di sequenza. La parte più preziosa del record è l'attribute features. Si tratta di una list annidata che contiene i domini strutturali e funzionali noti della proteina. Quando iteri attraverso queste features, troverai annotazioni specifiche. Vedrai features che descrivono in dettaglio le esatte coordinate degli amminoacidi per i siti attivi, le regioni di legame ai metalli o i domini transmembrana. Invece di eseguire un algoritmo di predizione, stai leggendo coordinate definitive e confermate in laboratorio direttamente da un database curato. In pratica, il flusso del tuo codice è questo. Chiami la funzione get_sprot_raw da ExPASy con il tuo accession ID. Prendi l'handle risultante e lo passi alla funzione read di SwissProt. Questo ti dà il tuo object record. Da lì, puoi leggere organism, controllare sequence_length, o fare un loop attraverso la list di features per estrarre i siti funzionali. Ricordati sempre di chiudere l'handle di rete una volta che hai finito di leggere i dati, per liberare le risorse di sistema. Quando costruisci pipeline che si basano sulla funzione biologica piuttosto che sulla semplice similarità di sequenza, puntare a Swiss-Prot ti garantisce di basare la tua logica su dati verificati e curati da esseri umani. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 15 di 18. Quando invii un articolo che descrive un plasmide batterico appena sequenziato, i revisori raramente desiderano leggere una tabella in plain text con le coordinate dei geni. Si aspettano una mappa circolare, colorata e ben annotata, che renda la struttura genomica chiara a colpo d'occhio. Visualizzare i genomi con GenomeDiagram è il modo in cui generi queste mappe direttamente dai tuoi dati di sequenza. Prima di iniziare a disegnare, devi assicurarti che la libreria esterna ReportLab sia installata. GenomeDiagram si appoggia interamente a ReportLab, dietro le quinte, per calcolare la geometria e renderizzare le immagini finali. Senza di essa, l'export grafico fallirà. L'architettura di GenomeDiagram è rigorosamente gerarchica. Costruisci la tua visualizzazione annidando gli oggetti dall'alto verso il basso. In cima a tutto c'è l'oggetto Diagram. Questa è la tua tela bianca. All'interno del Diagram, aggiungi uno o più Track. Un Track rappresenta una specifica area di plotting. Su una mappa lineare, un Track è una riga orizzontale. Su una mappa circolare di un plasmide, un Track è un singolo anello concentrico. All'interno di un Track, aggiungi i FeatureSet. Un FeatureSet è un raggruppamento logico di dati di sequenza. Potresti usare un FeatureSet per le sequenze codificanti e un FeatureSet diverso per le regioni regolatorie esattamente sullo stesso anello. Infine, all'interno dei FeatureSet, posizioni le singole feature di sequenza stesse. Ecco il punto chiave. Non devi calcolare manualmente gli angoli o le coordinate dei pixel per posizionare i tuoi geni. GenomeDiagram legge nativamente la posizione di inizio, la posizione di fine e l'orientamento del filamento dagli oggetti feature standard di Biopython. Per metterlo in pratica, supponi di avere un record GenBank parsato per un piccolo plasmide. Per prima cosa, inizializzi un Diagram vuoto. Poi, crei un nuovo Track al suo interno, e un nuovo FeatureSet all'interno di quel Track. Successivamente, iteri sulle feature nel tuo record GenBank parsato. Controlli se il tipo di feature corrente è un CDS, ovvero una sequenza codificante. Quando trovi un CDS, lo passi al tuo FeatureSet per aggiungerlo alla visualizzazione. In questa fase, assegni lo stile visivo. Puoi dire alla feature di essere renderizzata come una freccia, che punta automaticamente in senso orario o antiorario in base al filamento del gene. Qui puoi anche assegnare colori distinti. Un trucco comune è usare un semplice contatore del loop per alternare due colori, in modo che i geni adiacenti non si fondano visivamente in un unico blocco massiccio. Una volta che la tua gerarchia è completamente popolata di dati, istruisci il Diagram a disegnarsi. Chiami il metodo draw e imposti il formato su circolare. Puoi definire le dimensioni della pagina, il colore di sfondo e lo scaling dei track. Dopo che il disegno è stato costruito in memoria, chiami semplicemente il metodo write, passando un nome file che termina in PDF o PNG. ReportLab calcola all'istante le lunghezze corrette degli archi, posiziona le frecce colorate lungo il track circolare ed esporta un file pronto per la pubblicazione. Il vantaggio principale di questa struttura a livelli è la riproducibilità. Poiché le regole di layout sono rigorosamente separate dal parsing della tua sequenza grezza, puoi scrivere un singolo script per applicare uno stile uniforme a un intero database di plasmidi senza mai toccare un tool di graphic design. Grazie per averci seguito. Alla prossima!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 16 di 18. Hai dati grezzi di genotipizzazione sul campo e ti servono metriche statistiche, ma colmare questo divario significa scrivere l'ennesimo script custom per parsare file di testo. Convertire questi dati raccolti sul campo in un formato pronto per l'analisi è noioso, a meno che tu non usi un parser creato appositamente per il formato standard Genepop. È qui che entra in gioco la genetica di popolazione con Bio.PopGen. Genepop è un software package e un formato file standard usato per calcolare metriche come l'equilibrio di Hardy-Weinberg, le F-statistics e il linkage disequilibrium. Il suo formato di input text-based, di solito salvato come file punto gen, è rigido. Si basa su line break rigorosi, keyword specifiche e codici integer incollati tra loro per gli alleli. Scrivere la tua logica custom per estrarre le frequenze alleliche su più loci e popolazioni ti espone a errori off-by-one. Il modulo Bio.PopGen evita completamente questo problema leggendo il formato Genepop direttamente in un oggetto Python strutturato. Prendi uno scenario concreto. Stai studiando due popolazioni isolate di pesci. Hai genotipizzato ciascun pesce in tre loci microsatellitari. I tuoi dati grezzi si trovano in un file punto gen standard. In cima al file c'è un titolo, seguito dai nomi dei tuoi tre marcatori su righe separate. Poi arriva la keyword Pop, che segna l'inizio della prima popolazione di pesci. Sotto, ogni riga rappresenta un pesce, mostrando un identifier seguito dai suoi alleli in tutti e tre i loci. Dopo l'ultimo pesce di quel gruppo, compare un'altra keyword Pop, che segna l'inizio della seconda popolazione. Per processare tutto questo, importi il modulo GenePop da Bio.PopGen. Apri il tuo file di testo e passi il file handle aperto alla funzione GenePop punto read. Questa funzione processa il testo e restituisce un singolo oggetto Record. Questa è la parte che conta. L'oggetto Record rispecchia la gerarchia biologica del tuo studio. Se controlli l'attribute loci list sul Record, ti restituisce una semplice sequenza contenente i nomi dei tuoi tre marcatori microsatellitari. Questo conferma che il parser ha letto correttamente l'header. Poi, puoi guardare l'attribute populations. Questo attribute contiene una list in cui ogni elemento rappresenta un'intera popolazione del tuo file. Dato che hai due keyword Pop nel tuo file, questa list contiene esattamente due elementi. Se guardi da vicino una di queste popolazioni, trovi una list degli individui che contiene. Ogni individuo è memorizzato come una coppia formata dal suo string identifier e da una list dei suoi genotipi. Per un organismo diploide, un genotipo in un singolo locus viene parsato come una coppia di alleli. Il file di testo Genepop spesso memorizza questi alleli come un'unica string combinata di cifre, come zero uno zero due. Il parser la divide automaticamente in alleli distinti, rappresentando zero uno e zero due come entità separate. Non devi scrivere logica di string slicing per separare gli alleli materni e paterni. Una volta parsato il file, hai accesso immediato ai nomi dei marcatori, ai conteggi delle popolazioni e ai dati dei singoli alleli. Puoi iterare sulle popolazioni per contare specifiche frequenze alleliche, oppure passare l'oggetto Record direttamente alle routine di Biopython che interagiscono con il software Genepop. Puoi avviare calcoli per l'eterozigosità attesa o misurare la differenziazione genetica tra i tuoi due gruppi isolati. Il valore del parser Bio.PopGen non sta solo nel leggere un file di testo, ma nel trasformare una flat list di string in una rigorosa gerarchia biologica di loci, popolazioni e individui, proprio come richiedono gli algoritmi statistici. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!

Ciao, sono Alex di DEV STORIES DOT EU. Fondamenti di Biopython, episodio 17 di 18. Hai sequenziato un gene e trovato una variante. Conoscere la sequenza raramente è sufficiente. Per comprendere il danno biologico effettivo, devi sapere esattamente quali reti metaboliche vengono interrotte dall'enzima risultante. Biochemical Pathways with KEGG fornisce esattamente questa mappa. La Kyoto Encyclopedia of Genes and Genomes mantiene vasti database che descrivono in dettaglio sistemi biologici, composti e reazioni. Distribuiscono questi dati come flat file in plain text standard. Questi file usano una struttura specifica in cui una keyword si trova sul margine sinistro, e i dati associati si trovano sulla destra. Il problema è che i valori dei dati, come lunghe liste di sinonimi o nomi complessi di pathway, spesso vanno a capo in modo imprevedibile su più righe. Scrivere una manipolazione di string custom per gestire questo a capo è fragile. Il modulo Bio punto KEGG esiste per gestire le stranezze di formattazione e tradurre quei file di testo direttamente in oggetti Python prevedibili. Per estrarre i dati molecolari di base, usi la funzione Compound punto parse all'interno del modulo KEGG. Le passi un file handle aperto che punta a un file di testo di compound KEGG. Invece di caricare un enorme dump del database in memoria tutto in una volta, il parser restituisce un iterator. Ogni volta che fai avanzare l'iterator, questo produce un singolo oggetto Python che rappresenta un compound. Da questo oggetto, puoi accedere all'attributo entry per ottenere l'identificatore univoco, che in genere si presenta come una C maiuscola seguita da numeri. Poiché i compound spesso hanno più nomi comuni nella letteratura, l'attributo name restituisce una list di string contenente tutti i sinonimi riconosciuti. Ottieni anche l'accesso diretto all'esatta struttura molecolare tramite l'attributo formula. I compound sono solo i materiali statici nel tuo sistema. Gli enzimi sono ciò che effettivamente guida le reazioni. Per analizzarli, passi alla funzione Enzyme punto parse, passandole un flat file di enzimi KEGG. Proprio come il parser dei compound, produce oggetti discreti uno alla volta. Controlli l'attributo entry per ottenere il numero EC standard, e l'attributo name per la designazione dell'enzima. Questa è la parte che conta. Un enzima non opera nel vuoto, e l'oggetto enzyme lo riflette attraverso il suo attributo pathway. Il parser legge il blocco di testo multi-linea che descrive in dettaglio le interazioni dell'enzima e lo struttura in una list pulita. Ogni elemento in quella list è una tuple contenente due dati. Il primo elemento nella tuple è l'identificatore del pathway KEGG, e il secondo è il nome human-readable di quel pathway metabolico. Puoi scriptare un processo di mapping completo in pochi passaggi. Per prima cosa, apri il tuo data file degli enzimi scaricato e lo passi alla funzione Enzyme punto parse. Crei un loop per leggere i record restituiti. Quando incontri un record in cui l'attributo entry fa match con il numero EC del tuo enzima mutato, prendi il suo attributo pathway. Puoi quindi iterare su quella list di tuple, estraendo i nomi dei pathway per vedere immediatamente se la mutazione influisce sulla glicolisi, sul ciclo del citrato, o su tutt'altro. Il vero potere dei parser KEGG non è solo leggere il testo, ma convertire componenti biologici isolati in coordinate di network interconnesse, permettendoti di tracciare una variante genetica localizzata fino a un fallimento metabolico sistemico. Se trovi utili questi episodi e vuoi supportare lo show, puoi cercare DevStoriesEU su Patreon. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a buildare!

Ciao, sono Alex di DEV STORIES DOT EU. Biopython Fundamentals, episodio 18 di 18. Hai appena eseguito un esperimento di RNA-seq e ora ti trovi di fronte a una matrice di espressione con diecimila righe. Trovare un significato in quei dati grezzi è impossibile finché non raggruppi quei geni in una manciata di risposte biologiche distinte. Questo è esattamente ciò che fa la Cluster Analysis per l'espressione genica, usando il modulo Bio dot Cluster. Quando analizzi dati di microarray o RNA-seq, stai tracciando l'attività dei geni attraverso diverse condizioni. Prendi uno scenario concreto. Hai dati di espressione per mille geni misurati in quattro time point di heat-shock. Vuoi identificare quali geni si comportano in modo simile. Magari una cinquantina di loro ha un picco all'ora due e un calo all'ora quattro. I geni con pattern di up e down regulation corrispondenti spesso condividono pathway biologici o meccanismi regolatori. Trovare queste coorti manualmente tra migliaia di righe è improponibile. Il modulo Bio dot Cluster contiene un core basato su C progettato specificamente per elaborare in modo efficiente questo tipo di dati matriciali. Il tuo primo passo è portare i dati dentro Biopython. Invece di scrivere una logica di parsing custom, passi il tuo file di testo tab-separated alla funzione read del modulo. Questa restituisce un oggetto Record specializzato. Questo oggetto contiene la tua matrice di espressione numerica, ma tiene anche traccia dei tuoi identificatori dei geni e dei nomi delle tue condizioni sperimentali. Con i dati caricati, applichi un algoritmo di clustering. L'approccio più comune è il K-means, eseguito usando la funzione kcluster. Il K-means partiziona i tuoi elementi in un numero predeterminato di gruppi, rappresentato dalla variabile k. Passi la matrice dei dati e il valore k che hai scelto alla funzione kcluster. La funzione restituisce quindi un array che assegna ogni singolo gene a uno specifico cluster ID, insieme a un valore di errore che misura quanto sono compatti quei cluster. Poiché l'algoritmo inizia con assegnazioni random, in genere lo esegui più volte e tieni l'iterazione che produce l'errore più basso. Ecco il punto chiave. L'algoritmo raggruppa i geni in base a una metrica di distanza, e devi scegliere quella metrica con attenzione. Se usi la distanza euclidea standard, l'algoritmo raggruppa i geni che hanno livelli di espressione assoluta simili. Ma se vuoi raggruppare i geni in base alla forma della loro curva di espressione nel tempo, indipendentemente dalla loro baseline iniziale, devi istruire la funzione kcluster a usare invece una metrica di distanza basata sulla correlazione. Il K-means ti richiede di indovinare il numero di cluster in anticipo. Se non sai quante risposte distinte esistono nei tuoi dati di heat-shock, puoi usare invece l'hierarchical clustering, tramite la funzione treecluster. Invece di forzare i geni in dei bucket piatti, treecluster costruisce una gerarchia. Trova i due geni con i pattern di espressione più identici e li collega. Poi trova il gene o la coppia successiva più vicina e li collega, costruendo una struttura ad albero ramificata chiamata dendrogramma. Una volta che l'albero connette tutti i mille geni, puoi osservare la struttura complessiva dei dati e tagliare i rami a qualsiasi livello abbia un senso biologico. Dato che questo è l'ultimo episodio della nostra serie Biopython Fundamentals, ti consiglio vivamente di aprire la documentazione ufficiale di Biopython e di provare queste funzioni di clustering su un dataset reale. Puoi anche visitare devstories dot eu per suggerire argomenti che vorresti venissero trattati nelle serie future. L'obiettivo finale dell'esecuzione di questi algoritmi non è solo ordinare numeri in dei bucket, ma scoprire la logica biologica condivisa che costringe quei geni ad attivarsi insieme. Questo è tutto per questo episodio. Grazie per l'ascolto, e continua a sviluppare!