Perl Practical extraction Report Language

Slides:



Advertisements
Presentazioni simili
Linguaggio MATLAB: costrutti tipici (IF,WHILE…)
Advertisements

1 Corso di IMPIANTI DI ELABORAZIONE Seminario: Una panoramica sul PERL Docente: Ing. Vito AstaTutor: Ing. Paolo Molinari.
Perl Practical extraction Report Language Variabili e strutture dati Corso Perl per Biotecnologie (2015) Pathologically eclectic rubbish lister :-)
Script bash I file di comandi in Linux. BASH  Bourne Again Shell  Modalità interattiva o batch (file di comandi)  Ambiente di programmazione “completo”
7. Strutture di controllo Ing. Simona Colucci Informatica - CDL in Ingegneria Industriale- A.A
Programmazione: Iterazione Esistono tre tipi di iterazione fondamentali e vedremo la corrispondenza dei relativi diagrammi a blocchi e la loro traduzione.
1 Elementi DI INFORMATICA Università degli Studi di Cagliari Corso di Laurea in Ingegneria Elettronica Linguaggio C A.A. 2011/2012
Parte 2 Programmare in Matlab – I Sommario: Introduzione: m-file Strutture condizionali e cicli –Istruzione “if” + Operatori logici in MatlabIstruzione.
1 ELEMENTI DI INFORMATICA Università degli Studi di Cagliari Corso di Laurea in Ingegneria Elettronica Linguaggio C A.A. 2011/2012
INTRODUZIONE A MATLAB/OCTAVE MANOLO VENTURIN UNIVERSITÀ DEGLI STUDI DI PADOVA DIP. DI MATEMATICA PURA ED APPLICATA A. A. 2007/2008.
1 Come cercare le fonti di informazione scientifica Operatori e wildcards a cura della Biblioteca di Agraria.
Un semplice programma C /* Programma che stampa un saluto */ #include main() { printf(“Hello World!\n”); }
1 Simulazione Numerica dei Fenomeni di Trasporto Necessità di introduzione dei tensori  11  12  13  23  21  22 Vogliamo descrivere in un modo che.
Amministrazione di reti di calcolatori - Massimo Bertozzi Shell e scripting.
.  I tipi di dati non primitivi sono gli array, le struct e le union.  Gli array sono degli aggregati di variabili dello stesso tipo.  La dichiarazione.
Ereditarietà Uno dei principi della programmazione orientata agli oggetti (OOP) è il riuso Le classi dovrebbero essere progettate come componenti riutilizzabili.
Ambienti di Programmazione per il Software di Base
© 2007 SEI-Società Editrice Internazionale, Apogeo
11. Lettura e Scrittura di file in Matlab
La rappresentazione delle informazioni
Introduzione al linguaggio C
Terza Lezione → Navigare nel file System → parte 2
7. Strutture di controllo Ing. Simona Colucci
Script Marco D. Santambrogio –
IL CONCETTO DI ALGORITMO
Commenti Ogni riga che comincia con il simbolo # non viene letta dall’interprete per cui rappresenta un modo per commentare il listato # Questo è un esempio.
Equazioni e disequazioni
TIPI PRIMITIVI TIPI STRUTTURATI
Programmazione strutturata
Tipo di dato: array Un array è un tipo di dato usato per memorizzare una collezione di variabili dello stesso tipo. Per memorizzare una collezione di 7.
PROGRAMMAZIONE BASH – ISTRUZIONE IF
CICLO DO – WHILE LINGUAGGIO C.
Tipi di Shell sh – Bourne shell csh – C shell ksh – Korn shell
Corso di IMPIANTI DI ELABORAZIONE
Lezione 9 – A.A. 2016/2017 Prof. Giovanni Acampora
realizzato dal prof.Conti Riccardo
Informatica per Scienze Geologiche LT a.a
Java World Cicli e Array.
Corso Java Cicli e Array.
© 2007 SEI-Società Editrice Internazionale, Apogeo
Strutture di Controllo
Secondo Programma in C.
I numeri relativi DEFINIZIONE. Si dicono numeri relativi tutti i numeri interi, razionali e irrazionali dotati di segno (positivo o negativo). ESEMPI Numeri.
Vari e semplici programmi.
SQL per la modifica di basi di dati
A = InputBox("Immetti un numero")
© 2007 SEI-Società Editrice Internazionale, Apogeo
Codici rilevatori di errori
I fogli elettronici Microsoft Excel.
Corso di Laurea Ingegneria Informatica Fondamenti di Informatica
APPUNTI SUL LINGUAGGIO C Implementazioni di Liste Concatenate
La struttura dei primi programma in C
APPUNTI SUL LINGUAGGIO C Esercizi su File e Alberi Binari
Le stringhe in C++ Laboratorio 26 Aprile Dott. Serena Villata
Processi decisionali e funzioni di controllo
Corso di Algoritmi e Strutture Dati APPUNTI SUL LINGUAGGIO C
APPUNTI SUL LINGUAGGIO C
Unità 1 Programmi base.
Selezione e Proiezione
Array Un array è un contenitore “contiene” al massimo un numero predefinito di oggetti dello stesso tipo. Ogni oggetto dell'array è detto “elemento” Ad.
Lezione Terza Primi passi di programmazione
Array e Stringhe Linguaggio C.
PowerShell di Windows PowerShell è un shell che mette a disposizione un prompt interattivo e un interprete a riga di comando , per le sue caratteristiche.
Ricerca 01/08/2019 package.
La programmazione strutturata
Introduzione a Python Prima Lezione.
Docente: Sabato Bufano
Corso di Fondamenti di Informatica
Script su vettori Realizza uno script che chiede in input una dimensione d e crea un vettore di d numeri interi casuali. Poi calcola la somma dei due numeri.
Corso di Fondamenti di Informatica
Transcript della presentazione:

Perl Practical extraction Report Language Pathologically eclectic rubbish lister :-) Variabili e strutture dati Corso Perl per Biotecnologie (2016)

Il manualetto di riferimento in Italiano: Stefano Rodigliero Pocket Perl Ed:APOGEO

The "Hello World" program Consideriamo il seguente programmino: #!\usr\bin\perl # Hello World use strict; # variabili lessicali(usare my) use warnings; # evidenzia anche gli errori non critici my $message="Ciao, Mondo"; print "$message \n"; print " End of program $0 \n"; __END__

Perl Variables #!\usr\bin\perl è chiamata 'shebang-line' Windows la considererà un commento use strict; # variabili (usare my, our,state,local) Con questa direttiva, siamo obbligati a dichiarare le variabili con I prefissi: my my $v, my @W, my %HV' ; quello più usato state state $k=0; our our $name; crea un alias in un package local usato in un blocco {… } per modifiche locali

Perl Variables my $message:dichiariamo una variable lessicale. Usando 'my' Perl ci avvisa nel caso di errori di digitazione della variabile; es: my $numer=2; my $v = $Numer +1; # $numer NON è $Numer !!!!! A volte con lo stesso nome di variabile conserviamo piu' di una informazione ( $V e @V e %V sono diversi !! ). Tutti i linguaggi (dei computer) hanno la capacità di creare variabili per poter memorizzare e modificare dati. Perl è diverso da tanti altri linguaggi perché non specifica il "tipo" (i.e. integer, real, character, etc.) ma solo la "complessità" dei dati.

Perl Variabili Perl ha 3 maniere per memorizzare I dati: Scalari (scalars) Per dati singoli, come numberi o stringhe. Vettori (arrays) Intesi come liste di scalari. Scalari indicizzati da numeri. Vettori Associativi detti "hashes" simili ai vettori, ma usano delle chiavi ("keys") per identificare gli scalari. I simboli “$” , “@” e “%” anteposti ai nomi delle variabili si chiamano “sigilli”. In realtà gli hashes possono essere ricondotti agli arrays

Perl Variabili I simboli “$” , “@” e “%” anteposti ai nomi delle variabili si chiamano “sigilli”. I nomi di variabile iniziano sempre con un sigillo  (o simbolo) che indica il tipo del valore della variabile. Le variabili scalari (Scalari) usano il simbolo del dollaro ($). Le variabili array (Array) usano il simbolo chiocciola (@). Le variabili hash (Hash) usano il simbolo della percentuale (%): In realtà gli hashes possono essere ricondotti agli arrays

Variabili Scalari (sigillo “$”) Esempi # my $no_of_chrs=24; # intero my $per_cent_identity=0; # intero my $per_cent_identity=99.50; # ridefinito come reale my $pi = 3.1415926535; # floating point (reale) my $e_value=1e-40; # notazione scientifica my $dna="GCCTACCGTTCCACCAAAAAAAA"; # string -double quotes my $dna='GCCTACCGTTCCACCAAAAAAAA'; #string -single quotes my $n = 0b1110011; # intero binario my $var = 01234; # intero ottale my $n = 0x5FA8; # intero esadecimale How do you say floating point, real numbers in italian?

Variabili Scalari MAIUSCOLO e minuscolo $DNA ≠ $dna; (sono due variabili differenti) Le variabili scalari devono avere un prefisso, il simbolo $ (se c'è il $ → è uno scalare). Il carattere successivo deve essere una lettera e non un numero (valido per tutte le variabili create dall'utente ). Gli scalari possono essere facilmente ridefiniti (ex: integer → real → string): # esempio my $dna = 0; # integer $dna = "GGCCTCGAACGTCCAGAAA"; # ora è una stringa

Usiamo gli scalari.. my $a =1.5; my $b =2.0; $c=3; my $sum = $a+$b*$c; # moltiplica $b per $c, poi somma $a # my $j = 1; while ($j<100) { $j++; # significa $j=$j+1, i.e. add 1 to j print "$j\n"; } my $dna1="GCCTAAACGTC"; my $polyA="AAAAAAAAAAAAAAAA"; $dna1 .= $polyA; # aggiunge una stringa ad un'altra # (equiv. $dna1 = $dna1.$polyA) my $no_of_bases = length($dna1); # lunghezza dello scalare italian for shorthand = notazione abbreviata

Stringhe.. Esiste una notevole differenza tra stringhe con il singolo apice ' e stringhe con I doppi apici " double quotes # $nchr = 23; $message="pairs of chromosones in human cell =$nchr"; print $message; $message = 'pairs of chromosones in human cell =$nchr'; exit; OUTPUT pairs of chromosones in human cell =23 pairs of chromosones in human cell =$nchr single quotes

Strings ….(interpolazione) I doppi apici " interpretano le variabili, gli apici singoli ' non lo fanno: $dna='GTTTCGGA'; print "sequence=$dna"; print 'sequence=$dna'; OUTPUT sequence=GTTTCGGA sequence=$dna Si usano piu' spesso I doppi apici (") quando usiamo l'istruzione print. ' single quote " double quotes

Variabili in Perl Perl è case sensitive ($a è diverso da $A) Variabili scalari: contengono sia stringhe che numeri $nome = 'Marco'; $n=3; $pigreco=3.14; Variabili array @nomi=('Marco','Michele','Paolo'); @nomi=(Marco,Michele,13); Il primo elemento di un array ha indice 0 Per accedere agli elementi dell'array si usano le variabili scalari: $nomi[1] prende il valore Michele

Operazioni e assegnamento $a=1+2; #addizione $a=3-4; #sottrazione $a=3*4; #moltiplicazione $a=8/2; #divisione $a= 2**4; #elevamento a potenza $a=5%2; #modulo $a++;++$a; #post e pre_incremento $a+=$b; $a-= $b; $a.=$b #assegnamento $a=$b.$c; #concatenazione di stringhe $a=$b x $c; #ripetizione di stringhe (non commutativa:"stringa " x "numero")

# Un po' di sintassi utili... my $milione = 1_000_000 ; my $esadecimale = 0xDEADBEEF; my $ottale = 0210; my $binario = 0b0101101; print "$esadecimale\n"; print "$ottale\n"; print "$binario\n"; ===== OUTPUT ========== 1000000 3735928559 136 45

# Ancora sintassi utili... $var1 = 1; $var2 = 2; $var3 = "pippo"; $var4 = "pluto"; print "var1=$var1 \t var2=$var2 \t var3=$var3 \t var4=$var4 \n"; $tot1=$var1+$var2; print "tot1=var1+var2 = $tot1 \n "; $tot2=$var1.$var2; print "tot2= var1.var2 = $tot2 \n "; print "var1+var2 = $tot1\n"; # var1+var2 = 3 print "var1\.var2 = $tot2\n"; # var1.var2 = 12 $tot1=$var3+$var4; # NUM + STRINGA! ? Perl ci prova comunque. $tot2=$var3.$var4; # concatenazione print "var3+var4 = $tot1\n"; # var3+var4 = 0 print "==== \$var3.\$var4 = $tot2\n"; # var3.var4 = pippopluto $tot1=$var3+1; print "var3+1 = $tot1\n"; # var3+1 = 1

Strutture di controllo Operatori di confronto Il Perl mette a disposizione 3 tipi di operatori di confronto, ognuno dei quali va applicato su un determinato tipo di dato: numeri, stringhe e file Il Perl effettua una conversione di tipo delle variabili prima di effettuare il confronto coerentemente col tipo dei dati conivolti

Operatori logici Gli operatori logici del Perl per le espressioni booleane sono && AND || OR ! NOT AND e OR hanno una precedenza bassa rispetto a && e || . OPERATORI BITWISE(tra bits) | (or), & (and) ^ (xor)

Operatori di confronto Tra numeri: $a==$b uguaglianza $a<$b minore (maggiore >) $a<=$b minore(maggiore >) o uguale $a!= $b diverso Tra stringhe il minore - maggiore segue l'ordine alfabetico $a eq $b uguaglianza $a lt $b minore (maggiore gt) $a le $b minore(maggiore ge) o uguale $a ne $b diverso

Operatori di confronto su file e directory Tra file $a = "myfile.txt" -r $a leggibile -w $a scrivibile -d $a è directory -f $a file regolare ( non device) -T $a file di testo -e $a esiste

Arrays (VETTORI) Un array è una struttura dati che permette di accedere ad un set di variabili scalari direttamente attraverso un indice numerico; potremmo dire, in altri termini, che si tratta di una variabile a più componenti. I nomi degli array in Perl sono preceduti dal simbolo "@" per distinguerli dalle variabili scalari. Le singole componenti del vettore (array) sono delle variabili scalari.

Arrays (VETTORI) #!/usr/local/bin/perl # script "frutta.pl" my @frutta = ('mele', 'pere', 'banane', 'uva'); definisce l'array @frutta come un vettore a quattro componenti; per accedere alla singola componente si deve usare un indice numerico, come nel seguente esempio: #!/usr/local/bin/perl # script "frutta.pl" print "un cesto pieno di $frutta[1].\n"; OUTPUT: un cesto pieno di pere.

Arrays (VETTORI) I Vettori possono memorizzare collezioni di numeri, stringhe e altro . In Perl I vettori sono spesso chiamati liste ordinate di scalari, @days_in_month=(31,28,31,30,31,30,31,31,30,31,30,31); @days_of_the_week=('mon', 'tue', 'wed' ,'thu','fri','sat','sun'); @bases = ('adenine', 'guanine', 'thymine', 'cytosine', 'uracil'); @GenBank_fields=( 'LOCUS', 'DEFINITION', 'ACCESSION', ... ); array inizializzato con una lista

Array - gli elementi Nota! indice del vettore Per accedere ai singoli elementi dell'array si usano le PARENTESI QUADRE [ ] Il primo elemento di un array di n elementi in Perl , ha indice 0. L'ultimo elemento ha indice n-1. @poly_peptide=('gly','ser','gly','pro','pro','lys','ser','phe'); # ora mutiamo il peptide $poly_peptide[0]='val'; # valina al posto # della glicina # stampiamo il vettore $i=0; while ($i<8) { print "$poly_peptide[$i] "; $i++; } Nota! indice del vettore italian for square brackets = parantesi quadri, graffe (curly), tonde (normal) I valori numerici usati per individuare gli elementi sono chiamati indici.

Arrays – gli elementi Quando si accede agli elementi del vettore si usa il simbolo $ ( perche' ?) -- Perche' gli elementi del vettore sono scalari e gli scalari devono avere il sigillo “$”; @poly_peptide=(…); # definisce un array $poly_peptide[0] = 'val'; #varia il 10 elemento Questo significa che potremmo avere una variabile separata con nome $poly_peptide poiche' $poly_peptide[0] fa parte di @poly_peptide, ma NON lo e' $poly_peptide.

Variabili Perl - uso del contesto my @names=(‘Marco’,’Paolo’,’Maria’ ); print @names; # MarcoPaoloMaria print "@names"; # Marco Paolo Maria print @names.""; # 3 (n. di elementi del vettore)

Indici di un Array Gli indici dei vettori partono da 0 e non da 1 ; $poly_peptide[0]='var'; $poly_peptide[1]='ser'; $poly_peptide[7]='phe'; L'ultimo indice di un array puo' essere trovato con $#nome_di_array, e.g. $#poly_peptide. Si possono usare anche indici negativi: questo significa che potete partire dalla fine del vettore. Therefore $poly_peptide[-1] vale 'phe' $poly_peptide[$#poly_peptide] = $poly_peptide[7]

Proprieta' dei Vettori Lunghezza di un vettore: $len = $#poly_peptide+1; # 7+1 Non e' necessario ( in Perl) definire inizialmente la dimensione del vettore – essa puo' crescere dinamicamente : # costruzione di un array #!/usr/bin/perl my $i=0; my @ARR=(); # array senza elementi while ($i<100) { $ARR[$i]= 2*$i; print "\n ARR[$i] = $ARR[$i] "; $i++; }

stampa di un array #!/usr/bin/perl my $cognome = 'Rossi'; my @nomi = ("Michele $cognome", 'Elena', 'Luca', 'Elisa'); print "\n =====================\n"; print "@nomi"; # Questo causerà la stampa dei vari elementi, # nell'ordine in cui erano stati inseriti, separati da uno spazio. # In questo caso l'output sarà: # Michele Rossi Elena Luca Elisa my $k=0 ; while ($k <= $#nomi) { print "\n k= [$k] "; print "\n $nomi[$k] "; $k++; } print "\n FINE DEL PROGRAMMA $0 \n";

Estrarre dati dagli arrays #!/usr/bin/perl use feature 'say'; # dice a perl che userà la funzione say. @ARRAI= qw(K L D U Y T R E W A); say "@ARRAI"; @arrai2 = @ARRAI[0..2]; # estrae i primi 3 elementi di @arrai say "@arrai2"; @arrai3 = @ARRAI[-2..3]; # say "@arrai3"; # estrae il 3^, 7^ e 8^ elemento da @ARRAI @arrai4 = @ARRAI[2,6,7]; say "@arrai4"; $dim = @ARRAI; # $dim contiene il numero di elementi di @ARRAI say " in \@ARRAI ci sono $dim elementi "; @unosolo = @ARRAI[8]; say "\@unosolo @unosolo array! "; # attenzione! @unosolo è un array con un solo elem e non uno scalare $unosolo = $ARRAI[8]; say "\$unosolo = $unosolo scalare! "; # attenzione! $unosolo è uno scalare print "\n FINE DEL PROGRAMMA $0 \n";

Da stringa ad array e viceversa (split-and-Join.pl) #!/usr/bin/perl use 5.010.1; print "\n da Stringa ad Array usando la funzione split() \n"; my @testo = split ( "" , "questo testo verrà diviso in caratteri" ); my $dim = @testo; print "\n dimensione di \@testo = $dim \n "; print "\n @testo \n" ; # riunisco gli elementi dell'array @ testo in una stringa print "\n da Array a Stringa usando la funzione join() \n"; my $stringa1 = join("_" , @testo)."\n"; # q_u_e_s_t_ ……… print "\n $stringa1 \n"; my $stringa2 = join("" , @testo)."\n"; # questo print "\n $stringa2 \n"; print "\n da Stringa ad Array usando la funzione split() \n"; @testo = split ( " " , "ogni parola di questa frase diventerà elemento di un array" ); $dim = @testo; print "\n dimensione di \@testo = $dim \n "; print "\n @testo \n" ; print "\n EOJ $0 \n "; __END__

Da stringa ad array e viceversa (split-and-Join.pl) da Stringa ad Array usando la funzione split() dimensione di @testo = 38 q u e s t o t e s t o v e r r à d i v i s o i n c a r a t t e r i da Array a Stringa usando la funzione join() q_u_e_s_t_o_ _t_e_s_t_o_ _v_e_r_r_à_ _d_i_v_i_s_o_ _i_n_ _c_a_r_a_t_t_e_r_i questo testo verrà diviso in caratteri da Stringa ad Array usando la funzione split() dimensione di @testo = 10 ogni parola di questa frase diventerà elemento di un array EOJ C:\Users\mq1\AppData\Local\Temp\dzprltmp.pl

Array (Funzioni utili) PUSH and POP Funzioni comunemente usate per gestire una Pila(stack): POP PUSH F.I.L.O = First In Last Out La prima inserita e' l'ultima ad essere estratta. push @array, "elem1"; pop @array;

Array (funzioni utili) SHIFT e UNSHIFT Funzioni comunemente usate per gestire una Coda : Shift estrae un elemento dalla testa F.I.F.O = First In First Out La prima inserita e' la prima ad essere estratta dalla testa SHIFT UNSHIFT inserisce un elemento in testa unshift @array, 4; shift @array;

Vettori - Funzioni usate – PUSH ,POP, SHIFT,UNSHIFT #!/usr/bin/perl # programma che riempie un array use strict; use warnings; my @array = (); # si parte da una lista vuota my $tmp; push @array, "elem1", "elem2", "elem3" , "sono il quarto"; print " \n @array \n"; print " \n estraggo un elemento dalla coda ( da destra) \n"; $tmp = pop @array; print " Ho estratto il valore ' $tmp ' \n"; print " \n estraggo gli elementi partendo da sinistra ovvero dalla testa \n"; while ( @array ) # strano questo while! { $tmp = shift @array; # estrae gli elementi dalla testa ( ovvero "elem1" poi "elem2" etc... print " \n estratto -> $tmp "; } print "\n EOJ $0 \n"; __END__

Vettori - Funzioni usate – PUSH ,POP, SHIFT,UNSHIFT elem1 elem2 elem3 sono il quarto estraggo un elemento dalla coda ( da destra) Ho estratto il valore ' sono il quarto ' estraggo gli elementi partendo da sinistra ovvero dalla testa estratto -> elem1 estratto -> elem2 estratto -> elem3 EOJ qpush2.pl

Contesto Scalare $length = @poly_peptide ; (1) La (1) è equivalente a Se in una espressione sono coinvolti vettori (@) e scalari($) -come nell' espressione (1) – Perl cerchera' di interpretare l'istruzione in un contesto scalare . In questo caso si assegnera' a $length la lunghezza del vettore @poly_peptide La (1) è equivalente a $length=$#poly_peptide+1; array in contesto scalare = lunghezza del vettore Quindi il ciclo : while (@vector) { ..

Vettori – Funzione splice A volte capita, pero', di voler inserire nuovi elementi in un punto arbitrario di un array. Perl risolve questa necessita' con la funzione splice() della quale esistono molte forme: 1) splice ARRAY, OFFSET 2) splice ARRAY, OFFSET, LENGTH 3) splice ARRAY, OFFSET, LENGTH, LIST

Vettori – Funzione splice Cominciamo dal caso piu' semplice. splice ARRAY, OFFSET Questo uso di splice ha l'effetto di eliminare dall'ARRAY tutti gli elementi a partire dall'indice indicato (OFFSET) ESEMPIO: my @appo=("Anna", "Roberto", "Franco", "Pino", "Fabrizio"); print "@appo\n"; my @resto = splice (@appo, 3); print "@appo\n"; print "@resto\n"; __END__ Anna Roberto Franco Pino Fabrizio Anna Roberto Franco Pino Fabrizio

Vettori – Funzione splice Vediamo ora il caso: splice ARRAY, OFFSET,LENGTH Questo uso di splice ha l'effetto di eliminare dall'ARRAY un numero LENGTH di elementi a partire dall'indice indicato (OFFSET) ESEMPIO: my @appo=("Anna", "Roberto", "Franco", "Pino", "Fabrizio", "Tony"); print "@appo\n"; my @resto = splice (@appo, 1,2); print "@appo\n"; print "@resto\n"; __END__ Anna Roberto Franco Pino Fabrizio Tony Anna Pino Fabrizio Tony Roberto Franco

Vettori – Funzione splice Vediamo ora il terzo caso: splice ARRAY, OFFSET,LENGTH ,LIST Questo uso di splice ha l'effetto di eliminare dall'ARRAY un numero LENGTH di elementi a partire dall'indice indicato (OFFSET) e, al posto di quelli eliminati, saranno inseriti quelli specificati da LIST #!/usr/bin/perl my @appo=("Anna","Roberto","Franco","Pino","Fabrizio","Tony"); print "@appo\n"; my @lista= ('Ugo','Mauro'); my @resto = splice (@appo, 2,3,@lista); print "@appo\n"; print "resto --> @resto\n"; __END__ Anna Roberto Franco Pino Fabrizio Tony Anna Roberto Ugo Mauro Tony resto --> Franco Pino Fabrizio

ARRAY e PEZZI DI ARRAY splice Splice(ARRAY;start; length;list)

Variabili speciali Perl usa molte variabili speciali. eccone alcune $_ Presente in molte situazioni dove non è espicitamente citata la variabile coinvolta ( per esempio come nella lettura di un file o in un ciclo foreach. $0 Nome del file corrente che e' eseguito. $] Versione di Perl usata. @_ Contiene i parametri passati ad una subroutine (sottoprogrammi). @ARGV Contiene gli argomenti passati al programma tramite la linea di comando. $! In contesto stringa contiene il motivo per cui si è verificato un errore.

Array Associativi (Hashes) Sono simili ai normali vettori ma gli elementi sono identificati dalle chiavi ( keys ) e non da indici. La chiavi possono essere piu' complesse in quanto stringhe di caratteri. Gli Hash sono caratterizzati dal fatto di avere il nome che inizia col simbolo % e possono essere inizializzati come I vettori: %MioHash = (key1,val1,key2,val2,key3,val3..);

Array Associativi (Hashes) Esempi my %mesi=('gen',31,'feb',28,'mar',31,'apr',30); chiave Alternativamente è più chiaro! valore my %months=('gen'=> 31, 'feb'=> 28, 'mar'=> 31, 'apr'=> 30); sinonimo = synonym => e' un sinonimo della virgola( , )

Array Associativi (Hashes) chiave valore Esempio my %persona = ( nome => 'Piero' , cognome => 'PASIMENI' , codfiscale => "PSMPRR81P03B432K", altezza => 180 ); Notare che il nome delle chiavi, nonostante siano delle stringhe, possono essere scritte senza apici o doppi apici. Questa e' una agevolazione fornita dall'operatore => (fat comma) che serve a separare le chiavi dai valori. Tale operatore considera sempre l'operando di sinistra come se fosse una stringa. => l'interprete emettera' un messaggio di warning se le chiavi non sono definite con apici. my %persona = (nome, 'Piero', cognome, 'PASIMENI', codfiscale, 'PSMPRR81P03b432K', altezza ,180);

Associative Arrays (Hashes) Altro esempio… # %classificazione = ('cane' => 'mammifero', 'falco' => 'uccello', 'serpente' => 'rettile'); %genetic_code = ( 'TCA' => 'ser', 'TTC' => 'phe', 'TTA' => 'leu', 'TGA' => 'STOP' 'CCC' => undef, ... ); Aminoacidi ser -> serina phe -> fenilalanina leu ->leucina pro-> prolina ………. ser = serina phe=

Associative Arrays (Hashes) - elements Gli elementi scalari di un hash vengono manipolati usando le parentesi graffe, { e } : $genetic_code{TCA} = 'ser'; $genetic_code{CCC} = 'pro'; $genetic_code{TGA} = 'STOP'; $amino= $genetic_code{TCA}; Notare il segno $ : gli elementi sono scalari, pertanto devono essere preceduti dal segno del dollaro ( $), pur appartenendo ad un %Hash (proprio come nei vettori).

Associative Arrays (Hashes) funzioni utili exists indica se una particolare chiave esiste all'interno dell ' hash if (exists $genetic_code{$codon}) { Blocco di istruzioni; }else { print "Bad codon $codon\n"; exit; }

Associative Arrays (Hashes) funzioni utili defined indica se una particolare chiave ha un valore oppure e' undef if (defined $genetic_code{'CCC'}) { print " definito "; }else { print " NON DEFINITO "; exit; }

Associative Arrays (Hashes) – funzioni utili keys e values generano vettori dalle chiavi( keys) e dai valori(values) di un hash. @codons = keys %genetic_code; @amino_acids = values %genetic_code; esempio d'uso: foreach $codon (keys %genetic_code) { if ($genetic_code{$codon} eq 'STOP') { last; # i.e. stop alla traduzione } else { # aggiungi alla proteina $protein .= $genetic_code{$codon}; }

Hash – aggiungere una chiave e un valore my %persona = ( nome => 'Piero' , cognome => 'PASIMENI' , codfiscale => "PSMPRR81P03B432K", altezza => 180 ); Supponiamo di voler aggiungere un'altra chiave , il peso, con il relativo valore. $persona{peso}=78;

Hash – cancellare una coppia chiave/valore my %persona = ( nome => 'Piero' , cognome => 'PASIMENI' , codfiscale => "PSMPRR81P03B432K", altezza => 180 , peso => 78 ); Per cancellare dalla struttura hash la coppia peso/valore basta scrivere : delete $hash{$key};

Stringhe e sottostringhe Come si fa a cercare un pezzo di stringa all'interno di una stringa più grande? Perl fornisce una funzione per questo tipo di richiesta: index($StrLunga,$StrCorta) Perl cerca la prima occorrenza della stringa corta all'interno della stringa lunga. il valore restituito può essere positivo, zero oppure -1.

Stringhe e sottostringhe.. index($StrLunga,$StrCorta) valore 0 significa che $StrCorta si trova proprio all'inizio della $StrLunga esempio : my $pos = index("guarda che mare","gua"); # 0 valore 1 significa che $StrCorta si trova all'interno di $StrLunga. esempio : my $pos = index("guarda che mare","che"); # 7 valore -1 significa che $StrCorta non esiste all'interno di $StrLunga. esempio : my $pos = index("guarda che mare","orda"); # -1 NOTA: Rammentare che la posizione del primo carattere a sinistra di una stringa vale 0 e non 1! .

Stringhe e sottostringhe.. La sintassi della funzione index() può,all'occorrenza,avere anche un terzo parametro : index($StrLunga,$StrCorta,$startpos) dove il valore numerico contenuto in $startpos significa che $StrCorta sarà cercata in $StrLunga a partire dalla posizione $startpos esempio : #!/usr/bin/perl my $start = 5; my $pos = index("guarda che mare","gua",$start); # -1 print " pos = $pos"; $pos = index("guarda che mare","rda",$start); # -1 print " pos = $pos"; $pos = index("viva la vita","vi",$start); # 8 print " pos = $pos"; print "\n FINE DEL PROGRAMMA $0 \n"; # filename QusoINDEX.pl

E se volessimo conoscere la posizione dell'ultima occorrenza della stringa corta nella stringa lunga? Perl fornisce la funzione rindex() rindex($StrLunga,$StrCorta) esempio: my $lastzeta= rindex("zio Fabrizio","z"); # ritorna 9 print " pos ultimo zeta = $lastzeta"; Esiste anche Il terzo parametro opzionale index($StrLunga,$StrCorta,$dadove) ma in questo caso rappresenta il massimo valore possibile di ritorno della funzione rindex. esempio: my $pos= rindex("Yabba dabba doo!","doo!",10 ); # ritorna -1 print "\n pos = $pos";

Funzione substr() La funzione substr($Stringa,$Posiniz,$lungh) estrae una pezzo di stringa da $Stringa partendo dalla posizione $Posinit per un certo numero di caratteri $lungh esempio: my $frase = "Prendo un pezzo di torta, grazie"; my $pz = substr($frase,10,5); # ritorna 'pezzo' print " \n stringa estratta = $pz "; Se $lungh è assente , la stringa estratta parte dalla posizione $Posinit fino alla fine di $stringa Esempio: my $resto = substr($frase,22); # ritorna 'ta , grazie' my $resto = substr($frase,100); # ritorna 'ta , grazie'

Funzione substr()… La posizione iniziale $Posinit può essere anche negativa, in tal caso si conta dalla fine di $Stringa (partenza -1)e si estrae sempre verso destra Esempio: my $frase = "Prenda un pezzo di torta,_grazie"; my $dx = substr($frase,-9,6); # ritorna 'a,_gra' Un altro esempio: my $frase = "Prenda un pezzo di torta, grazie"; substr($frase,-6,6) = "Presto!"; print "\n $frase"; # stampa: 'Prenda un pezzo di torta, Presto!' in questo caso abbiamo usato la funzione substr per alterare la stringa originale.

ITERAZIONI In Perl esistono sostanzialmente tre principali strutture di controllo per realizzare cicli iterativi: la struttura while. la struttura for ls struttura foreach

ITERAZIONI (while ) Ripete un blocco di codice quando la condizione è vera. my $count = 0; while ( $count < 10 ) { $count += 2; print "count is now $count\n"; } # stampa i valori 2 4 6 8 10 condizione

ITERAZIONI (while ) Ripete un blocco di codice quando la condizione è vera. #!/usr/bin/perl @frutta = ("mele", "pere", "pesche", "albicocche"); while (@frutta) { $frutto = shift @frutta; print "$frutto\n"; } nota: la condizione (@frutta) è valutata in contesto scalare ovvero rappresenta il numero di elementi presenti nel vettore . L'istruzione shift ne toglie uno dalla testa, in ogni passaggio. Il ciclo finisce quando viene tolto l'ultimo elemento e la dimensione di @ frutta diventa =0 (quindi falso) condizione esempio di ciclo infinito: while(1) { print "\n ciclo che non finisce ";}

ITERAZIONI (do..while ) condizione Ripete un blocco di codice almeno una volta ed infine verifica la condizione di continuazione del ciclo #!/usr/bin/perl print "test do .... while \n"; $i = 0; do { if ($i%2 == 1) { print " $i "; } $i++; } while ( $i < 10); print "\n FINE DEL PROGRAMMA $0 \n"; OUTPUT : stamperà 1 3 5 7 9 ) condizione

ITERAZIONI (do..while ) Ripete un blocco di codice almeno una volta ed infine verifica la condizione di continuazione del ciclo #!/usr/bin/perl print "test do {.... } while \n"; $i = 0; do { if ($i%2 == 1) { print " $i "; $i++; } } while ( $i < 10); Ho fatto una "leggera" modifica al programma precedente. Pensate che la modifica sia giusta?

ITERAZIONI (do..while .. until ) Ripete un blocco di codice almeno una volta ed infine verifica la condizione logica (se è vera esce dal ciclo) #!/usr/bin/perl print "test do { .... } until \n"; $i = 0; do { if ($i%2 == 1) { print " $i "; } $i++; } until ( $i == 10); Quando $i prende il valore 10 il ciclo finisce.

ITERAZIONI - Ciclo for La struttura for consente di ripetere un numero prefissato di volte un certo blocco di istruzioni, controllando la ripetizione del ciclo mediante un contatore. La sintassi dell'istruzione for è la seguente: for (condizione iniziale; condizione finale; incremento) { blocco di istruzioni } #!/usr/bin/perl @frutta = ("mele", "pere", "pesche", "albicocche"); for ($i=0; $i<=$#frutta; $i++) { print "$frutta[$i]\n"; } condizione

ITERAZIONI - Ciclo for Una versione ridotta di ciclo for nasconde il contatore ma mostra i valori di inizio e di fine. La variabile che contiene il conteggio viene fornita "gratuitamente" da Perl ! La variabile è $_ #!/usr/bin/perl for (1..10) { # come foreach loop da 1 a 10 print "counter is $_!\n"; } condizioni for ($i = 1; $i < 10; $i++) { # Oops! Ho sbagliato qualcosa? print "counter is $_!\n";} esempio di ciclo for infinito: for (;;) {print "loop for infinito!\n";}

ITERAZIONI - foreach Permette di scandire un array oppure un hash elemento per elemento. Poniamo di aver definito il seguente array: @luoghi = ('Roma', 'Berlino', 'New York', 'Melbourne'); foreach $k(@luoghi) { print "$k\n"; } Questa struttura memorizza in $k un elemento alla volta dell'array, e fa sì che le istruzioni nel blocco interno vengano eseguite finché tutta la lista è stata analizzata. Una delle comodità di foreach è quella di rendere possibile l'analisi di una copia modificata dell'array, senza per questo alterare l'originale . Ad esempio: foreach $k(sort @luoghi) { print "$k\n"; } causerà la stampa di tutte le città ordinate alfabeticamente. In realtà @luoghi non viene assolutamente variato: ne viene creata ed utilizzata una copia anonima, contenente gli elementi ordinati. foreach (1..10) { print "counter is $_!\n"; } # Perl fornsce $_ come variabile di controllo

Controllare le ITERAZIONI Perl dispone di alcuni operatori per controllare il flusso delle iterazioni. Si tratta di: - last interrompe immediatamente il ciclo next redo # Stampa tutte le linee che contengono la stringa 'fred' ma se incontra il marker __END__ il loop deve finire. while (<STDIN>) { if (/__END__/) { last; } elsif (/fred/) { print; } } ## last porta qui il programma #

Controllare le ITERAZIONI Perl dispone di alcuni operatori per controllare il flusso delle iterazioni. Si tratta di: - last interrompe immediatamente il ciclo next fa partire l'iterazione successiva del ciclo redo # legge un file -una riga la volta- e analizza solo le righe che non sono commenti. RIGA: while (<HFILE>) { next RIGA if /^#/; # Scarta i commenti # $L = length($_"); print "$_ ($L)"; etc. etc…….. }

Controllare le ITERAZIONI Perl dispone di alcuni operatori per controllare il flusso delle iterazioni. Si tratta di: - last interrompe immediatamente il ciclo next fa partire l'iterazione successiva del ciclo redo fa ripetere il ciclo lasciando inalterate le variabili di controllo.

CICLO UNTIL Il ciclo until è l'opposto del ciclo while : si esegue ripetutamente un blocco di istruzioni e smette quando la condizione di test diventa vera. In altre parole , il blocco diistruzioni viene eseguito quando il valore logico del test è falso. Sia il ciclo while che il ciclo until valutano la condizione di test prima di eseguire il blocco di istruzioni ; quindi se la condizione e' inizialmente falsa (perl il while) o vera (per until ) il blocco di istruzioni verrà saltato interamente. I controlli next,last e redo possono essere usati nel ciclo.

CICLO UNTIL Il ciclo until è l'opposto del ciclo while : si esegue ripetutamente un blocco di istruzioni e smette quando la # initializzo un array my $count = 0; my @numeri = qw(one two three four five); until(!@numeri) { $count++; shift(@numeri); } print "$count elementi cancellati !\n"; # stampa: 5 elementi cancellati!

UNTIL usato come modificatore di istruzione istruzione until (EXPR) esempio #!/usr/bin/perl my $count = 10; print $count, " " until --$count <=0; print "\n"; # stampa : 9 8 7 6 5 4 3 2 1 print "count = $count\n"; # stampa count = 0 print "\n FINE DEL PROGRAMMA $0 \n";

ESEMPIO in PERL CAMBIAMENTO DI BASE Il programma chiede in INPUT: - la base ( da 2 a 16) - il numero positivo da trasformare nella nuova base

Cambio base #!/usr/bin/perl use strict; use warnings; use feature 'say'; my $Num ; my $base; my @resto = qw(0 1 2 3 4 5 6 7 8 9 A B C D E F); my @V=(); # vettore vuoto my $r = 0; # resto my $rt = "?"; # resto tabella print "\n===================== "; print "\n trasformazione in base x (2..16) "; print "\n ===================== "; say @resto; do { print "\n inserire la base "; $base = <STDIN>; $base = int($base); } until ( ($base >1) && ($base < 17)); print "\n Base scelta = $base " ; do { print "\n inserire il numero non negativo "; $Num = <STDIN>; $Num = int($Num); } until ( ($Num >= 0)); print "\n Numero scelto = $Num "; my $k =0; my $N = $Num; while ($N >0) { $r = $N % $base; say "(r=$r ) "; $rt = $resto[$r]; say "( rt = $rt ) \n"; unshift(@V,$rt); $N = ($N - $r)/$base; } print "\n fine ciclo while \n \n "; print "\n *********************************** \n"; print " $Num in base $base = @V \n "; print "*********************************** \n"; print "\n FINE PROGRAMMA $0 \n ";

LINK Utili http://www.perl.it/documenti/modern_perl.html http://perldoc.perl.org/index-functions.html http://www.html.it/guide/guida-perl/ http://www.tutorialspoint.com/perl/ http://search.cpan.org/~enrys/POD2-IT-0.12/IT/perl.pod http://www.perl.it/modern_perl/html

Esempio di 'state' use strict; use warnings; use 5.010; sub count { state $counter = 0; $counter++; return $counter; } say count(); say count(); say count(); # say " counter = $counter"; # errore! $ counter non viene vista # fuori dalla sub count

Esempio apertura e lettura di file #!/usr/bin/perl use 5.010; use strict; my $L; open(HF, "<", 'C:\Perl\QTEST\names2.txt'); # apro un file RIGA: while (<HF>) { next RIGA if /^#/; # Scarta i commenti $L = length($_); print "$_ ($L)"; } close(HF); print "\n fine del progr. $0 \n"; # Se eliminate RIGA in tutte le linee funziona lo stesso

Esempio cicli #!/usr/bin/perl use strict; print " test do .... until \n"; my $i = 0; do { if ($i%2 == 1) { print " $i dispari \n"; } $i++; } until ( $i == 10); print " \n FINE ciclo do .. until \n "; my @frutta = ("mele", "pere", "pesche", "albicocche"); for ($i=0; $i<=$#frutta; $i++) { print "$frutta[$i]\n"; }