BioinformaticaLinguaggio Perl (1)

Dr. Giuseppe Pigola – pigola@dmi.unict.itDr. Alessandro Laganà – lagana@dmi.unict.it

Cos’è PERL? PERL (Practical Extraction and Report Language) è un

linguaggio di programmazione interpretato General Purpose.

Viene usato in ogni settore come linguaggio colla, cioè adatto ad unire vari elementi. Scrivere un Database, un foglio elettronico, un

Sistema Operativo o un server Web completo in PERL sarebbe possibile ma praticamente inutile.

La funzione principale di PERL è invece unire i vari elementi.

2 Bioinformatica

PERL linguaggio colla PERL può prendere un database, convertirlo in un

file adatto per un foglio elettronico e, durante l’elaborazione, correggere i dati.

PERL è anche in grado di prendere i documenti di un elaboratore di testi e convertirli nel formato HTML per la visualizzazione sul Web.

Essendo un linguaggio mirato ad unire gli elementi, PERL si adatta facilmente alle varie situazioni. Ha uno stile di programmazione molto flessibile e quindi è possibile eseguire la stessa operazione in più modi.

3 Bioinformatica

Link e Risorse Sito ufficiale:

http://www.perl.org/

Sito Italiano: http://www.perl.it/

Active Perl: http://www.activestate.com/

4 Bioinformatica

Il primo programma PERL

Una volta digitato il programma nell’editor di testo, lo salviamo come hello. Non è necessario aggiungere l’estensione del file, anche se PERL consente di farlo. Le estensioni più comuni sono .pl o .plx.

Per eseguire il programma è necessario aprire la finestra Prompt dei comandi, possibilmente nella directory in cui è stato salvato hello.pl.

#!/usr/bin/perl

print “Hello, World!\n”;

5 Bioinformatica

PERL passo per passo Per PERL tutto ciò che appare dopo il simbolo # è un

commento. Il simbolo #! sulla prima riga di un programma è diversa in alcuni casi: il nome di percorso che segue fa riferimento al percorso dell’interprete PERL: #!/usr/bin/perl

Se un file UNIX inizia con il simbolo #! seguito dal percorso di un interprete, UNIX sa che si tratta di un programma e sa anche come interpretarlo. Lo stesso vale per alcuni server Web, tra cui APACHE;

6 Bioinformatica

#!/usr/bin/perl

use strict; # Forza la dichiarazione di variabili

use warning; # Forza l’inizializzazione di variabili, controlla deprecated;

PERL, linguaggio a forma libera PERL è noto come linguaggio di programmazione a

forma libera; ciò significa che le istruzioni di PERL non sono esigenti sul modo in cui sono scritte. In un’istruzione PERL è possibile inserire spazi, tabulazioni, ritorni a capo, senza problemi (a meno che non vengano spezzate delle parole chiave):

#!/usr/bin/perl

print

“Hello, World!\n”

;

7 Bioinformatica

Unità di base di PERL:numeri e stringhe In PERL, i numeri e le stringhe sono le unità di base

e prendono il nome di scalari.

Così come in altri linguaggi di programmazione, in PERL esistono scalari costanti (o letterali) e scalari variabili.

8 Bioinformatica

I letterali numerici

PERL offre due tipi diversi di costanti scalari di nome letterali: i letterali numerici e i letterali stringa.

I letterali numerici sono numeri e PERL consente di scrivere i numeri in diversi modi:

Numero Tipo di letterale

6 Un intero

12.5 Un numero in virgola mobile

15. Un altro numero in virgola mobile

.732058 Un altro numero in virgola mobile

1e10 Notazione scientifica

6.67E-33 Notazione scientifica

4_294_296 Un numero grande con caratteri di sottolineatura come separatore di migliaia

9 Bioinformatica

I letterali stringa

In PERL i letterali stringa sono sequenze di caratteri, come Hello, World. E’ necessario racchiudere le stringhe letterali in apici, singoli ‘ ‘ o doppi “ “:

Gli apici all’interno delle stringhe devono essere preceduti dal simbolo di backslash \.

“foo!”

‘Fourscore and seven years ago’

“”

“Then I said to him, \”Go ahead!\””

‘The doctor\’s stethoscope was cold.’

10 Bioinformatica

I letterali stringa (2) La differenza principale tra le stringhe con doppi apici “ “

e quelle con apici singoli ‘ ‘ è che queste ultime sono letterali.

Ogni carattere in una stringa con apici singoli significa esattamente tale carattere.

D’altra parte, in una stringa con doppi apici, PERL controlla se sono presenti nomi di variabili o sequenze di escape e li traduce se li trova.

Le sequenze di escape sono stringhe speciali che consentono di incorporare caratteri nelle stringhe quando la digitazione degli stessi causerebbero problemi.

11 Bioinformatica

Alcune sequenze di escape

Sequenza Rappresenta

\n Nuova riga

\r Ritorno a capo

\t Tabulazione

\b Backspace

\u Visualizza il carattere seguente in maiuscolo

\l Visualizza il carattere seguente in minuscolo

\\ Un carattere backslash letterale

\’ Un ‘ letterale all’interno di una stringa racchiusa tra apici singoli

\” Un “ letterale all’interno di una stringa racchiusa tra apici doppi

12 Bioinformatica

Operatori q e qq (Delimitatori) Oltre agli apici PERL offre gli operatori qq e q. Per

usare qq si può racchiudere il letterale stringa in qq( ) al posto degli apici:

E’ possibile usare l’operatore q al posto degli apici singoli per racchiudere il testo:

qq(I said, “Go then,” and he said “I’m gone”)

q(Tom’s kite wedged in Sue’s tree)

13 Bioinformatica

Operatori q e qq (2) Al posto delle parentesi si può usare qualsiasi altro

carattere non alfabetico e non numerico per delimitare una stringa:

Il carattere da usare come delimitatore deve comparire subito dopo l’operatore q o qq.

Se si usa una coppia di caratteri ( ), <>,{ } o [ ] come delimitatori, dovranno essere nidificati appropriatamente:

Tuttavia questo metodo non rende i programmi molto leggibili, per cui conviene scegliere delimitatori che non appaiono nella stringa:

q/Tom’s kite wedged in Sue’s tree/

q,Tom’s kite wedged in Sue’s tree,

q(Joe (Tom’s dad) fell out of a (rather large) tree.);

Q[Joe (Tom’s dad) fell out of a (rather large) tree.];

14 Bioinformatica

Variabili scalari Per memorizzare dati scalari in PERL è necessario

usare una variabile scalare. In PERL le variabili scalari sono indicate con il simbolo del dollaro ($ - Identificatore del tipo) seguito dal nome della variabile:

$a

$total

$Date

$serial_number

$cat450

15 Bioinformatica

Variabili scalari (2) Gli altri tipi di variabili (hash e array) usano un

identificatore diverso o addirittura nessun identificatore (filehandle).

I nomi delle variabili in PERL, siano esse hash, array, filehandle o scalari, devono essere conformi alle regole seguenti: Possono contenere caratteri alfabetici (a-z, A-Z),

numeri o caratteri di sottolineatura (_) dopo l’identificatore del tipo. Tuttavia il primo carattere del nome non può essere un numero.

I nomi delle variabili sono sensibili alle maiuscole/minuscole

16 Bioinformatica

Variabili scalari (3) PERL riserva per sé stesso nomi di variabili di un solo

carattere che non iniziano con un carattere alfabetico o di sottolineatura. Le variabili come $_, $”, $/, $2 e $$ sono variabili speciali la cui funzione sarà spiegata in seguito.

Le variabili scalari in PERL non devono essere dichiarate o inizializzate prima di poterle usare.

Per creare una variabile scalare è sufficiente usarla. PERL usa un valore predefinito quando una variabile non è inizializzata. Se è usata come numero PERL userà il valore 0, se è usata come stringa PERL userà la stringa vuota “”.17 Bioinformatica

La variabile speciale $_ PERL dispone di una variabile speciale $_ il cui

valore è usato come “predefinito” da molti operatori e funzioni.

Per esempio se si digita print senza specificare una variabile scalare o un letterale stringa da stampare, PERL stamperà il valore corrente di $_:

$_=“Dark Side of the Moon”

print; # Stampa il valore di $_

18 Bioinformatica

Espressioni Un semplice programma PERL:

Un’espressione (in rosso) in PERL è semplicemente qualcosa con un valore.

Per esempio 2 è un’espressione valida. I valori delle espressioni sono calcolati

all’esecuzione del programma.

#!/usr/bin/perl –w

$radius=50;

$area=3.14159*($radius ** 2);

print $area

19 Bioinformatica

Operatori: Assegnazione L’operatore di assegnazione = prende il valore a

destra e lo inserisce nella variabile a sinistra:

L’operando di sinistra deve essere qualcosa a cui può essere assegnato un valore. L’operando a destra può essere qualsiasi tipo di espressione. L’intera assegnazione è un’espressione:

$title=“Gone with the wind”;

$pi=3.14159;

$a=$b=$c=97;

$count=$count+1;

20 Bioinformatica

Operatori numerici

Esempio Nome operatore

5 + $t Addizione

$t - $s Sottrazione

$e * $pi Moltiplicazione

$f / 6 Divisione

24 % 5 Modulo

4 ** 2 Potenza

21 Bioinformatica

Operatori stringa Concatenazione:

Interpolazione di variabili:

$a=“Hello, World!”;

$b=“Nice to meet you”;

$c=$a . $b;

$name=“John”;

print “I went to the store with $name.”;

22 Bioinformatica

Operatori stringa (2) L’interpolazione si può impedire usando gli apici

singoli o facendo precedere l’identificatore della variabile da un backslash:

La concatenazione si può eseguire così:

$name=“Ringo”;

print ‘I used the variable $name’

print “I used the variable \$name”

$fruit1=“apples”;

$fruit2=“and oranges”;

$bowl=“$fruit1 $fruit2”;

23 Bioinformatica

Operatori stringa (3) Se il nome di una variabile è seguito

immediatamente da lettere, numeri o apici, PERL non sarà in grado di distinguere chiaramente dove finisce il nome della variabile e inizia il resto della stringa. In questo caso si possono usare parentesi graffe { } attorno al nome della variabile:

$date=“Thurs”;

Print “I went to the fair on ${date}day”;

$name=“Bob”;

Print “This is ${name}’s house”;

24 Bioinformatica

Operatori stringa (4) x è l’operatore di ripetizione; prende due valori, una

stringa da ripetere e il numero di volte da ripeterla:

$line=“-” x 70; # Stampa 70 volte – e memorizza il risultato in $line

25 Bioinformatica

Operatori unari Operatori unari con simbolo:

Operatori unari con nome:

-6; # 6 negativo

-(-5); # 5 positivo

Operatore Esempio Risultato

int int(5.6234) 5

length length(“nose”) 4

lc lc(“ME TOO”) “me too”

uc uc(“hal 9000”) “HAL 9000”

cos cos(50) Coseno di 50 in radianti

rand rand(5) Numero casuale compreso tra 0 e 5 (tra 0 e 1 se l’argomento è omesso)

26 Bioinformatica

Incremento e decremento

$counter++; # incrementa la variabile counter

$counter--; # decrementa la variabile counter

$a=“c9”;

$a++;

print $a; # stampa d0

$a=“zzz”;

$a++;

print $a; # stampa aaaa

27 Bioinformatica

Operatore angolare < > Questo operatore è usato per leggere e scrivere file. La sua

forma più semplice <STDIN> indica a PERL che una riga di input dovrebbe essere letta dal dispositivo di input (tastiera):

La riga di testo letta da <STDIN> include anche il carattere di nuova riga digitato premendo invio. E’ possibile rimuoverlo utilizzando la funzione chomp:

print “What size is your shoe?”;

$size=<STDIN>;

print “Your shoe size is $size. Thank you!\n”;

print “What size is your shoe?”;

$size=<STDIN>;

Chomp $size;

print “Your shoe size is $size. Thank you!\n”;28 Bioinformatica

Altri operatori di assegnazione La regola generale per creare un’assegnazione con

un operatore è la seguente: variabile operatore=espressione

Questa forma di assegnazione equivale a: variabile=variabile operatore espressione

Ad esempio:

$a=$a+3;

$a+=3; # uguale alla riga precedente

$line.=“, at the end” # accoda la stringa “, at…” a $line

$t%=67; # divide $t per 67 e inserisce il resto in $t29 Bioinformatica

Considerazioni su stringhe e numeri PERL consente spesso di usare numeri e stringhe in

modo intercambiabile. Se un elemento ha l’aspetto di un numero PERL può usarlo come tale se ne ha bisogno:

$a=42; # un numero

print $a+18; # stampa 60

$b=“50”; # una stringa

print $b-10; # stampa 40

30 Bioinformatica

Considerazioni su stringhe e numeri (2)

Allo stesso modo se un elemento ha l’aspetto di un numero, quando PERL necessita di una stringa può rappresentarlo come tale:

Se un elemento non ha l’aspetto di un numero ma viene usato dove era previsto l’uso di un numero PERL usa al suo posto il valore 0:

$a=42/3; # un numero

$a=$a . “Hello”; # usa un numero come stringa

print $a; # stampa “14Hello”

$a=“Hello, World!”;

print $a+6; # visualizza il numero 6, la stringa vale 0

# PERL ci avvisa della circostanza se attiviamo –w sulla riga #!31 Bioinformatica

Controllare il flusso del programma Blocchi di istruzioni;

Operatori;

Cicli;

Etichette;

Come uscire da PERL dopo l’esecuzione di un programma;

32 Bioinformatica

Blocchi Il metodo principale per raggruppare le istruzioni in

PERL è rappresentato dai blocchi:

{

istruzione_a;

istruzione_b;

istruzione_c;

}

{

istruzione_a;

{

istruzione_x;

istruzione_y;

}

}

33 Bioinformatica

L’istruzione if

if (espressione) blocco

if (espressione)

blocco1

else

blocco2

$r=<STDIN>;

chomp $r;

If ($r == 10) {

print “$r is 10”;

} else {

print “$r is something other than 10…”;

$r=10;

print “$r has been set to 10”;

}

34 Bioinformatica

Elsif

if (espressione1)

blocco1

elsif (espressione2)

blocco2

else

blocco3

$r=<STDIN>;

if ($r == 10) {

print “$r is 10!”;

} elsif ($r == 20) {

print “$r is 20!”;

} else {

print “$r is neither 10 nor 20”;

}

35 Bioinformatica

Altri operatori relazionali

Operatore Esempio Descrizione

== $s == $t Vero se $s è uguale a $t

> $s > $t Vero se $s è maggiore di $t

< $s < $t Vero se $s è minore di $t

>= $s >= $t Vero se $s è maggiore o uguale a $t

<= $s <= $t Vero se $s è minore o uguale a $t

!= $s != $t Vero se $s non è uguale a $t

36 Bioinformatica

Uso improprio degli operatori relazionali Consideriamo il seguente esempio:

Dato che PERL si aspetta valori numerici, le stringhe vengono valutate 0, per cui l’espressione precedente è simile a

$first=“Simon”;

$last=“Simple”;

if ($first == $last) {

print “The words are the same!\n”;

}

if (0 == 0)

37 Bioinformatica

Operatori relazionali per valori non numerici

Operatore Esempio Descrizione

eq $s eq $t Vero se $s è uguale a $t

gt $s gt $t Vero se $s è maggiore di $t

lt $s lt $t Vero se $s è minore di $t

ge $s ge $t Vero se $s è maggiore o uguale a $t

le $s le $t Vero se $s è minore o uguale a $t

ne $s ne $t Vero se $s non è uguale a $t

38 Bioinformatica

Significato di “vero” per PERL Il numero 0 è falso;

La stringa vuota “” e la stringa “0” sono false;

Il valore non definito undef è falso;

Tutto il resto è vero.

Quando si verifica un’espressione per vedere se è vera o falsa questa viene semplificata, quindi viene convertita in un valore scalare per poter determinare se è vera o falsa.

39 Bioinformatica

Operatori logici

Operatore Esempio Analisi

&& $s && $t Vera solo se $s e $t sono vere

and $s and $t

|| $s || $t Vera se $a è vera o $b è vera

or $s or $t

! ! $m Vera se $m non è vera

not Not $m

40 Bioinformatica

Circuito breve

La valutazione di un’espressione logica viene interrotta quando può essere determinata la verità (circuito breve):

In questo caso se $a o $b è falsa, deve essere valutata la parte destra dell’operatore or e il messaggio viene modificato. Se sia $a sia $b sono vere, l’operatore or deve essere vero e non è necessario valutare la parte destra.

$message = “A e B sono entrambe vere.”

($a and $b) or $message=“A e B non sono entrambe vere”

41 Bioinformatica

Ancora sugli operatori logici Gli operatori logici di PERL non si limitano a

restituire solo vero o falso. In realtà restituiscono l’ultimo valore valutato.

Per es. l’espressione 5 && 7 restituisce 7.

Se $old è vera l’espressione $new = $old è vera. Questo è più conciso di:

$new=$old || “default”

$new=$old;

if (! $old) {

$new=“default”;

}

42 Bioinformatica

Cicli while e for

while (espressione) blocco

For (inizializzazione; test; incremento) blocco

$counter=0;

while ($counter < 10) {

print “Still counting…$counter\n”;

$counter++;

}

for ($a=0; $a<10; $a=$a+2) {

print “a is now $a\n”;

}

43 Bioinformatica

Disposizioni strane… Le istruzioni if possono usare un altro tipo di sintassi.

Se all’interno del blocco if c’è una sola espressione, questa può precedere le istruzioni if:

diventa:

if (test_espressione) {

espressione;

}

espressione if (test_espressione);

$correct=1 if ($guess == $question);

Print “No pi for you!” if ($ratio != 3.14159);

44 Bioinformatica

Controllo più preciso L’istruzione last permette di uscire dal blocco più

interno del ciclo in esecuzione:

while($i<15) {

last if ($i==5); # il ciclo termina quando $i vale 5

$i++;

}for($i=0; $i<100; $i++) {

for($j=0; $j<100; $j++) {

if ($i * $j == 140) {

print “The product of $i and $j is 140\n”;

last; } } }

45 Bioinformatica

L’istruzione next

L’istruzione next riporta il controllo di nuovo nel ciclo e fa ricominciare l’iterazione successiva del ciclo, se questo non è stato completato.

L’istruzione redo è simile a next a eccezione del fatto che la condizione non viene rivalutata e PERL riprende l’esecuzione dall’inizio del blocco senza controllare se la condizione di fine è soddisfatta o no.

for($i=0; $i<100; $i++) {

next if (not $i % 2);

print “An odd number=$i\n”;

}

46 Bioinformatica

Etichette PERL consente di etichettare i blocchi e alcune

istruzioni di ciclo (for, while):

MIOBLOCCO: {

}

OUTER: while($expr) {

INNER: while($expr) {

statement;

}

}

47 Bioinformatica

Etichette e last, redo, next Le istruzioni last, redo e next possono prendere

un’etichetta come argomento. Così è possibile uscire da un blocco specifico. Normalmente non sarebbe possibile terminare un ciclo esterno da un ciclo interno, a meno di ricorrere a complicazioni del codice. Invece…

OUTER: for($i=0; $i<100; $i++) {

for($j=0; $j<100; $j++) {

if ($i * $j == 140) {

print “The product of $i and $j is 140\n”;

last OUTER; } } }

48 Bioinformatica

Uscire da PERL Quando PERL incontra un’istruzione exit,

l’esecuzione del programma viene interrotta e PERL restituisce lo stato di uscita al sistema operativo. Uno stato di uscita 0 significa che tutto è andato bene:

if ($user_response eq ‘quit’) {

print “Good bye\n”;

exit 0;

}

49 Bioinformatica

Liste Quando si desidera fare riferimento a molti oggetti

in PERL, vengono usati gli elenchi. Esistono tre modi per rappresentare gli elenchi: usando liste, array e hash;

Le liste rappresentano la forma più semplice di elenchi; una lista non è altro che un insieme di scalari;

Ogni scalare nella lista prende il nome di elemento della lista;

Le liste di PERL possono contenere qualsiasi numero di elementi scalari;

50 Bioinformatica

Liste di letterali E’ facile inserire elementi in una lista di letterali:

Questo esempio crea una lista di 4 elementi di diverso tipo.

Se la lista contiene solo stringhe semplici e racchiudere ogni stringa tra apici singoli diventa troppo complesso, PERL offre una via più semplice, l’operatore qw:

(5, ‘apple’, $x, 3.14159)

qw( apples oranges 45.6 $x ); # elementi separati da spazi

51 Bioinformatica

Liste di letterali (2) L’operatore qw non esegue l’interpolazione delle

variabili su elementi che hanno l’aspetto di variabili; sono infatti gestiti in modo letterale;

Quindi ‘$x’ non è convertito al valore della variabile scalare $x; viene considerato come stringa contenente un simbolo del dollaro e la lettera x;

52 Bioinformatica

Operatore di intervallo

L’operatore di intervallo prende l’operando sinistro (1) e l’operando destro (10) e crea un elenco costituito da tutti i numeri tra 1 e 10, compresi. Una lista può contenere anche diversi intervalli:

Assegnando all’operatore di intervallo un operando destro inferiore a quello sinistro, ad es. (10..1) viene creata una lista vuota.

L’intervallo (a..z) genera una lista di 26 lettere minuscole, l’intervallo (aa..zz) genera un elenco di 676 coppie di lettere: aa, ab, ac, ad, …, zx, zy, zz.

(1..10)

(1..10, 20..30)

53 Bioinformatica

Array Le liste di letterali sono usate generalmente per

inizializzare altre strutture: un array o un hash. Per creare un array in PERL è sufficiente inserirvi degli

elementi:

Le assegnazioni di array implicano anche altri array o persino elenchi vuoti:

Tutti gli elementi di @original sono copiati in un nuovo array di nome @copy. Se @copy conteneva altri elementi, questi saranno eliminati. Assegnare un elenco vuoto invece rimuove tutti gli elementi dell’array.

@boys=qw( Greg Peter Bobby );

@copy=@original;

@clean=();

54 Bioinformatica

Array (2) Se una lista di letterali contiene altre liste, array o

hash, questi elenchi saranno tutti compressi in una singola lista più grande:

Questo array equivale a:

@boys=qw( Greg Peter Bobby );

@girls=qw( Marcia Jan Cindy );

@kids=(@girls, @boys);

@family=(@kids, ( ‘Mike’, ‘Carol’ ), ‘Alice’);

@family=qw( Marcia Jan Cindy Greg Peter Bobby Mike Carol Alice);

55 Bioinformatica

Array (3) Il lato sinistro di un’assegnazione di array può essere una lista se

contiene solo nomi di variabili. L’assegnazione di array inizializza le variabili nella lista:

Se la lista a sinistra contiene un array, l’array riceve tutti i valori rimanenti dal lato destro, qualunque sia la sua posizione nella lista:

In questo caso $a è impostato a ‘peaches’. I frutti rimanenti nell’elenco a destra sono assegnati a @fruit a sinistra. $c è impostato a undef. Allo stesso modo se il lato sinistro contiene più variabili di quanti siano gli elementi a destra, le variabili rimanenti ricevono il valore undef. Se la lista a destra ha più elementi di quante siano le variabili a sinistra, i rimanenti vengono ignorati.

($a, $b, $c)=qw(apples oranges bananas);

($a, @fruit, $c)=qw(peaches mangoes grapes cherries);

56 Bioinformatica

Array (4) Come per $_ , @_ e @ARGV sono array di default:

Le Subroutines usano @_ come default;

Fuori dalle subroutine, @ARGV è l’array di default, ed è usato per i parametri di input dalla linea di comando;

57 Bioinformatica

Estrarre elementi da un array In questo modo è possibile ottenere i contenuti degli

array:

L’array viene interpolato e i suoi elementi vengono restituiti separati da spazi.

Per accedere ai singoli elementi di un array si usa un indice numerico, che inizia col numero 0:

print “@array”;

@trees=qw(oak cedar maple apple);

print $trees[0]; # stampa “oak”

print $trees[3]; # stampa “apple”

$trees[4]=‘pine’;

58 Bioinformatica

Porzioni Si può fare riferimento a un sottogruppo nell’array,

di nome porzione:

@trees=qw(oak cedar maple apple cherry pine peach fir);

@fruit=@trees[3,4,6]; # Solo gli alberi da frutto

@conifers=@trees[5,7]; # Solo le conifere

59 Bioinformatica

Trovare la fine di un array

In questo modo viene visualizzato l’indice dell’ultimo elemento, quindi 7;

Modificando il valore di $#trees cambia anche la lunghezza dell’array: riducendolo si tronca, ingrandendolo vengono assegnati nuovi elementi di valore undef;

Un altro metodo per trovare la dimensione dell’array:

@trees=qw(oak cedar maple apple cherry pine peach fir);

print $#trees;

$size=@array

60 Bioinformatica

Array e indici negativi E’ possibile specificare anche indici negativi per gli

array. La numerazione degli indici negativi inizia dalla fine dell’array e procede a ritroso. Per es. $array[-1] è l’ultimo elemento di @array, $array[-2] è il penultimo elemento e così via.

61 Bioinformatica

Informazioni sul contesto Il contesto indica gli elementi che circondano un

oggetto di interesse per definirne meglio il significato. Ad es. la parola “livello” può avere diversi significati in base al contesto: L’automobile era ferma al passaggio a livello; Il programma si basa su un linguaggio di basso livello; L’acqua nella piscina arriva a livello della vita.

E’ la stessa parola ripetuta più volte ma il significato è cambiato;

Anche PERL è sensibile al contesto: le funzioni e gli operatori in PERL possono comportarsi in modo diverso in base al contesto in cui sono usati.

62 Bioinformatica

Contesto (2) I due tipi più importanti di contesto in PERL sono il

contesto elenco e il contesto scalare. Riferendoci all’operatore di assegnazione “=“, il tipo di espressione (elenco o scalare) sul lato sinistro dell’operatore determina il contesto in cui sono valutati gli elementi sul lato destro:

$a=$b; # Scalare a sinistra: il contesto è scalare

@foo=@bar; # Array a sinistra: il contesto è elenco

($a)=@foo; # Lista a sinistra: il contesto è elenco (viene assegnato il primo valore dell’array)

$b=@bar; # Scalare a sinistra: il contesto è scalare (size dell’array)

63 Bioinformatica

Ancora su dimensione e fine di un array Osserviamo $a e $b nelle righe di codice seguenti:

Alla fine del codice $a contiene il numero 4 e $b contiene il numero 3. Questo perché $a è valutato in un contesto scalare e contiene il numero di elementi. $b invece è impostato all’indice dell’ultimo elemento.

@foo=qw( water cola juice lemonade );

$a=@foo;

$b=$#foo;

print “$a\n”;

print “$b\n”;

64 Bioinformatica

L’array è vuoto A questo punto provare se un array contiene

elementi diventa semplice:

In realtà @mydata è usato in un contesto scalare speciale di nome contesto booleano, ma si comporta allo stesso modo.

@mydata=qw( oats peas beans barley );

if(@mydata) {

print “The array has elements!\n”;

}

65 Bioinformatica

Contesto con operatori e funzioni A volte gli operatori si comportano in modo diverso,

in base al contesto specifico;

La funzione print prevede un elenco come argomento. Non è, tuttavia, importante il contesto specifico in cui è valutato l’elenco; quindi stampare un array con print fa sì che l’array sia valutato in un contesto elenco, visualizzandone gli elementi;

Si può usare una pseudo-funzione speciale di nome scalar per forzare qualcosa a un contesto scalare:

print scalar(@foo); # Stampa il numero di elementi di foo

66 Bioinformatica

Ancora sul contesto La funzione chomp prende come argomento un

array o uno scalare. Se chomp è usata con uno scalare, rimuove il separatore di record dalla fine dello scalare. Se è usata con un array, rimuove il separatore di record dalla fine di ogni scalare nell’array;

L’operatore <STDIN> in un contesto scalare legge una riga di input dal terminale. In un contesto elenco legge tutto l’input dal terminale e inserisce i dati nella lista:

$a=<STDIN>; # legge una riga in $a

@whole=<STDIN>; # legge tutto l’input nell’array @whole

($a)=<STDIN>; # legge tutto l’input nella lista assegnabile

67 Bioinformatica

Contesto e operatore x L’operatore di ripetizione x ha un comportamento

speciale nel contesto elenco. Se l’operando sinistro è racchiuso in parentesi e l’operatore stesso è usato in un contesto elenco, restituisce una lista dell’operatore sinistro ripetuto:

@stars= (“*”) x 100; # array di 100 asterischi

68 Bioinformatica

Contesto e operatore “virgola” Finora le virgole sono state usate per separare gli

elementi di liste di letterali:

In un contesto scalare la virgola è un operatore che valuta ogni elemento da sinistra a destra e restituisce il valore dell’elemento più a destra:

Il lato destro dell’espressione è valutato in un contesto scalare a causa dello scalare $last_pet a sinistra. Il risultato è che $last_pet è impostato uguale a ‘iguana’.

@pets=(‘cat’, ‘dog’, ‘fish’, ‘canary’, ‘iguana’);

$last_pet=(‘cat’, ‘dog’, ‘fish’, ‘canary’, ‘iguana’);

69 Bioinformatica

Contesto e funzione localtime In un contesto scalare la funzione localtime

restituisce una stringa ben formattata con l’ora corrente:

In un contesto elenco, localtime restituisce una lista di elementi che descrivono l’ora corrente:

print scalar(localtime); # stampa ad es. Thu Nov 03 23:00:06 2005

($sec, $min, $hour, $mday, $mon, $year_off, $wday, $yday, $isdst)=localtime;

70 Bioinformatica

Localtime

Campo Valore

$sec Secondi, 0-59

$min Minuti, 0-59

$hour Ora, 0-23

$mday Giorno del mese, 1-28,29,30 o 31

$mon Mese dell’anno, 0-11

$year_off Numero degli anni dal 1900 (Per l’anno corretto a quattro cifre aggiungere 1900 a questo numero)

$wday Giorno della settimana, 0-6

$yday Giorno dell’anno, 0-364 o 365

$isdst Vero se è in vigore l’ora legale

71 Bioinformatica

Esaminare un array Iterazione dell’array:

PERL offre una maniera più semplice per fare la stessa cosa:

@flavors=qw( chocolate vanilla strawberry mint sherbet );

For($index=0; $index<@flavors; $index++) {

print “My favorite flavor is $flavors[$index] and…”

}

print “many others.\n”;

foreach $cone (@flavors) {

print “I’d like a cone of $cone\n”;

}

72 Bioinformatica

Ancora foreach L’iteratore non è solo una variabile a cui è

assegnato il valore di ogni elemento nella lista; in realtà si riferisce proprio all’elemento della lista. Modificando l’iteratore, l’elemento corrispondente nella lista rimane modificato dopo l’esecuzione del ciclo:

foreach $flavor (@flavors) {

print “I’d like a bowl of $flavor ice cream, please.\n”;

$flavor = “$flavor (I’ve had some)”;

}

print “The available flavors are\n”;

foreach $flavor (@flavors) {

print “$flavor\n”;

}73 Bioinformatica

Conversione fra array e scalari Un metodo per convertire uno scalare in un array è la

funzione split, che prende un pattern e uno scalare, usa il pattern per dividere lo scalare e restituisce una lista dei pezzi:

Il pattern è stato racchiuso tra slash / /. Si ottengono le parole che compongono la frase, senza spazi.

Se non si specifica un secondo argomento, la variabile $_ viene divisa. Se non si specifica un pattern o una stringa, si usa uno spazio bianco per dividere la variabile $_.

Il pattern nullo //, divide lo scalare in singoli caratteri:

@words=split(/ /, “The quick brown fox”);

while(<STDIN>) {

($firstchar)=split(//,$_);

print “The first character was $firstchar\n”;

}74 Bioinformatica

Ancora split Quando si divide uno scalare in cui ogni sezione è

un elemento distinto è più semplice distinguere le diverse sezioni quando si assegna un nome ad ogni sezione:

@Music=(‘White Album, Beatles’, ‘Graceland, Paul Simon’,

‘A boy named Sue, Goo Goo Dolls’);

foreach $record (@Music) {

($record_name, $artist)=split(‘,’, $record);

}

75 Bioinformatica

Creare scalari da array (Join) join prende una stringa e una lista, unisce gli elementi della

lista usando la stringa come separatore e restituisce la stringa risultante:

Questo esempio assegna la stringa “1,2,3,4,5,6,7,8,9,10” a $numbers;

E’ possibile usare split e join per dividere una stringa e ricomporla simultaneamente:

Qui $message è diviso in una lista con split. La lista è usata dalla funzione join e ricomposta con trattini;

$numbers=join(‘,’, (1..10));

$message=“Elvis was here”;

print “The string \”$message\” consists of:”,

join(‘-’, split(//, $message));

76 Bioinformatica

Riordinare l’array PERL offre la funzione sort, che prende come

argomento la lista e la ordina in ordine alfabetico. L’array originale non viene toccato:

L’ordine predefinito è quello ASCII per cui tutte le parole che iniziano con caratteri maiuscoli sono ordinate prima delle parole che iniziano con lettera minuscola. Output: Bush Carter Clinton Ford Nixon Regan Clinton Bush Reagan Carter Ford Nixon

@Chiefs=qw(Clinton Bush Reagan Carter Ford Nixon);

print join(‘ ‘, sort @Chiefs), “\n”;

print join(‘ ‘, @Chiefs), “\n”;

77 Bioinformatica

Ancora sort La funzione sort consente di scegliere l’ordinamento

desiderato usando un blocco di codice (o un nome di subroutine) come secondo argomento;

Nel blocco, due variabili, $a e $b, sono impostate a due elementi dell’elenco. Il compito del blocco è restituire -1, 0 o 1 in base a se $a è inferiore a $b, uguale a $b o maggiore di $b:

@sorted=sort {return(1) if ($a>$b);

return(0) if ($a==$b);

return(-1) if ($a<$b); } @numbers;

78 Bioinformatica

L’operatore astronave Un modo più semplice per ottenere lo stesso

risultato si ha usando l’operatore astronave <=>: restituisce -1 se l’operando sinistro è inferiore a quello destro, 0 se i due operandi sono uguali, 1 se l’operando sinistro è maggiore di quello destro:

Per confrontare stringhe alfabetiche si utilizza l’operatore cmp, che funziona allo stesso modo.

@numeri_decrescenti = sort { $b <=> $a } 1 .. 9;

@numeri_crescenti = sort { $a <=> $b } 1 .. 9;

79 Bioinformatica

La funzione reverse La funzione reverse, quando prende un valore

scalare in un contesto scalare, inverte i caratteri della stringa e restituisce la stringa invertita:

Quando prende una lista in un contesto elenco, reverse restituisce gli elementi della lista in ordine inverso:

E in questo caso?

print reverse(“Perl”); # visualizza “lreP”

@lines=qw(I do not like green eggs and ham);

print join(‘ ‘, reverse @lines);

print join(‘ ‘, reverse sort @lines);

80 Bioinformatica

I file Per leggere o scrivere un file in PERL è necessario aprire un

filehandle;

I filehandle in PERL rappresentano un altro tipo di variabile: agiscono come riferimento fra il programma e il SO e contengono informazioni su come è stato aperto il file e fino a che punto si è arrivati con la lettura (o scrittura), oltre che agli attributi relativi a lettura e scrittura del file definiti dall’utente;

Il filehandle <STDIN> viene fornito automaticamente da PERL all’avvio del programma e, in genere, è collegato alla tastiera;

Il formato dei nomi dei filehandle è lo stesso di quello dei nomi delle variabili, tranne che per l’assenza di simboli $ o @. Per questo motivo si consiglia di scrivere i nomi dei filehandle in maiuscolo, per evitare conflitti con parole chiave di PERL.

81 Bioinformatica

Aprire un file

Se la funzione fallisce restituirà il valore undef:

open(filehandle, nomepercorso);

If (open(MYFILE, “mydatafile”)) {

# etc etc

}

else

print “Cannot open mydatafile!\n”;

exit 1;

}

82 Bioinformatica

La funzione die In molti programmi la sintassi “Apertura o

fallimento” di un file viene scritta usando la funzione die:

Se l’apertura del file non riesce viene interrotta l’esecuzione e l’interprete restituisce un messaggio di errore;

Per chiudere un file:

open (MYTEXT, “novel.txt”) || die;

close(MYTEXT);

83 Bioinformatica

Nomi di percorso Quando si cerca di aprire un file senza specificare la

directory, PERL suppone che il file si trovi nella directory corrente;

Per aprire un file che si trova in un’altra directory è necessario usare un nome di percorso. In UNIX:

In Windows i nomi di percorso contengono backslash come separatori, e usando questi simboli in una stringa tra doppi apici in PERL la sequenza di caratteri viene tradotta in un carattere speciale:

open(MYFILE, “/usr/pierce/novel”) || die;

open(MYFILE, “\Windows\users\pierce\novel.txt”) || die;

84 Bioinformatica

Nomi di percorso (2) Un metodo corretto per aprire il file è sottoporre

ogni backslash a escape con un altro backslash:

Questo è corretto ma confuso. Potremmo eliminare i doppi backslash usando la funzione qq;

In PERL è possibile però usare lo slash / per separare gli elementi del percorso:

open(MYFILE, “C:\\Windows\\users\\pierce\\novel.txt”) || die;

open(MYFILE, “C:/Windows/users/pierce/novel.txt”) || die;

85 Bioinformatica

Ancora sulla funzione die La funzione die può prendere anche un elenco di

argomenti e stamparli al posto del messaggio predefinito. Se il messaggio non è seguito da un carattere di nuova riga, viene aggiunto at nomescript line xxx alla fine:

die “Cannot open”; # stampa “Cannot open at nomescript line xxx”

die “Cannot open!\n”; # stampa “Cannot open!”

86 Bioinformatica

La variabile $! La variabile $! è sempre impostata al messaggio di errore

dell’ultima operazione richiesta del sistema. Usata in un contesto numerico $! restituisce un numero di errore;

In un contesto stringa $! restituisce un messaggio di errore appropriato dal SO:

Se il codice fallisce il messaggio stampa qualcosa di simile a “Cannot open myfile: a file or directory in the path does not exist”;

Se si vuole solo un messaggio di avviso, anziché bloccare il programma:

open(MYFILE, “myfile”) || die “Cannot open myfile: $!\n”;

If (! Open(MYFILE, “myfile”)) {

warn “cannot read myfile: $!”;}

87 Bioinformatica

Leggere dal file

In un contesto scalare, l’operatore angolare legge una riga di input dal file e, una volta finito il file, restituisce il valore undef;

Per leggere e stampare il file:

Se gli operatori angolari sono gli unici elementi all’interno dell’espressione condizionale di un ciclo while, PERL assegna automaticamente la riga di input alla variabile speciale $_:

open (MYFILE, “myfile”) || die “Can’t open my file: $!”;

$line=<MYFILE>;

while (defined($a=<MYFILE>)) {

print $a; }

while (<MYFILE>) {

print $_; }

88 Bioinformatica

Leggere dal file (2) Ogni riga di dati letta dal file comprende anche il

carattere di end-of-line. Se si vuole solo il testo, usare la funzione chomp;

In un contesto elenco, gli operatori angolari leggono l’intero file e lo assegnano alla lista:

In questo caso i dati del filehandle MYFILE sono letti e assegnati a @contents. $contents[0] conterrà la prima riga del file, $contents[1] la seconda etc.

open(MYFILE, “novel.txt”) || die “$!”;

@contents=<MYFILE>;

close(MYFILE);

89 Bioinformatica

Scrivere sul file

Nel primo caso, il simbolo > indica a PERL che il file specificato deve essere sovrascritto coi nuovi dati e che filehandle è aperto per la scrittura;

Nel secondo caso, il simbolo >> indica a PERL di aprire il file per la scrittura, ma se il file esiste già i contenuti non devono essere cancellati; i nuovi dati saranno accodati alla fine del file;

Per scrivere sul file:

dove LIST è una lista di cose che si desidera scrivere.

open(filehandle, “>nomepercorso”);

open(filehandle, “>>nomepercorso”);

print filehandle LIST

90 Bioinformatica

Scrivere sul file (2) E’ possibile aprire più filehandle per la lettura e la

scrittura allo stesso tempo:

Ma la stessa cosa si ottiene così:

open(SOURCE, “sourcefile”) || die “$!”;

open(DEST, “>destination”) || die “$!”;

@contents=<SOURCE>;

print DEST @contents;

close(DEST);

close(SOURCE);

print DEST <SOURCE>;

91 Bioinformatica

Filehandle liberi All’avvio di ogni programma PERL vengono aperti tre

filehandle liberi, STDIN, STDOUT e STDERR;

STDIN è di base associato alla tastiera;

STDOUT e STDERR sono di base associati allo schermo;

92 Bioinformatica

File binari Quando si scrivono dati binari – file GIF, file EXE,

documenti WORD, etc. – è necessario usare la funzione binmode per contrassegnare il filehandle come binario:

open(FH, “>camel.gif”) || die “$!”;

binmode(FH);

print FH “GIF87a\056\001\045\015\000”;

close(FH);

93 Bioinformatica

Operatori di test di file

X è il test particolare che si intende eseguire, mentre filehandle è il filehandle da verificare;

La stessa cosa si può ottenere con un nomepercorso senza aver un filehandle aperto;

-X filehandle

-X nomepercorso

94 Bioinformatica

if(-e "myfile.txt") {

open (MYFILE, "myfile.txt") || die "Can’t open my file: $!";

while (defined($a=<MYFILE>)) {

print $a;

}

}

else {

print "il file non esiste";

}

Operatori di test di file (2)Operatore Esempio Risultato

-r -r ‘file’ Vero se ‘file’ è leggibile

-w -w $a Vero se il nome del file contenuto in $a è scrivibile

-e -e ‘myfile’ Vero se ‘myfile’ esiste

-z -z ‘data’ Vero se ‘data’ esiste ma è vuoto

-s -s ‘data’ Dimensione di ‘data’ in byte, se esiste

-f -f ‘novel.txt’ Vero se ‘novel.txt’ è un file regolare invece che una directory

-d -d ‘/tmp’ Vero se ‘/tmp’ è una directory

-T -T ‘unknown’ Vero se ‘unknown’ è un file di testo

-B -B ‘unknown’ Vero se ‘unknown’ è un file binario

-M -M ‘foo’ Numero di giorni da quando il file ‘foo’ è stato modificato dopo l’avvio del programma

95 Bioinformatica

Esercizi Proposti Realizzare gli script per risolvere i seguenti

problemi: Calcolare i primi n numeri primi;

Contare le righe di un file di testo;

Contare il numero di occorrenze di una certa parola p in un file di testo;

Dato un file di testo con n righe generare una pagina html che contenga una tabella centrata con 2 colonne ed n righe in modo che: Nella colonna 1 di ogni riga compaia il numero di riga

(progressivo); Nella colonna 2 compaiano le righe del file di testo; Il testo sia in LOWERCASE e UPPERCASE a righe alterne;

96 Bioinformatica