PERL POUR LA MANIPULATION DE TEXTES Une Introduction par l'exemple

Transcription

1 PERL POUR LA MANIPULATION DE TEXTES Une Introduction par l'exemple Sous linux, on peut exécuter un script perl en tapant dans un terminal la ligne de commande $ perl nom_du_programme.pl Les exemples suivants, introduisent de manière graduelle les éléments de syntaxe du langage perl. EXEMPLE 1 : L'exemple suivant introduit une manière de traiter un fichier externe. Pour tous les exemples suivants on va utiliser un fichier test.txt qu'il faudra copier dans le répertoire Perl. =========== # imprime un texte avec chaque ligne précédée par un numéro de ligne. # perl numerote_lignes.pl test.txt $fich =shift ; print "$. : $_"; print "\n$. lignes en tout\n\n"; ============ La première ligne de n'importe quel programme perl doit être (ne jamais omettre cette ligne de code!!) : Cette ligne indique au système d'exploitation où trouver Perl. (Elle indique le chemin d'accès absolu jusqu'à l'interpréteur) Les lignes suivantes, précédées par le symbole # sont des lignes de commentaire. Elles seront ignorées lors de l'exécution du script. La ligne $fich= shift; permet de récupérer le nom du fichier qu'on cherche à traiter sur la ligne de commande. Ceci nous permet de traiter n'importe quel fichier en utilisant le même script. Ce nom est stocké dans une variable : $fich, dont on pourra se servir par la suite pour faire référence au fichier. Dans notre cas, la valeur de cette variable, inchangée tout au long de ce script sera la chaîne de caractères "test.txt". La ligne permet d'ouvrir le fichier test.txt (la variable $fich vaut dans notre cas "test.txt"), et FICHIER est un descripteur dont on pourra se servir par la suite pour lire dans le fichier $fich, qui vaut en l'occurrence test.txt. Si cette action échoue, parce que le fichier désigne par $fich n'existe pas, (on peut tester ce cas avec un fichier bidon toto.txt), le programme s'arrête avec le message :

2 Impossible d'ouvrir le fichier : toto.txt... indique qu'on cherche à exécuter les actions qui suivent pour chaque ligne du texte à traiter, en l'occurrence FICHIER, qui est le "descripteur " de test.txt. While est un exemple de structure de contrôle qui instruit le système de répéter ou itérer une action (ou une suite d'actions) tant qu'une condition tient. La syntaxe générale de la structure while est while (condition) { action ; action;... Dans l'exemple présent, la condition est 'tant qu'il y a des lignes a lire'. Cette expression est exprimée par l'opérateur <>. Les actions à accomplir (ici l'action d'imprimer à l'écran) sont encadrées pas les guillemets. La ligne print "$. : $_"; fait appel à deux variables spéciales, prédéfinies en perl : $. désigne le numéro de la ligne courante $_ désigne la ligne courante et à l'opérateur print. Un opérateur instruit le système à accomplir une certaine tâche. Le résultat de cette instruction est l'impression à l'écran du numéro de la ligne courante, suivi du signe :, suivi de la ligne courante. Finalement, la ligne print "\n$. lignes en tout\n\n"; permet d'imprimer, une fois que chaque ligne du fichier a été traitée, le nombre total de lignes du fichier (lors de la dernière itération/répétition de la boucle while, la valeur de la variable $_ est la dernière ligne du fichier et la valeur de $. est le numéro de la dernière ligne - on peut donc se servir de cette dernière pour imprimer le nombre total de lignes du fichier.). EXEMPLE 2 : ====================== # imprime un texte avec chaque ligne précédée par un numéro de ligne. # perl..._lignes.pl test.txt $fich=shift ; $len=length($_); print "$len : $_";

3 print "\n$. lignes en tout\n\n"; ====================== Exécuter le programme no 2. Que permet de faire ce programme? Ce programme introduit un élément supplémentaire qui est la fonction prédéfinie length. Que permet de faire cette fonction? EXEMPLE 3 : Que permet de faire le script suivant? Les deux scripts introduisent trois éléments de plus : la structure de contrôle if, l'incrémentation des variables et les opérateurs d'égalité sur des chaînes de caractères : eq c-à-d equals (permettant de tester l'égalité) ou ne c-a-d not-equals (qui permet de tester que deux chaînes de caractères sont différentes). Cet opérateur aurait pu être utilisé à la place de eq en inversant l'ordre des blocs if-else. Comment? ============================== #Ce script permet de... # $fich=shift ; $nombre_lignes_vides = 0 ; $nombre_lignes_non_vides =0; if ($_ eq "\n"){ $nombre_lignes_vides++; else{ $nombre_lignes_non_vides++; print "lignes vides : ", $nombre_lignes_vides, " et lignes non-vides : ", $nombre_lignes_non_vides, "\n"; ##print "lignes vides : $nombre_lignes_vides et lignes non-vides : $nombre_lignes_non_vides\n\n"; ======================= Deux variables son introduites avant le debut de la boucle while : $nombre_lignes_vides et $nombre_lignes_non_vides. Ensuite, dans la boucle while chaque ligne du corpus est traitée. Si elle correspond à la condition définie dans la branche if, alors la variable $nombre_lignes_vides est incrémentée, sinon c'est la variable $nombre_lignes_non_vides qui est incrémentée. NOTE : la notation $nombre_lignes_vides ++ est équivalente à la notation $nombre_lignes_vides =$nombre_lignes_vides+1; Les deux instructions permettent d'affecter à la variable $nombre_lignes_vides son ancienne valeur

4 incrémentée de 1. EXEMPLE 4 : Que permet de faire le script suivant? Il utilise la plupart d'éléments qu'on a déjà rencontrés plus l'opérateur de comparaison > (supérieur). Dans notre exemple, cet opérateur permet de comparer deux quantités numériques. L'exemple montre aussi que le bloc else dans une structure if-else est optionnel. =================== # ce script permet de... $fich=shift ; $max=0; $len=length($_); if ($len > $max){ $max=$len; print "MAXIMUM: $max\n"; =================== EXEMPLE 5 : Que permet de faire le script suivant? ================== # ce script permet de... $fich=shift ; tr/a-zâàäéèêëîïôöóûùüçñ/a-zâàäéèêëîïôöóûùüçñ/; s/([0-9]+) ([0-9]+)/$1$2/g; s/ ([sdlmntcj]')([a-z]+)/ $1\n$2/g; s/^([dlmntcj]')([a-z]+)/$1\n$2/g; s/(qu jusqu lorsqu)'/$1'\n/g; tr/\t//d; s/\.\n/\n.\n/; s/([,\.]) /\n$1 /g;

5 tr/ /\n/; print $_; ====================== Certains éléments qu'on avait vus lors des séances de familiarisation avec l'environnement Linux, mais leur syntaxe est légèrement différente : tr permet de transformer des ensembles de caractères (ici les majuscules en minuscules). NOTE : les deux ensembles de caractères doivent être de taille égale. s permet d'effectuer des substitutions sur des chaînes de caractères. Cette instruction permet de manipuler aussi des expressions régulières. $1 et $2 font référence à la première et deuxième sous-expression d'une expression régulière, qu'on souhaite réutiliser dans les substitutions. Ces deux variables spéciales sont l'équivalent des variables \1 et \2 qu'on avait vu avecla commande grep). Reprenons tour à tour les éléments du langage perl qu'on a vu jusqu'ici, et examinons-les d'une manière plus approfondie : Les variables L'opérateur print. Variables scalaires : - affectation d'une valeur - opérateurs de comparaison Les structures de contrôle Substitutions et transformations sur les chaînes de caractères Ouverture des fichiers et lecture

6 PREMIERE PARTIE 0/ Qu'est-ce que perl et qu'est-ce qu'on peut faire avec perl? 1/ Les variables : scalaires, tableaux, tableaux associatifs 2/ L'opérateur print. 3/ Variables scalaires : - affectation des valeurs - opérateurs de comparaison sur les valeurs scalaires (nombres et chaînes de caractères) - substitutions et transformations sur les chaînes de caractères 4/ Les structures de contrôle 5/ Ouverture des fichiers 0/ Qu'est-ce que Perl et pourquoi on s'y intéresse? Perl (Practical Report and Extraction Language ou Pathological Eclectic Rubbish Lister) est un langage de programmation. Il est particulièrement adapté pour le traitement des fichiers textes (et les CGI). On l'utilise principalement pour la facilité avec laquelle on peut développer des programmes la puissance du mécanisme des expressions régulières simplicité - possibilité de faire des manipulations de textes sans prendre des cours de programmation avancés. (On arrive à faire pas mal de choses même en étant débutants). les programmes écrits en Perl peuvent être exécutés sous Unix, Windows, Mac, etc sans modification (portable) gratuité : un nombre impressionnant de librairies et utilitaires est disponible sur internet 1/ Les variables Un programme informatique gère des données qu il stocke en mémoire. On nomme ces données pour pouvoir accéder aux zones de la mémoire centrale les contenant. Ces données peuvent changer au cours de l'exécution d'un programme : donc les noms qu'on leur donne correspond à des variables. Par exemple, dans le script 4, la variable $max peut changer de valeur a chaque répétition de la boucle while. De même, dans le script no. 3 les variables $nombre_lignes_vides et $nombre_lignes_non_vides, qui au début du script valent 0 toutes les deux - on dit qu'elle sont initialisées à 0, changent alternativement de valeur. Pour mieux se représenter ce que c'est qu'une variable et sa valeur on peut utiliser la métaphore de la boite aux lettres : une variable est comme une boite aux lettres nommée, et sa valeur est son contenu à un moment donné. Il existe plusieurs types de variables qu'on manipule en Perl : 1. des scalaires : des variables ayant une valeur simple, qu'on peut manipuler simplement. Tel est le cas des nombres entiers (comme 2, 30, etc. comme - les variables $max, $length, $nombre_lignes_vides ont des valeurs de ce type), nombres flottants (comme 20,35) et les chaînes de caractères (comme la variable $fich qui prend sa valeur sur la ligne de commande). Les valeurs des chaînes de caractères sont entourées de guillemets simples ou doubles. Le nom des variables est précédé du signe $. 2. tableaux (on reviendra sur ce type de valeur lors de la prochaine séance). Un tableau représente une liste de valeurs scalaires ordonnées; chaque élément d'un tableau est une variable scalaire. Les noms de variables de type tableau sont précédés par le Par exemple, on peut stocker une ligne qu'on lit dans un fichier dans un tableau afin

7 d'effectuer certaines opérations "cat", "is", "on", "the", "mat", "."); On peut se représenter cette variable comme ceci : The cat is on the mat Chaque élément du tableau est placé dans une case du tableau (une zone mémoire associée) à laquelle on peut accéder à l'aide de l'indice de la case. NOTE : les indices dans un tableau commencent à 0. Par exemple, si on vert accéder au 5ème mot de la phrase (qui aura donc l'indice 4) on va utiliser la notation : $ligne(4) La valeur de cette variable scalaire (chaîne de caractères) vaut "the". Lors de la lecture de la ligne suivante d'un fichier, la taille et la valeur d'une variable tableau change "cat", "is", "sick", "and", "is", "waiting", "to", "get", "better", "."); $ligne(4) vaut maintenant "and". 3. hachages ou tableaux associatifs. (On reviendra sur ce type de valeur dans deux séances). Les tableaux associatifs sont une type particulier de tableau. Tandis que les éléments d un tableau sont indexés à partir de 0, les éléments d un hachage sont indexés par une valeur scalaire quelconque. Il s'agit d'une collection de paires clé-valeur. La clés par laquelle les éléments sont indexés doit être unique. Les noms des valeurs des variables de type associatif sont précédés par le symbole %. Un exemple qui permet de se représenter le type tableau associatif d'une façon simple est le type dictionnaire. Par exemple : %dico = ("cat" =>"Any animal of the natural family Felidae", "mat" => "A thick flat fabric", "sick" => "Affected with disease of any kind"); Ou alors %dico = ("cat" =>"Nom", "mat" => "Nom", "sick" => "Adjectif"); Les symboles $,@,% permettent de repérer les variables plus facilement, et indiquent aussi de quel type de variable il s'agit. Regardons maintenant plus en détail les valeurs scalaires (avec une valeur singulière), après une courte digression sur l'opérateur print. 2/ L'opérateur print Il s'agit d'un opérateur qui prend en argument une liste (on peut imprimer plusieurs choses, séparées pas des virgules), comme on a fait dans le script 3 : print "lignes vides : ", $nombre_lignes_vides, " et lignes non-vides : ", $nombre_lignes_non_vides, "\n"; L'opérateur print a, dans ce cas, 5 arguments. On aurait pu écrire la même chose en incluant les variables et le texte à imprimer dans une même chaîne de caractères. Cette opération s'appelle interpolation des variables : print "lignes vides : $nombre_lignes_vides et lignes non-vides : $nombre_lignes_non_vides \n"; L'interpolation des variables est possible uniquement avec les guillemets doubles. 3/Variables scalaires : nombres et chaînes de caractères Vous avez peut-être remarqué dans les exemples de scripts qu'on a étudiés que les variables nombre et chaînes de caractères sont déclarées de la même façon, sans indiquer le type comme ceci : $max=0; ####(entier)

8 $nombre1=12.5 ; #### (nombre réel) $mot="cat"; ####(chaîne de caractères) A l'aide de l'opérateur print on peut les imprimer les trois variables comme ceci : print "\$max vaut $max, \$nombre vaut $nombre et \$mot vaut $mot\n"; REMARQUE : on a du protéger ici le symbole $ afin de pouvoir l'imprimer, et éviter que l'opérateur print affiche la valeur de $max, $nombre1 et $mot. Tous les méta-caractères comme $,@ et % doivent être protégés de cette façon fin de pouvoir les imprimer. A la différence de Perl, dans la plupart de langages de programmation on doit déclarer le type de chaque variable. Par exemple, en C, une déclaration+initialisation comme : $nb_lignes_vides =0 ; devra indiquer le type de la variable qu'on veut déclarer comme ceci : int nb_lignes_vides = 0; Cette ligne déclare la variable nb_lignes_vides de type entier, et lui affecte une valeur initiale qui est égale à 0. C'est pour cette raison que Perl est appelé un langage faiblement typé. C'est à cause de cette manque de rigueur que Perl n'est pas utilisé pour de gros développement de programmes, mais plutôt pour de petites moulinettes. Déclarer et modifier les valeurs des scalaires. Afin d'illustrer ces concepts regardons les deux scripts suivants : $nombre = 20 ; $nb = 3 ; $nombre ++; $nombre--; $nombre +=22; $nombre -= 22 ; $nombre*=$nb ; $nombre /=$nb ; $nombre=$nombre**3 ; ==================== $prenom = "Marion" ; $nom = "Vallet"; $nom = $prenom." ".$nom." "; print "\$nom vaut maintenant $nom\n";

9 ===================== Quel est le rôle de la fonction chop? ===================== print "Entrez votre nom s'il vous plaît\n"; $nom= <STDIN>; print "*$nom*\n"; ### pourquoi le deuxième symbole * est-il imprimé sur une autre ligne? chop $nom; print "maintenant \$nom vaut *$nom*\n"; chop $nom; print "maintenant \$nom vaut *$nom*\n" ; ====================== Cet exemple introduit aussi un descripteur prédéfini <STDIN> ou standard input - c'est à dire l'entrée standard. Il permet de lire la valeur d'une variable au clavier. On reviendra sur les descripteurs de fichiers lors de la prochaine séance. Les descripteurs de fichiers permettent d'interagir avec les fichiers, la console d'entrée, etc. Quelle est la différence entre l'opérateur chop et chomp (à juger par le script ci-après? print "Entrez votre nom s'il vous plaît\n"; $nom= <STDIN>; print "$nom\n"; chomp $nom; print "maintenant \$nom vaut *$nom*\n"; chomp $nom; print "maintenant \$nom vaut *$nom*\n" ; =======================