Initiation au langage Perl Atelier Calvix du 27 avril 2007 copyleft : Emmanuel GRENADOS

Introduction Perl est un langage de programmation spécialement adapté aux traitement de données et de fichiers textes. Il est très pratique pour développer de petits utilitaires. Du fait de sa popularité et de son coté openSource, beaucoup de developpements de modules additionnels ont vu le jour et sont disponibles sur le net. Les possibilités sont immenses (interfaces, reseau, CGI, conversions de formats...). Perl est un langage interpreté. C'est à dire que le programme est en langage texte (donc forcement openSource) et qu'il n'a pas besoin d'être compilé. Du fait qu'il est interpreté et de sa souplesse avec les variables, ses performances sont beaucoup plus limitées lorsqu'il s'agit de faire des calculs complexes en temps réel.

Syntaxe Perl Les commandes d'un script Perl sont en général executées l'une après l'autre dans le sens de lecture. Chaque commande se termine par un ; (point virgule) Une commande peut être écrite sur plusieurs lignes. Les espaces supplémentaires et les retour à la ligne ne sont pas pris en compte (sauf dans les chaînes de caractère). Les commentaires sont précédés du symbole # En general la première ligne d'un script perl contient les symboles #! suivis du chemin vers l'interpreteur perl (en général /usr/bin/perl sous linux) : #!/usr/bin/perl Ceci permet de faire comprendre au système d'exploitation qu'il doit appeler l'interpreteur perl lorsqu'on execute le fichier : >./monscript.pl (le fichier doit avoir les droits d'execution) On peut egalement executer le programme avec la commande : > perl monscript.pl

variables : scalaires Un scalaire contient une donnée  soit un nombre (entier, réel, octal, hexa...)  soit une chaine de caractère : définie entre quotes, simples ' ou doubles “. Dans une double quote les variables sont évaluées.  Suivant le contexte, un nombre peut être consideré comme une chaine et vice-versa  un scalaire est représenté par un nom précédé du signe $ $prix = ; # equivalent à : $prix = « »; $message = « bonjour » ; $phrase = « $message le prix de cet objet est $prix euros\n »; print $phrase ; # equivalent à : print « $phrase » ; > bonjour le prix de cet objet est euros print '$message le prix de cet objet est $prix euros\n' > $message le prix de cet objet est $prix euros\n

manipulation des scalaires opérateurs sur les nombres + (addition) - (soustraction) * (multiplication) ** (puissance) / (division) % (modulo) comparaison sur les nombres (supérieur) = (supérieur ou égal) == (égalité) != (différence) opérateurs sur les chaines de caractère :. (concatenation) : "Bonjour"."Monsieur" "BonjourMonsieur" comparaison sur les chaines de caractère : eq (égalité) ne (différence) lt (inférieur) gt (supérieur) le (inférieur ou égal) ge (supérieur ou égal)

variables : tableau (array) Un tableau est une liste de scalaires  classés dans un ordre précis...de 0 à (n-1) si le tableau est de taille n  la taille du tableau est variable. On peut rajouter ou enlever des éléments  un tableau est représenté par un nom précédé du un élément du tableau (un scalaire) s'écrit avec un $ = (1, « rouge », 25, 32.4) ; # tableau de taille 4 print « $montableau[1] \n » ; > rouge $montableau[1] = « vert »; print »; > 1 vert

manipulation des tableaux.. (intervalle) (1..10) 10 éléments (les chiffres de 1 à 10) (1..5,10,20..30) 16 éléments (les chiffres de 1 à 5, puis le chiffre 10 et les 10 chiffres de 20 à 30 ($debut..$fin) (($fin+1) - $debut) éléments ayant pour valeurs de $debut à $fin par incrément de 1 $#tableau (index de la dernière valeur du tableau = (taille du tableau – 1) ) $element) : ajoute un élement à droite du tableau : enlève un élement à droite du tableau et renvoit sa valeur : ajoute un élement à gauche du tableau : enlève un élement à gauche du tableau et renvoit sa valeur : trie un tableau dans l'ordre ASCII : inverse l'ordre des elements dans un = split(' ',$chaine) : coupe les mots d'une chaine et les met en tableau $chaine = join(' : creer une chaine à partie d'un tableau

variables : tableau associatif (hash) Un hash associe des paires clé-valeur  à chaque clé (scalaire) est associé une valeur (scalaire)  il n'y a pas d'ordre particulier dans un hash  un hash est représenté par un nom précédé du signe %...mais une valeur ou une clé du hash (un scalaire) s'écrit avec un $ %couleurs = (“cerise” => “rouge”, “banane” => “jaune”, “kiwi” => “vert”, “orange” => “orange”) ; # hash avec 4 paires print $couleur{banane} >jaune

manipulation des hashes keys(%hash) : renvoie une liste des clés du hash values(%hash) : renvoie une liste des valeurs du hash delete($hash($cle)) : supprime la paire clé-valeur dont la clé est $cle du hash ($cle,$valeur) = each(%hash) : renvoie une paire clé-valeur. A chaque appel on passe à la paire suivante...jusqu'a la fin du hash.

Entrée et sortie standard Lecture au clavier d'une ligne (jusqu'au caractère de retour): $ligne = ; ou $ligne = <>; Ecriture sur la sortie standard : print STDOUT $ligne; ou print $ligne Ecriture sur la sortie d'erreur standard : print STDERR $ligne STDIN, STDOUT et STDERR sont appelés des descripteurs...ou handle..ou channel. Il peut y avoir des descripteurs pour divers types de communication : fichiers, port d'interface, ports ethernet...

Lecture/Ecriture de fichiers Ouverture d'un fichier en lecture : open(MONFIC, $nom_du_fichier_a_lire); MONFIC est un nom de descripteur au choix du programmeur. Lecture d'une ligne du fichier (renvoie 'false si on est à la fin du fichier) : $ligne = ; La prochaine lecture lira la ligne suivante. Ouverture d'un fichier en ecriture : open(MONFIC2, « >$nom_du_fichier_a_ecrire »); Ecriture d'une ligne dans le fichier : print MONFIC2 $ligne; La prochaine écriture se fera à la suite. Ouverture d'un fichier en append (écriture à la fin) : open(MONFIC2, « >>$nom_du_fichier_a_ecrire »); Ecriture d'une ligne dans le fichier : print MONFIC2 $ligne; La prochaine écriture se fera à la suite. Fermeture d'un fichier (A toujours faire avant de sortir du programme): close(MONFIC>;

Exemple de lecture/ecriture de fichier #copie d'un fichier ligne à ligne dans un autre open(LECT, « fichier1.txt »); open(ECR, « >fichier2.txt »); while($ligne = ) { print ECR $ligne; } close(LECT); close(ECR)

Exercice 1 Definir un scalaire, un tableau et un hash contenant des valeurs de votre choix. Afficher le contenu de chacun à l'ecran.

Exercice 2 Demander un montant en francs et récuperer la valeur entre au clavier. Convertir le montant en euros (1 euro = francs).

contrôle : if Les structure de contrôle permettent d'executer des commandes lorsqu'une condition est remplie. if (condition1) { #commandes executées lorsque la condition1 est remplie } elsif (condition2) { #commandes executées lorsque la condition1 n'est pas remplie mais la # condition2 est remplie } else { #commandes executées lorsque aucune des conditions n'est remplie } une condition peut être formée de plusieurs conditions : && est un 'et' logique, || est un 'ou' logique, ! est un 'non' logique. exemple : if ( !($i =20) ) { print « le nombre est positif et n'est pas dans l'intervalle 10 -> 20»; }

contrôle : unless unless (condition1) { #commandes executées lorsque la condition1 n'est pas remplie } elsif (condition2) { #commandes executées lorsque la condition1 est remplie et la # condition2 est remplie } else { #commandes executées lorsque la condition1 est remplie et la #condition2 n'est pas remplie }

boucles : while /until while (condition) { #commandes repetées tant que la condition est vérifiée #si la condition n'est pas vérifiée on passe à la suite } until (condition) { #commandes repetées jusqu'à ce que la condition soit vérifiée #si la condition est verifiée on passe à la suite }

boucles : for for (commande_initiale ; condition ; commande_boucle) { #commandes executées tant que la condition est remplie } est équivalent à : commande_initiale; while(condition) { #commandes executées tant que la condition est remplie commande_boucle; } ex : for ($i=1; $i<=6; $i = $i + 1) { print « $i »; } >

boucles : foreach foreach $variable (scalaire1,scalaire2,scalaire3,scalaire4) { #commandes executées pour $variable valant chaque element de la liste } #ecriture de tous les scalaires d'un tableau foreach $variable { print «$variable »; } #ecriture de toutes les paires clé-valeur d'un hash foreach $cle (keys(%hash)) { print « $cle : $hash{$cle} \n»; }

Fonctions/Sous programmes Une fonction se décrit à l'aide de la commande sub. Elle peut être ensuite appelée n'importe ou dans le programme. On peut passer des variables à une fonction et en récuperer en retour. Dans la fonction, les arguments d'entrée sont 'passés' par le Les valeurs de retour sont renvoyée avec la commande return en fin de fonction sub nom_de_la_fonction { #commandes de la fonction return $scalaire; #ou tableau ou hash : valeur renvoyée (facultatif) } ex : sub moyenne { $note1 = $_[0]; #premier argument du $note2 = $_[1]; #deuxième argument du $moyenne = ($note1 + $note2) / 2.0 ; return $moyenne }

Fonctions (suite) L'appel à une fonction se fait en précédant le nom de la fonction d'un & (et commercial) : ex : $moyenne1 = &moyenne (12,14); # vaut 13 $moyenne2 = &moyenne(8,17); #vaut 12.5

Exercice 3 Créer une fonction calculant le montant d'impot payé en fonction du revenu annuel et du nombre de parts. Ecrire dans un fichier pour des revenus allant de 0 à euros par increment de 10 euros : sur chaque ligne : revenu impot_1_part impot_2_parts impot_3_parts Calcul de l'impot 2007 (sur les revenus 2006) : R = revenu du foyer P = nombre de parts I = impot annuel R1 = R – 10/100 * R (sauf frais réels) QF = R1/P si QF <= 5515 : I=0 si 5515 < QF <= : I = (0.055 * R1) - (303.25*P) si < QF <= : I = (0.14 * R1) - ( *P) si < QF <= : I = (0.30 * R1) - ( *P) si < QF : I = (0.40 * R1) - ( *P)

Operateur de recherche L'operateur de recherche permet de chercher une expression à l'interieur d'une chaine de caractère. Il renvoit une valeur 'true' si l'expression est trouvée. $chaine =~ / /; #pour voir si elle contient l'expression $chaine !~ / /; #pour voir si elle NE contient PAS l'expression L'expression à chercher peut etre - une chaine de caractère : ex : $phrase = « maitre corbeau sur un arbre perché» if ($phrase =~ /corbeau/) { print « le mot corbeau est présent dans la phrase»; } - ou une expression régulière qui agit comme une sorte de masque décrivant ce que l'on recherche : if ($phrase =~ /cor\w+ /) { print « la phrase contient un mot commencant par cor»; }

expression régulière (1) Une expression régulière décrit une suite de caractère à chercher. Chaque caractère est décrit par un descripteur de caractère suivi éventuellement d'un multiplicateur : un descripteur de caractère peut être : -un caractère: a -un groupe de caractères (entre crochets) : [abcdeh] -un intervalle de caractères (entre crochets) : [a-z1-5] -un groupe de caractère exclus (entre crochets) : [^abdeft] -un type prédéfini : \w (= lettre ou chiffre ou _), \d (=chiffre), \s (espace ou tab), \W (tout sauf une lettre ou un chiffre ou _), \D (tout sauf chiffre), \S (tout sauf un espace ou une tabulation)

expression regulière (2) un multiplicateur de fichier permet de dire combien de fois le descripteur de caractère doit être recherché. Il se place juste après le descripteur de caractère : \d* : 0 chiffre ou plus \d+ : 1 chiffre ou plus \d : exactement 1 chiffre (pas de multiplicateur) \d{n,m} : entre n et m chiffres \d{n,} : au moins n chiffres \d{n} : exactement n chiffres quelques exemples : /\s\d+\seuros/ : un espace suivi d'un nombre (au moins un chiffre) suivi d'un espace et suivi du mot 'euros' /[a-e]\d[^z]*/ : une lettre entre a et e, suivi d'un chiffre, suivi éventuellement de lettres differentes de z

expression régulière (3) On peut aussi utiliser dans une expression régulière: ^ : début de la chaine de caractères $ : fin de la chaine de caractères $scalaire : une variable | : ou entre 2 chaines : ex /pomme|banane/ : pomme ou banane On peut mémoriser certaines partie de l'expression pour les réutiliser en les entourant de parenthèses...et en les appelant à l'aide de \1, \2, \3... ex : /(\d+)\s\1/ : 2 nombres identiques séparés par un espace

Opérateur de recherche (suite) L'utilisation de l'opérateur de recherche remplit un certain nombre de variables si l'expression régulière est trouvée : $& contient la partie de la chaine qui correspond à l'expression cherchée $` contient la partie de la chaine avant l'expression $' contient la partie de la chaine après l'expression $1 contient la première expression entre parenthèses $2 la 2eme...etc ex : $phrase = “il etait une fois dans une galaxie lointaine, tres lointaine...”; $phrase =~ /(fois)\s+(\w+)\s+(\w+\s)/; $` = 'il etait une ' $& = 'fois dans une ' $' = 'galaxie lointaine, tres lointaine...' $1 = 'fois' $2 = 'dans' $3 = 'une '

Exemple Voici un exemple classique : lecture d'un fichier et récuperation de valeurs à l'aide d'expressions régulière : Ici le fichier contient des données sur 3 colonnes separées par des espaces ou des tabulations (par exemple des valeurs exportées d'un tableur en format texte). #!/usr/bin/perl open(FIC, “donnees.txt”); $numeroligne = 0; while ($ligne = ) { $numeroligne++; if ($ligne =~ /(\S+)\s+(\S+)\s+(\S+)\s*$/) { $valeur1[$numeroligne] = $1; $valeur2[$numeroligne] = $2; $valeur2[$numeroligne] = $3; } close(FIC);

Exercice Calculer à partir du fichier contenant les derniers tirages du loto, le nombre de fois que chaque numero a été tiré et écrire les valeurs dans un autre fichier.

Opérateur de substitution Il permet de remplacer une expression régulière par une chaine de caractère dans une chaine : pour remplacer la première occurrence de l'expression régulière : $chaine =~ s/expression regulière/chaine de remplacement/; pour remplacer toutes les occurences de l'expression régulière : $chaine =~ s/expression regulière/chaine de remplacement/g; ex : $phrase = “la da di la da da da”; $phrase =~ s/da/do/; > la do di la da da da $phrase =~ s/da/do/g; > la do di la do do do

Pour aller plus loin cours : resumé : documentation fournie : archives de modules perl (en anglais): aide offline : perldoc -f perldoc et...le web en général