Bioinformatica Linguaggio Perl (2)

1. BioinformaticaLinguaggio Perl (2) Dr. Giuseppe Pigola – pigola@dmi.unict.it Dr. Alessandro Laganà – lagana@dmi.unict.it

2. Corrispondenza di pattern • Uno degli strumenti di PERL per riconoscere pattern sono le espressioni regolari; • Le espressioni regolari sono quasi un linguaggio a parte; • Sono un metodo formale di descrivere i pattern da trovare; • Nel seguito vedremo come creare semplici espressioni regolari, usare le espressioni regolari nella corrispondenza di pattern e modificare le stringhe usando le espressioni regolari; Bioinformatica

3. Pattern semplici • In PERL i pattern sono racchiusi in un operatore di corrispondenza di pattern, che alle volte è rappresentato come m//: • Il pattern precedente corrisponde alle lettere S-i-m-o-n in sequenza; • Se non specificato diversamente il pattern viene cercato in $_; • Se il pattern specificato da m// è trovato nella variabile $_, l’operatore di corrispondenza restituisce vero: m/Simon/ if (m/Piglet/) { : # Il pattern “Piglet” è in $_ } Bioinformatica

4. Metacaratteri • Nel pattern ogni carattere corrisponde a se stesso a meno che non si tratti di un metacarattere; • I metacaratteri sono i caratteri che cambiano il comportamento della corrispondenza di pattern: • ^ $ ( ) \ | @ [ { ? . + * • Se il pattern contiene un metacarattere da usare come valore letterale, si deve far precedere il metacarattere da un backslash: m/I won \$10 at the fair/; # Il carattere $ è trattato come simbolo del dollaro letterale Bioinformatica

5. // o altri delimitatori • Oltre che usando gli slash, è possibile rappresentare l’operatore di corrispondenza utilizzando qualsiasi altro carattere: • Spesso il delimitatore viene sostituito quando il pattern contiene slash: • Ma così è più leggibile: if (m,Waldo,) { print “Found Waldo.\n”; } if (m/\/usr\/local\/bin\/hangman/) { print “Found…”; } if (m:/usr/local/bin/hangman:) { print “Found…”; } Bioinformatica

6. Delimitatori // - Variabili • Se i delimitatori sono slash si può anche scrivere la corrispondenza di pattern senza la m e scrivere ad es. /Cheetos/ al posto di m/Cheetos/; • Anche le variabili possono essere usate nelle espressioni regolari. Se un’espressione regolare contiene una variabile scalare, PERL valuta prima la variabile e la interpola; quindi esamina l’espressione regolare: $pat=<STDIN>; chomp $pat; $_=“The phrase that pays”; if (/$pat/) { print “\”$_\” contains the pattern $pat\n”; } Bioinformatica

7. Regole del gioco… • Generalmente, le corrispondenze di pattern iniziano a sinistra della stringa obiettivo e procedono verso destra; • Le corrispondenze di pattern restituiscono vero (in qualsiasi contesto) solo se l’intero pattern è presente nella stringa obiettivo; • E’ trovata per prima la prima corrispondenza possibile (quella più a sinistra) nella stringa obiettivo. Le espressioni regolari non lasciano indietro una buona corrispondenza per cercarne un’altra; • Si prende la prima corrispondenza più grande possibile. L’espressione regolare potrebbe trovare subito una corrispondenza e cercare di estenderla il più possibile. Le espressioni regolari cercano di estendere quanto più possibile la corrispondenza. Bioinformatica

8. Un metacarattere semplice: . • Il metacarattere punto . corrisponde a qualsiasi carattere singolo a eccezione del carattere di nuova riga; • Per es., nel pattern /p.t/, il punto corrisponde a qualsiasi carattere singolo; • Questo pattern troverebbe corrispondenza in pot, pat, pit, carpet, python, … Bioinformatica

9. I non stampabili • \n carattere di nuova riga; • \r ritorno a capo; • \t tabulazione; • \f carattere di avanzamento di pagina; Bioinformatica

10. Quantificatori • Un quantificatore è un tipo di metacarattere che indica all’espressione regolare quante occorrenze consecutive di qualcosa deve trovare; • Un quantificatore può essere inserito dopo qualsiasi carattere singolo o gruppo di caratteri; • Il quantificatore più semplice è il metacarattere +, che fa sì che il carattere precedente corrisponda almeno una volta. Quindi, /do+g/ si trova in: • hounddog ma non in badge • hotdog ma non in doofus • doogie howser ma non in Doogie • doooooog ma non in pagoda Bioinformatica

11. I metacaratteri * e ? • * è simile a +, ma fa sì che il carattere precedente corrisponda zero o più volte; • Ad es. il pattern /t*/ indica di trovare quante più corrispondenze è possibile, ma anche nessuna. Quindi /car*t/ corrisponde a: • carted ma non a carrot • cat ma non a carl • carrrt ma non a caart • Il metacarattere ? fa sì che il carattere precedente corrisponda zero o una volta (al più). • Così /c?ola/ trova cola e ola ma non ccola. • /c*ola/ invece trova cola, ola e ccola. Bioinformatica

12. Ancora quantificatori • PERL consente di trovare il numero esatto di corrispondenze desiderate usando le parentesi graffe { }: • pat{n,m} • In questo caso, n è il numero minimo di corrispondenze e m il numero massimo di corrispondenze, mentre pat è il gruppo di caratteri da quantificare; • Vediamo alcuni esempi: • /x{5,10}/ x occorre almeno 5 volte, ma non più di 10 • /x{9,}/ x occorre almeno 9 volte, ma anche di più • /x{0,4}/ x occorre fino a 4 volte, ma anche 0 • /x{8}/ x occorre esattamente 8 volte Bioinformatica

13. .* • La scrittura .* consente di trovare qualsiasi cosa tra due cose desiderate; • Ad es. /first.*last/ cerca di trovare la parola first seguita da qualsiasi cosa, quindi la parola last: • first then last; • The good players get picked first, the bad last; • The first shall be last, and the last shall be first; Bioinformatica

14. Classi di caratteri • Un’altra pratica comune nelle espressioni regolari è chiedere una corrispondenza di “uno qualsiasi di questi caratteri” • Le espressioni regolari di PERL offrono un tale strumento (classe di caratteri). • Per scrivere una classe di caratteri, i caratteri contenuti devono essere racchiusi tra parentesi quadre [ ]. • I caratteri in una classe di caratteri sono trattati come un carattere singolo durante la corrispondenza: • [abcde] Corrisponde a qualsiasi a,b,c,d o e • [a-e] Idem • [Gg] Corrisponde a G o a g • [0-9] Una cifra • [0-9]+ Una o più cifre in sequenza • [A-Za-z]{5} Qualsiasi gruppo di cinque caratteri alfab. • [*!@#$%&()] Tutti questi caratteri di punteggiatura. In questo caso * rappresenta un letterale. Bioinformatica

15. Classi di caratteri (2) • Se il primo carattere di una classe di caratteri è un accento circonflesso (^), la classe viene negata: • /[^A-Z]/ • In questo caso trova caratteri alfabetici non maiuscoli. • Poiché ], ^ e – sono speciali in una classe di caratteri, esistono alcune regole per la corrispondenza di questi caratteri in modo letterale: • Per trovare un ^ letterale si deve esser certi che non sia il primo carattere della classe; • Per trovare un ] letterale è necessario inserirlo come primo carattere o farlo precedere da un \: /[abc\]]/. • Per inserire un – letterale è necessario inserirlo come primo carattere o farlo precedere da un \. Bioinformatica

16. Classi speciali di caratteri • \w un carattere parola; equivale a [a-zA-Z0-9_] • \W un carattere non parola (inverso di \w) • \d una cifra; equivale a [0-9] • \D un carattere diverso da una cifra • \s uno spazio bianco; equivale a [ \t\f\r\n] • \S un carattere che non sia uno spazio bianco • Esempi • /\d{5}/ corrisponde a 5 cifre • /\s\w+\s/ corrisponde a un gruppo di caratteri parola circondati da uno spazio bianco Bioinformatica

17. Gruppi e alternanze • In un’espressione regolare può capitare di voler sapere se viene trovato uno qualsiasi di un insieme di pattern. La soluzione si chiama alternanza: • Se cerchiamo però le parole frog, bog, log, flog o clog l’espressione /frog|bog|log|flog|clog/ diventa troppo ripetitiva. In questo caso: • /(fr|b|l|fl|cl)og/ if (/dogs|cats/) { print “\$_ contains a pet\n”; } Bioinformatica

18. Gruppi e alternanze (2) • E’ possibile nidificare le parentesi per formare gruppi all’interno di altri gruppi. • /(fr|b|(f|c)?l)og/ • In un contesto elenco l’op. di corrispondenza restituisce una lista delle porzioni dell’espressione trovata racchiuse in parentesi. Ogni valore in parentesi è un valore di ritorno della lista oppure 1 se il pattern non contiene parentesi: • In questo caso il pattern trova qualsiasi cosa (come gruppo), quindi lo spazio bianco, la parola is, un altro spazio bianco e ancora qualsiasi cosa (sempre come gruppo). • Le due espressioni raggruppate sono restituite all’elenco sul lato sinistro e assegnate a $fruit e $color. $_=“apple is red”; ($fruit, $color)=/(.*)\sis\s(.*)/; Bioinformatica

19. Riferimenti • I riferimenti si usano per indicare al motore di espressioni regolari dove cercare il pattern: all’inizio della stringa o alla fine. • Il carattere ^ all’inizio di un’espressione regolare fa sì che l’espressione corrisponda solo all’inizio di una riga. • /^video/ trova la parola video solo se si trova all’inizio di una riga • Il simbolo $ alla fine di un’espressione regolare fa sì che il pattern corrisponda solo alla fine di una riga. • /earth$/ trova earth ma solo alla fine di una riga. • Altri esempi • /^Help/ Le righe che iniziano con Help • /^Frankly.*darn$/ Le righe che iniziano con Frankly e finiscono con darn e tutto ciò che sta in mezzo • /^hysteria$/ Le righe che contengono solo la parola hysteria • /^$/ Righe vuote • /^/ Tutte le righe Bioinformatica

20. Sostituzione • Per sostituire i pattern trovati: • L’op. di sostituzione s/// (dove / può essere sostituito con altri caratteri, es. s###) cerca $_ per patterncercato e sostituisce l’intera espressione regolare trovata con sostituzione. • L’operatore restituisce il numero di corrispondenze o sostituzioni eseguite, o 0 se non ha trovato nulla: s/patterncercato/sostituzione/; $_=“Our house is in the middle of our street”; s/middle/end/; s/in/at/; if (s/apartment/condo/) { # questo codice non è raggiunto } Bioinformatica

21. Lavorare con altre variabili • Piuttosto che lavorare con $_ sarebbe meglio in generale lavorare con altre variabili; • Per usare l’operatore di corrispondenza e l’operatore di sostituzione su variabili diverse da $_ è necessario associarle alla variabile usando l’op. di associazione =~: • L’op. =~ non effettua assegnazioni ma si limita a prendere l’op. di destra e a farlo agire sulla variabile a sinistra. $weight=“185 lbs”; $weight=~s/ lbs//; # toglie lbs dalla stringa Bioinformatica

22. Modificatori e corrispondenze multiple • Per trovare parole senza preoccuparsi se sono maiuscole o minuscole: • Ovviamente PERL offre una soluzione più comoda: • Un altro modificatore per le corrispondenze e le sostituzioni è il modificatore di corrispondenza globale g: l’espressione regolare (o sostituzione) è eseguita ripetutamente nell’intera stringa, effettuando ogni corrispondenza (o sostituzione) subito dopo la prima; • I modificatori possono essere combinati specificandoli tutti dopo l’operazione di corrispondenza o sostituzione. Per es. gi trova tutte le occorrenze di pattern nella stringa, in maiuscolo o minuscolo. /[Mm][Aa][Cc][Bb][Ee][Tt][Hh]/; /macbeth/i; Bioinformatica

23. Modificatori • In un contesto elenco, il modificatore di corrispondenza globale restituisce una lista di tutte le porzioni dell’espressione regolare racchiuse tra parentesi: • In un contesto scalare il modificatore g itera la corrispondenza sulla stringa restituendo vero per ogni corrispondenza e falso quando non trova più corrispondenze: $_=“One fish, two frog, red fred, blue foul”; @F=m/\W(f\w\w\w)/g; # restituisce in @F fish frog fred foul $letters=0; $phrase=“What’s my line?”; while($phrase=~/\w/g) { $letters++; } Bioinformatica

24. Riferimenti all’indietro • Quando si usano le parentesi nelle espressioni regolari, PERL memorizza la porzione della stringa obiettivo che corrisponde a ogni espressione in parentesi; • Queste porzioni trovate sono salvate in una variabile speciale di nome $1 (per il primo insieme di parentesi), $2 (per il secondo) etc; • Il pattern dell’esempio seguente trova i numeri telefonici del Nord America – per. Es. 800-555-1212 – e memorizza ogni porzione in $1, $2 e $3: if (/(\d{3})-(\d{3})-(\d{4})/) { print “The area code is $1”; } Bioinformatica

25. La funzione grep • PERL offre una funzione particolare per cercare pattern negli array: • La funzione grep itera ogni elemento nella lista ed esegue l’espressione o blocco. Nell’espressione o blocco, $_ è impostata a ogni elemento della lista valutato. Se l’espressione restituisce vero, l’elemento è restituito da grep: • In questo caso ogni elemento di @dogs è assegnato, a turno, a $_. L’espressione /hound/ è quindi testata su $_. Ogni elemento che restituisce vero, viene inserito in una lista restituita da grep e memorizzata in @hounds. grep espressione, lista grep blocco lista @dogs=qw(greyhound bloodhound terrier mutt chihuahua); @hounds=grep /hound/, @dogs; Bioinformatica

26. Ancora grep • E’ importante notare che $_ nell’espressione si riferisce al valore effettivo nella lista, non a una copia. Modificare $_ cambia l’elemento originale nell’elenco: • Ora @hounds contiene greyhounds e bloodhounds, con una s alla fine. L’array @dogs originale è anch’esso modificato; • grep può essere usato con qualsiasi altra funzione: @hounds=grep s/hound/hounds/, @dogs @longdogs=grep length($_)>8, @dogs; Bioinformatica

27. La funzione map • map ha una sintassi identica a grep ma restituisce il valore dell’espressione (o blocco), non il valore di $_. Si può usare la funzione map per produrre un secondo array basato sul primo: • In questo caso ogni elemento dell’array @input è diviso sugli spazi, producendo una lista di parole, che viene aggiunta alla lista restituita dalla funzione map. Una volta divisa ogni riga consecutiva di @input, le parole accumulate sono memorizzate in @words. @words = map { split ‘ ‘, $_ } @input; Bioinformatica

28. Gli hash • Gli hash rappresentano un altro tipo di dati collettivo; • Come gli array, gli hash contengono una serie di scalari. La differenza tra array e hash consiste nel fatto che gli hash accedono ai dati scalari per nome, invece di usare un valore numerico come fanno gli array; • Gli elementi degli hash sono composti da due parti: una chiave e un valore. La chiave identifica ogni elemento dell’hash, mentre il valore rappresenta i dati associati alla chiave. Questa relazione è definita come coppia chiave-valore; • Esempi di strutture dati con natura hash sono i numeri seriali dei prodotti, la registrazione di pazienti le bollette, il file system del disco, raccolte CD, etc. Bioinformatica

29. Gli hash in PERL • Un hash in PERL può contenere tutti gli elementi desiderati o almeno quelli consentiti dalla memoria disponibile nel sistema; • Gli hash vengono ridimensionati man mano che si aggiungono e si eliminano elementi; • L’accesso ai singoli elementi è molto rapido e non rallenta in modo significativo man mano che l’hash aumenta di dimensioni; • Le chiavi dell’hash possono avere la lunghezza desiderata (sono scalari) così come le parti dei dati; • Le variabili hash sono indicate dal segno percentuale %. Non condividono i nomi con gli array e gli scalari. Ad es. possiamo avere un hash di nome %a, un array di nome @a e uno scalare di nome $a. Bioinformatica

30. Riempire l’hash • E’ possibile creare singoli elementi di hash come segue: • In questo es. viene assegnato un elemento all’hash %Authors. La chiave di questo elemento è il termine ‘Dune’, mentre i dati sono costituiti dal nome ‘Frank Herbert’; • Il valore associato alla chiave, $Authors{‘Dune’}, può essere considerato come qualsiasi altro scalare; • Perché abbiamo usato $Authors anziché %Authors? Come gli array quando gli hash sono rappresentati come singola entità, presentano un indicatore davanti al nome della variabile (%). Quando si accede ad un singolo elemento invece si accede ad uno scalare. $Authors{‘Dune’}=‘Frank Herbert’; Bioinformatica

31. Inserimento di valori nell’hash • Questa operazione si può abbreviare così: $food{‘apple’}=‘fruit’; $food{‘pear’}=‘fruit’; $food{‘carrot’}=‘vegetable’; %food = (‘apple’, ‘fruit’, ‘pear’, ‘fruit’, ‘carrot’, ‘vegetable’); Bioinformatica

32. Operatore virgola-freccia => • Questo operatore consente di rendere le assegnazioni più leggibili: • E’ possibile scrivere i termini sinistri degli operatori => senza apici. Inoltre una chiave hash a parola singola tra parentesi graffe viene automaticamente racchiusa tra apici: %food = (‘apple’ => ‘fruit’, ‘pear’ => ‘fruit’, ‘carrot’ => ‘vegetable’); $Books{Dune} = ‘Frank Herbert’; %food = (apple => ‘fruit’, pear => ‘fruit’, carrot => ‘vegetable’); Bioinformatica

33. Ottenere i dati da un hash • Spesso non è conveniente accedere a ogni chiave per nome. La funzione keys può essere usata per recuperare tutte le chiavi di un hash restituite come elenco, che può essere quindi esaminato per trovare tutti gli elementi dell’hash: %Movies = (‘The Shining’ => ‘Kubrick’, ‘Ten Commandments’ => ‘DeMille’, Goonies => ‘Donner’); print $Movies{‘The Shining’}; foreach $film (keys %Movies) { print “$film was directed by $Movies($film).\n”; } Bioinformatica

34. Recuperare valori • La funzione values consente di recuperare tutti i valori memorizzati in un hash: • Ogni elemento di @Directors e @Films contiene un riferimento alla stessa coppia chiave-valore di %Movies. Il nome del regista contenuto in $Directors[0] corrisponde al nome del film memorizzato in $Films[0] e così via. @Directors=values %Movies; @Films=keys %Movies; Bioinformatica

35. Invertire l’hash • A volte è necessario recuperare elementi individuali dall’hash in base al valore invece che in base alla chiave. Il metodo migliore per far questo è invertire l’hash, cioè creare un nuovo hash in cui tutte le chiavi dell’hash originale diventano valori e i valori diventano chiavi: • Se i valori (che devono diventare chiavi) non sono univoci si finirà per avere un hash con meno elementi di quello originale. Quando i valori duplicati vengono inseriti nel nuovo hash, le chiavi presenti sono sostituite con quelle nuove. %Movies = (‘The Shining’ => ‘Kubrick’, ‘Ten Commandments’ => ‘DeMille’, Goonies => ‘Donner’); %ByDirector= reverse %Movies Bioinformatica

36. Liste e hash • Quando un hash viene usato in un contesto elenco, PERL lo trasforma in una lista normale di chiavi e valori. Questa può essere assegnata agli array: • E’ possibile eseguire qualsiasi operazione di array normale su @Data e riassegnare l’array a %Movies: %Movies = (‘The Shining’ => ‘Kubrick’, ‘Ten Commandments’ => ‘DeMille’, Goonies => ‘Donner’); @Data = %Movies; %Movies = @Data Bioinformatica

37. Ancora sugli hash • Per copiare un hash è possibile assegnarlo semplicemente ad un altro hash: • E’ possibile inserire hash all’interno di hash: • Se %Second contiene una chiave che compare anche in %First, la seconda occorrenza della coppia chiave-valore sostituisce la prima in %Both. %New_Hash = %Old_Hash; %Both = (%First, %Second); %Additional = (%Both, key1 => ‘value1’, key2 => ‘value2’); Bioinformatica

38. Controllo delle chiavi in un hash • Per verificare se una chiave esiste in un hash: if( exists $Hash{keyval} ) { … } Bioinformatica

39. Rimuovere chiavi da un hash • Nel modo seguente: • Per rimuovere tutte le chiavi e i valori: delete $Hash{keyval}; %Hash = (); Bioinformatica

40. Impiego dell’hash: determinare le distribuzioni di frequenze • Il pattern cercato è un carattere parola \w seguito da nessuno o più caratteri parola oppure trattini [\w-]*; • Con le parentesi la stringa corrispondente viene memorizzata in $1; • $1 viene impostato, a turno, a ogni parola corrispondente al pattern della seconda riga. Questa parola viene usata come chiave all’hash %Words; • La prima volta che appare la parola, la chiave non esiste ancora nell’hash quindi PERL restituisce un valore undef per la coppia. while ( <>) { while ( /(\w[\w-]*)/g ) { $Words{$1}++; } } Bioinformatica

41. Impiego dell’hash: determinare le distribuzioni di frequenze (2) • Incrementandolo, PERL imposta il valore a 1, creando la coppia; • La seconda volta che compare una parola, la chiave esiste già nell’hash %Words e viene incrementata da 1 a 2; • Alla fine l’hash %Words contiene una distribuzione di frequenze delle parole lette: foreach ( keys %Words ) { print “$_ $Words{$_}\n”; } Bioinformatica

42. Trovare elementi unici negli array • Consideriamo la seguente lista: • Per trovare gli elementi senza i duplicati: @fishwords=(‘one’, ‘fish’, ‘two’, ‘fish’, ‘red’, ‘fish’, ‘blue’, ‘fish’); %seen = (); foreach (@fishwords) { $seen{$_}=1; # $_ potrebbe essere sostituito da $fishwords[$i]; } @uniquewords = keys %seen; Bioinformatica

43. Elaborare l’intersezione degli array • L’intersezione fra due array: • La funzione grep viene iterata per l’elenco dei politici impostando $_ a ogni politico. Il nome viene quindi cercato nell’hash %seen. Se viene restituito vero il nome è nell’hash e grep restituisce il valore di $_. @stars=(‘R. Reagan’, ‘C. Eastwood’, ‘M. Jackson’, ‘Cher’, ‘S. Bono’); @pols=(‘N. Gingrich’, ‘S. Thurmond’, ‘R. Reagan’, ‘S. Bono’, ‘C. Eastwood’, ‘M. Tatcher’); %seen=(); foreach (@stars) { $seen{$_}=1; } @intersection=grep($seen{$_}, @pols); Bioinformatica

44. Elaborare la differenza tra due array • La differenza tra due array: • Per i nomi di @pols che compaiono in %seen, grep restituisce falso e tali nomi non vengono inseriti in difference. @stars=(‘R. Reagan’, ‘C. Eastwood’, ‘M. Jackson’, ‘Cher’, ‘S. Bono’); @pols=(‘N. Gingrich’, ‘S. Thurmond’, ‘R. Reagan’, ‘S. Bono’, ‘C. Eastwood’, ‘M. Tatcher’); %seen=(); foreach (@stars) { $seen{$_}=1; } @difference=grep(! $seen{$_}, @pols); Bioinformatica

45. Ordinare gli hash • E’ possibile ordinare secondo quanto specificato in un blocco: • Il blocco fornito per ordinare viene chiamato ripetutamente con $a e $b impostati a ogni coppia di valori che sort richiede al codice di ordinare. In questo caso $a e $b sono impostati alle varie chiavi di %Words. Invece di confrontare $a e $b direttamente, il codice cerca i valori di tali chiavi e li confronta. foreach ( sort keys %Words ) { print “$_ $Words{$_}\n”; } foreach ( sort { $Words{$a} <=> $Words{$b} } keys %Words ) { print “$_ $Words{$_}\n”; } Bioinformatica

46. Funzioni • Per creare subroutine definite dall’utente: • Ad es. sub subroutine_name { … } Sub countdown { for ($i=10; $i>=0; $i-) { print “$i –”; } } Bioinformatica

47. Richiamare subroutine • Quando il programma deve usare il codice della subroutine: • Oppure: • La seconda sintassi può essere usata se la subroutine è già stata dichiarata nel codice; • Quando viene chiamata la subroutine, PERL ricorda la sua posizione, esegue il codice della subroutine e ritorna alla posizione memorizzata. &countdown(); countdown(); Bioinformatica

48. Chiamare subroutine da altre subroutine sub world { print “World!”; } sub hello { print “Hello, “; world(); } hello(); Bioinformatica

49. Restituire valori dalle subroutine • Una subroutine ha un valore detto valore di ritorno; • Questo è il valore dell’ultima espressione valutata nella subroutine o un valore restituito esplicitamente dall’istruzione return: sub two_by_four { 2 * 4; } print 8*two_by_four(); Bioinformatica

50. Return • Restituire un valore: sub x_greaterthan100 { return(1) if ( $x > 100 ); 0; } $x = 70; if (x_greaterthan100()) { print “$x is greater than 100\n”; } Bioinformatica