lf374, SoftwareDevelopment: LINUX & PERL, strumenti del computer per lo studio e l’analisi di informazioni biologiche

Castellano Chinese Deutsch English Français Nederlands

Questo documento è disponibile in: Castellano ChineseGB Deutsch English Français Italiano

Carlos Andrés Pérez
<caperez /at/ usc.edu.co>

L'autore:

Carlos Andrés Pérez è specializzato in Simulazione Molecolare, Candidato al Dottorato in Biotecnologia. Consulente Tecnico del Grupo de Investigación en Educación Virtual (GIEV) - Gruppo di Ricerca in Apprendimento Virtuale. Indirizzo: Universidad Santiago de Cali, Calle 5ª carrera 62 Campus Pampalinda, Cali – Colombia.

Tradotto in Italiano da:
Lucia Di Gaeta <lucialinux/at/hotmail.co.uk>

Contenuto:

La Bioinformatica
Perl
Gestione del File Perl:
Ricerca di campioni di amminoacidi
Calcolo di frequenze di amminoacidi:
Riferimenti Bibliografici
Discussioni su quest'articolo

LINUX & PERL, strumenti del computer per lo studio e l’analisi di informazioni biologiche

Premessa:

Quest’articolo vuole dimostrare alcuni dei vantaggi della programmazione Perl programming su Unix, per l’estrazione di informazioni biologiche di DNA, RNA e Banca Dati delle sequenze delle proteine. Possono essere utilizzati in processi comparativi o nell’analisi. Il Menoma Umano progetta e le tecniche di clonazione del DNA hanno accelerato il progresso scientifico in quest’area. Le informazioni generate quotidianamente in questo campo superano spesso la capacità di processare le informazioni da un punto di vista evolutivo.

La proliferazione rapida delle informazioni biologiche su genomi differenti (il dono dei geni di un organismo) porta avanti la bioninformatica quale disciplina fondamentale per la gestione e l’analisi di questi dati.

_________________ _________________ _________________

La Bioinformatica

La bioinformatica è nata quando gli scienziati hanno cominciato a conservare le sequenze biologiche in formati digitali ed sono nati i primi programmi per compararle. La bioinformatica è stata limitata all’analisi delle sequenze per un lungo periodo di tempo. Tuttavia, l’importanza di stabilire la forma strutturale delle molecole ha portato i computers a diventare un importante strumento di investigazione nella teoria biochimica. Le informazioni e collezione di dati sulla conformazione tridimensionale delle molecole aumentavano ogni giorno. I geni sono cambiati: studiati prima in una forma individuale, si è poi passati ad una più completa ed estensiva. È molto più semplice ora capire come si comportano tra di loro, con le proteine e come si organizzano nei procedimenti metabolici. Ogni volta siamo più consapevoli di quanto sia importante organizzare i dati.

Ognuna delle attività descritte ha almeno due lati interessanti. Da un lato, l’interesse biologico è quello di conoscere le relazioni tra le molecole vive e dall’altro l’assemblaggio diventa un interessante problema di software grafico da risolvere. La necessità è combinare ed integrare le informazioni biologiche per ottenere una visione globale ed effettiva dei processi biologici che si verificano. Abbiamo anche notato la necessità di combinare le differenti aree nella scienza computerizzata per giungere ad una soluzione effettiva. Una è la gestione della banca dati, come pure l’integrazione dei dati: algoritmi efficienti, un hardware potente – griglie, multiprocessori, etc.

Perl

Larry Wall cominciò lo sviluppo di Perl nel 1986. Perl è un linguaggio di programma decodificato, ideale per manipolare testi, file e processi. Perl consente di sviluppare piccoli programmi velocemente. Si può dire che Perl è un mix ottimizzato di un linguaggio ad alto livello (per esempio C) ed un linguaggio trascritto (per esempio bash).

I programmi Perl possono lavorare su diversi sistemi e piattaforme operative. Tuttavia, Perl è nato ed è stato diffuso con il sistema operativo UNIX. Perl ha pienamente superato il suo scopo iniziale grazie all’impulso che ha ricevuto come uso immediato di linguaggio per applicazioni web. Prima che Perl fosse disponibile usedawk,thirst egrep erano gli strumenti per analizzare i files ed estrarre informazioni.

Perl riunisce le possibilità di questi strumenti UNIX in un unico programma estendendo e modernizzando ognuna di esse con ulteriori funzionalità.

Perl è un linguaggio per programmare gratuito ed è possible avviarlo in ognuno dei sistemi operativi che sono generalmente presenti nei laboratori di ricerca biologica. Con UNIX e MacOSX è pre-installato, in altri è necessario installarlo. Per il sistema che stiamo usando, è sufficiente scaricarlo dal sito:http://www.cpan.org .

I programmi Perl in Linux, sono chiamati con il nome del file che contiene le istruzioni per eseguirli. Le istruzioni sono conservate in un file e Perl è richiamato con il nome del file come argomento.

Un altro metodo usato è conservare le istruzioni Perl in un file, ma senza richiamare Perl con il file come argomento. Per questo dobbiamo fare due cose: (a) inserire un commento speciale nella prima linea del programma:

#!/usr/bin/env perl

print "Hi\n";

e (b) conservare il file ed assegnarvi le proprietà di esecuzione di UNIX:

% chmod +x greetings.pl

Una volta fatto questo, il programma può essere usato nominandolo con il nome del file.

Gestione del File Perl:

Quando abbiamo una banca dati delle sequenza molecolari in formato di testo, possiamo rendere Perl uno strumento per la ricerca di sequenze. In quest’esempio vediamo come cercare per una sequenza di proteine in una banca dati con il formato SWISS-PROT (db_human_swissprot), usando il suo codice id.

#!/usr/bin/perl

# Cercate una sequenza di amminoacidi in una banca dati

# SWISS-PROT formattata, dato un codice id 

# Chiedete del codice nel campo ID

# Chiedete del codice nel campo ID

print "Enter the ID to search: ";
$id_query=<STDIN>;
chomp $id_query;
# Apriamo il file della banca dati

# ma se non é possible, il programma sará terminato

open (db, "human_kinases_swissprot.txt") ||
 die "problem opening the file human_kinases_swissprot.txt\n";
# Controllate ogni linea nella banca dati

while (<db>) {
chomp $_;
# Controllate che siate nel campo ID
if ($_ =~ /^ID/) {
# Se é possibile, otteniamo l’informazione 

# interrompendo le linee con degli spazi

($a1,$id_db) = split (/\s+/,$_);
# ma se non c’é alcuna coincidenza di ID continuiamo come segue 

next if ($id_db ne $id_query);
# Quando coincidono, inseriamo una nota 

$signal_good=1;
# Poi controlliamo il campo di sequenza 

# se la nota é 1(sequenza scelta)# Se positivo, cambiamo la nota con 2, per raccogliere la sequenza

} elsif (($_ =~ /^SQ/) && ($signal_good==1)) {
$signal_good=2;
# Infine, se la nota é 2, presentiamo ogni linea della sequenza

# finché la linea comincia con  //
# in questo caso, interrompiamo il while
} elsif ($signal_good == 2) {
last if ($_ =~ /^\/\//);
print "$_\n";
}
}
# Quando abbiamo lasciato le istruzioni while, controlliamo la nota 

# Se negativo, significa che non troveremo la sequenza scelta

# e questo ci dará un errore

if (!$signal_good) {
print "ERROR: "."Sequence not found\n";
}
# Infine, chiudiamo il file
# che é ancora aperto.

close (db);
exit;

Ricerca di campioni di amminoacidi

#!/usr/bin/perl
# Cercate i modelli di amminoacidi
# Chiedete i modelli per la ricerca all’utente
print "Please, introduce the pattern to search in query.seq: ";
$patron = <STDIN>;
chomp $patron;
# Aprite il file della banca dati
# se non é possibile, il programma sará terminato
open (query, "query_seq.txt") || die "problem opening the file query_seq.txt\n";
# Controllate per ogni linea la sequenza SWISS-PROT
while (<query>) {
chomp $_;
# Quando giungete al campo SQ, inserite il commento in 1

   if ($_ =~ /^SQ/) {

         $signal_seq = 1;
# Quando si arriva alla fine della sequenza, lasciate il curl

# Controllate che questa espressione sia inserita prima di controllare 

# il commento=1,poiché questa linea non appartiene alla sequenza di amminoacidi

   } elsif ($_ =~ /^\/\//) {

         last;
# Controllate che il commento sia uguale a 1, se positivo

# eliminate gli spazi bianchi nella linea della sequenza 

# ed unite ogni linea in una nuova variabile  

# Per concatenare, possiamo anche:

# $secuencia_total.=$_;

   } elsif ($signal_seq == 1) {

         $_ =~ s/ //g;

         $secuencia_total=$secuencia_total.$_;

   }

  }
# Controllate ora la sequenza, raccoglietela nella sua interezza,

# per il modello dato

  if ($secuencia_total =~ /$patron/) {

   print "The sequence query.seq contains the pattern $patron\n";

  } else {

   print "The sequence query.seq doesn't contain the pattern $patron\n";

  }
# Infine chiudiamo il file

# ed usciamo dal programma 

close (query);

exit;

Se vogliamo conoscere la posizione esatta in cui il campione è stato trovato, dobbiamo usare la variabile speciale `$&'. Questa variabile mantiene il modello trovato dopo aver valutato una regolare espressione (sarebbe necessario porlo subito dopo la linea ` if ($$secuencia_total>= ~/$$patron>/) {`. In più è possible combinare con le variabili ` $ ` ' e ` $ ´ ' che conserva tutto a sinistra e a destra del modello trovato. Modificate il programma precedente con le nuove variabili, per fornire una posizione esatta del campione. Nota: anche voi potete trovare utile la funzione length che fornisce la lunghezza di una catena.

# Dobbiamo solo cambiare l’if dove il modello é stato trovato
# Controllate la sequenza, raccoglietela nella sua interezza,

# per il modello dato

# e controllate la sua posizione nella sequenza

  if ($secuencia_total =~ /$patron/) {

   $posicion=length($`)+1;

   print "The sequence query_seq.txt contains the pattern $patron in the following position $posicion\n";
  } else {

  print "The sequence query_seq.txt doesn't contain the pattern $patron\n";

  }

Calcolo di frequenze di amminoacidi:

La frequenza dei differenti amminoacidi nelle proteine è variabile, quale risultato delle sue diverse funzioni o ambienti favoriti. In quest’esempio vedremo come calcolare la frequenza di amminoacidi di una data sequenza di amminoacidi.



#!/usr/bin/perl
# Calcolate la frequenza di amminoacidi in una sequenza proteica
# Ottenete il nome del file dalla linea di comando
# (SWISS-PROT formattata)
# Puó anche essere richiesta con la stampa da <STDIN>
if (!$ARGV[0]) {print "The execution line shall be: program.pl file_swissprot\n";}
$fichero = $ARGV[0];
# Inizializzate la variabile $errores
my $errores=0;
# Aprite il file per leggere
open (FICHA, "$fichero") || die "problem opening the file $fichero\n";
# Controlliamo prima la sequenza come nell’esempio 2
while (<FICHA>) {
chomp $_;
if ($_ =~ /^SQ/) {
$signal_good = 1;
} elsif ($signal_good == 1) {
   last if ($_ =~ /^\/\//);
   $_ =~ s/\s//g;
   $secuencia.=$_;
}
}
close (FICHA);
# Usiamo ora un curl che controlli ogni posizione degli amminoacidi nella
# sequenza (da una sua propria funzione, che puó essere usata poi in altri
# programmi)
comprueba_aa ($secuencia);
# Stampate i risultati sullo schermo
# Prima i  20 amminoacidi, poi le catene con le loro frequenze
# In questo caso, 'sort' non puó essere usato in foreach,
# poiché le catene contengono le frequenze (numeri)
print"A\tC\tD\tE\tF\tG\tH\tI\tK\tL\tM\tN\tP\tQ\tR\tS\tT\tV\tW\tY\n";
foreach $each_aa (@aa) {
print "$each_aa\t";
}
# Poi si possono verificare dei possibili errori
# ed il programma terminato
print "\nerrores = $errores\n";
exit;
# Funzioni
# Queste calcolano ogni frequenza di amminoacidi # da una sequenza proteica
sub comprueba_aa {
# Ottenete la sequenza
my ($secuencia)=@_;
# ed avviate amminoacido per amminoacido, usando a per il movimento
# da 0 per tutta la lunghezza della sequenza
for ($posicion=0 ; $posicion<length $secuencia ; $posicion++ ) {
# Ottenete l’amminoacido
$aa = substr($secuencia, $posicion, 1);
# e controllate quale sta usando if
# una volta fatto, aggregate 1 alla frequenza corrispondente
# in una tavola usando un puntatore per ognuno
# ordinate in ordine alfabetico
if ( $aa eq 'A' ) {
$aa[0]++;
} elsif ( $aa eq 'C' ) {
$aa[1]++;
} elsif ( $aa eq 'D' ) {
$aa[2]++;
} elsif ( $aa eq 'E' ) {
$aa[3]++;
} elsif ( $aa eq 'F' ) {
$aa[4]++;
} elsif ( $aa eq 'G' ) {
$aa[5]++;
} elsif ( $aa eq 'H' ) {
$aa[6]++;
} elsif ( $aa eq 'I' ) {
$aa[7]++;
} elsif ( $aa eq 'K' ) {
$aa[8]++;
} elsif ( $aa eq 'L' ) {
$aa[9]++;
} elsif ( $aa eq 'M' ) {
$aa[10]++;
} elsif ( $aa eq 'N' ) {
$aa[11]++;
} elsif ( $aa eq 'P' ) {
$aa[12]++;
} elsif ( $aa eq 'Q' ) {
$aa[13]++;
} elsif ( $aa eq 'R' ) {
$aa[14]++;
} elsif ( $aa eq 'S' ) {
$aa[15]++;
} elsif ( $aa eq 'T' ) {
$aa[16]++;
} elsif ( $aa eq 'V' ) {
$aa[17]++;
} elsif ( $aa eq 'W' ) {
$aa[18]++;
} elsif ( $aa eq 'Y' ) {
$aa[19]++;
# Se l’amminoacido non viene trovato
# 1 é inserito negli errori
} else {
print "ERROR: Aminoacid not found: $aa\n";
$errores++;
}
}
# Infine, ritornate alla catena di frequenza
return @aa;
}

Ora effettuiamo il passo successivo che segue il fluire di informazioni in una cellula, dopo la trascrizione. Una è la traduzione, per cui una sequenza di ARN che proviene da un gene, che era di DNA, passa alle sequenze di proteine e amminoacidi. Perciò dovremmo visualizzare il codice genetico, che si basa su quale tripletta di ARN/ADN corrisponde ad un amminoacido. La sequenza che estrarremo è di una carta genetica di Escherichia coli, in formato EMBL e presto verificheremo la traduzione con l’amminoacido. Per questo esempio, sarà necessario introdurre le variabili associative di catene o tavole hash. Nel programma dovremmo considerare che l’area codificarte è sufficiente ed è inclusa nel campo 'FT CDS.



#!/usr/bin/perl
# Traducete una sequenza ADN da un documento EMBL
# nell’ amminoacido corrispondente
# Ottenete il nome del file dalla linea di comando
# (SWISS-PROT formattato)
# Puó anche essere richiesta con la stampa da <STDIN>
if (!$ARGV[0]) {print "The program line shall be: program.pl ficha_embl\n";}
$fichero = $ARGV[0];
# Aprite il file per leggerlo
open (FICHA, "$fichero") || die "problem opening the file $fichero\n";
# Controllate la sequenza come nell’esempio 2
while (<FICHA>) {
chomp $_;
if ($_ =~ /^FT CDS/) {
$_ =~ tr/../ /;
($a1,$a2,$a3,$a4) = split (" ",$_);
}
elsif ($_ =~ /^SQ/) {
$signal_good = 1;
} elsif ($signal_good == 1) {
last if ($_ =~ /^\/\//);
# Eliminate numberi e spazi
$_ =~ tr/0-9/ /;
$_ =~ s/\s//g;
$secuencia.=$_;
}
}
close (FICHA);
# Definiamo una catena associata con le corrispondenze
# di ogni amminoacido con il suo nucleotide
# corrispondente (anche in una funzione propria,
# per if lo stesso codice genetico é usato in altri programmi
my(%codigo_genetico) = (
'TCA' => 'S',# Serine
'TCC' => 'S',# Serine
'TCG' => 'S',# Serine
'TCT' => 'S',# Serine
'TTC' => 'F',# Fenilalanine
'TTT' => 'F',# Fenilalanine
'TTA' => 'L',# Leucine
'TTG' => 'L',# Leucine
'TAC' => 'Y',# Tirosine
'TAT' => 'Y',# Tirosine
'TAA' => '*',# Stop
'TAG' => '*',# Stop
'TGC' => 'C',# Cysteine
'TGT' => 'C',# Cysteine
'TGA' => '*',# Stop
'TGG' => 'W',# Tryptofane
'CTA' => 'L',# Leucine
'CTC' => 'L',# Leucine
'CTG' => 'L',# Leucine
'CTT' => 'L',# Leucine
'CCA' => 'P',# Proline
'CCC' => 'P',# Proline
'CCG' => 'P',# Proline
'CCT' => 'P',# Proline
'CAC' => 'H',# Hystidine
'CAT' => 'H',# Hystidine
'CAA' => 'Q',# Glutamine
'CAG' => 'Q',# Glutamine
'CGA' => 'R',# Arginine
'CGC' => 'R',# Arginine
'CGG' => 'R',# Arginine
'CGT' => 'R',# Arginine
'ATA' => 'I',# IsoLeucine
'ATC' => 'I',# IsoLeucine
'ATT' => 'I',# IsoLeucine
'ATG' => 'M',# Methionina
'ACA' => 'T',# Treonina
'ACC' => 'T',# Treonina
'ACG' => 'T',# Treonina
'ACT' => 'T',# Treonina
'AAC' => 'N',# Asparagina
'AAT' => 'N',# Asparagina
'AAA' => 'K',# Lisina
'AAG' => 'K',# Lisina
'AGC' => 'S',# Serine
'AGT' => 'S',# Serine
'AGA' => 'R',# Arginine
'AGG' => 'R',# Arginine
'GTA' => 'V',# Valine
'GTC' => 'V',# Valine
'GTG' => 'V',# Valine
'GTT' => 'V',# Valine
'GCA' => 'A',# Alanine
'GCC' => 'A',# Alanine
'GCG' => 'A',# Alanine
'GCT' => 'A',# Alanine
'GAC' => 'D',# Aspartic Acid
'GAT' => 'D',# Aspartic Acid
'GAA' => 'E',# Glutamic Acid
'GAG' => 'E',# Glutamic Acid
'GGA' => 'G',# Glicine
'GGC' => 'G',# Glicine
'GGG' => 'G',# Glicine
'GGT' => 'G',# Glicine
);
# Traducete ogni codon nel suo amminoacido corrispondente
# ed aggregatelo alla sequenza proteica
print $a3;
for($i=$a3 - 1; $i < $a4 - 3 ; $i += 3) {
$codon = substr($secuencia,$i,3);
# Passate il codon da minuscolo (formato EMBL) a maiuscolo
$codon =~ tr/a-z/A-Z/;
$protein.= codon2aa($codon);
}
print "This proteinic sequence of the gen:\n$secuencia\nis the following:\n$protein\n\n";
exit;

Riferimenti Bibliografici

Discussioni su quest'articolo

ogni articolo possiede una sua pagina di discussione, da questa pagina puoi inviare un commento o leggere quelli degli altri lettori:

pagina di discussione

<--, LF Home

Indice di questo numero

Translation information:

es --> -- : Carlos Andrés Pérez <caperez /at/ usc.edu.co>

en --> es: Carlos Andrés Pérez <caperez /at/ usc.edu.co>

en --> it: Lucia Di Gaeta <lucialinux/at/hotmail.co.uk>

2006-11-01, generated by lfparser version 2.54