Élise VAREILLES vareille@enstimac.fr Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES vareille@enstimac.fr.

Élise VAREILLES vareille@enstimac.fr
Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES

Plan du cours Introduction à Perl Structures de données Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

Introduction à Perl Plan du cours Structures de données
Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

Perl : Practical Extraction and Report Language
Introduction à Perl Perl : Practical Extraction and Report Language Langage de programmation dérivé de script Shell, crée par Larry Wall en 1986 Langage interprété : compilation/exécution Aucune limitation sur la taille des données Gestion de la taille mémoire n’incombe pas au programmeur En informatique, un programme écrit en langage interprété est converti en instructions directement exécutables par la machine au moment de son exécution. Au contraire, un programme écrit en langage compilé est traduit en instructions lisibles par la machine une fois pour toutes. Le programme qui traduit le langage interprété est appelé interprète ; il doit être en fonctionnement sur la machine où l'on veut lancer un programme interprété. Quelques exemples de langages interprétés : BASIC, PHP, Javascript et les langages de script en général. Il existe aussi des langages dits semi-interprétés, pour lesquels il existe un compilateur traduisant le programme non pas en « langage-machine » mais en un code intermédiaire assez analogue à de l'assembleur. Pour pouvoir exécuter ces programmes sur une machine donnée, il faut y faire tourner un interpréteur qui traduise ce code intermédiaire. Le code intermédiaire est souvent appelé pseudo-code ou encore p-code ; l'interpréteur peut, lui, être appelé p-machine ou machine virtuelle. Un exemple de langage semi-interprété est le Pascal dans sa version UCSD. Plus exigeants en ressources et moins rapides à l'exécution que les langages compilés, les langages interprétés gardent toutefois un intérêt notamment par leur facilité de mise en œuvre et la portabilité des programmes, qui peuvent la plupart du temps être lancés sans modification sur toute plateforme où fonctionne l'interpréteur.

Introduction à Perl Avantage de Perl :
écriture rapide d’applications puissantes qui peuvent tourner sur plusieurs plate-formes, prototypage rapide En informatique, un programme écrit en langage interprété est converti en instructions directement exécutables par la machine au moment de son exécution. Au contraire, un programme écrit en langage compilé est traduit en instructions lisibles par la machine une fois pour toutes. Le programme qui traduit le langage interprété est appelé interprète ; il doit être en fonctionnement sur la machine où l'on veut lancer un programme interprété. Quelques exemples de langages interprétés : BASIC, PHP, Javascript et les langages de script en général. Il existe aussi des langages dits semi-interprétés, pour lesquels il existe un compilateur traduisant le programme non pas en « langage-machine » mais en un code intermédiaire assez analogue à de l'assembleur. Pour pouvoir exécuter ces programmes sur une machine donnée, il faut y faire tourner un interpréteur qui traduise ce code intermédiaire. Le code intermédiaire est souvent appelé pseudo-code ou encore p-code ; l'interpréteur peut, lui, être appelé p-machine ou machine virtuelle. Un exemple de langage semi-interprété est le Pascal dans sa version UCSD. Plus exigeants en ressources et moins rapides à l'exécution que les langages compilés, les langages interprétés gardent toutefois un intérêt notamment par leur facilité de mise en œuvre et la portabilité des programmes, qui peuvent la plupart du temps être lancés sans modification sur toute plateforme où fonctionne l'interpréteur.

Instructions se terminant par un point virgule ;
Introduction à Perl Instructions se terminant par un point virgule ; Commentaires précédés de # Blocs d’instructions entourés de { }

Attention en Perl, données non typées
Introduction à Perl Extension des fichiers .pl 1ère ligne des fichiers : chemin accès interpréteur (shebang) #! /usr/local/bin/perl Attention en Perl, données non typées

Scalaires, tableaux, tableaux associatifs
Plan du cours Introduction à Perl Structures de données Scalaires, tableaux, tableaux associatifs Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

Structure de données : données scalaires
Types : chaînes de caractères, nombres, références Chaînes de caractères : “ ”  variables interpolées : print “$v” : écrit la valeur de v ‘ ‘  pas d’interprétation de la valeur des variables : print ‘$v’ : écrit ‘$v’

Nombres : Plusieurs notations possibles : 123, , 12e10 Conversion nombre  chaîne de caractère automatique : 125  “125” Références : Pointeur sur une structure de données

Attention, non obligation de déclarer les variables Déclaration : my $nom_var [= valeur] ; my $empty; my $douze = 12; my $chaine = hello; my ($a, $b) = (1, 45); Nom_var : caractères numériques ou alphanumériques Nom uniquement chiffré : my $ = ;

Structure de données : données scalaires / Opérateurs et fonctions
Chaînes de caractères : Concaténation : . : $chaine.  à tous;  hello à tous Multiplication de chaîne : x : $c =bon x3;  bonbonbon Opérateurs affectation : $x.=$y; $z x= bon;

Chaînes de caractères : Fonctions : length($c) : longueur chop($c) : suppression dernier caractère de $c chomp($c) : suppression du dernier caractère si fin de ligne reverse($c) : renvoie la chaîne inverse

Nombres : Opérateurs classiques : +, -, /, *, % + tronquer le résultat : int($x/$y) Opérateurs affectation : +=, -=, *=, /=, %= : $x *= 4; Puissance : ** : $x**4; Fonctions : sin($x), cos($x), exp($x), log($x), abs($x), sqrt($s)

Fonction defined($v) permet de déterminer si les variables sont définies ou non : 0 si var non définie (non initialisée, erreur, fin de fichier) 1 sinon

Opérateurs de tests : Valeurs scalaires fausses : 0, ‘0’ ou 0, chaîne vide ‘’ ou , undef, Valeurs scalaires vraies : toute autre valeur Opérateurs logiques : and, &&, or, ||, not, ! Opérateurs de comparaison : $x < = > $y retourne un nombre positif si $x > $y, négatif si $x < $y et 0 si $x == $y Opérateurs Chaînes nombres Égalité eq == Différence ne != Infériorité lt < Supériorité gt > Inf ou égal le <= Sup ou égal ge >= Comparaison cmp < = >

Structure de données : tableaux et listes
En Perl, pas de distinction entre liste et tableau : Déclaration : [=(liste de scalaires)] ; Tableau : Tableau vide : = (); Tableau affecté à sa déclaration : = (3, ‘chaîne’, bonjour $v); ¬ = qw(3 chaîne  bonjour $v ); 3 éléments 4 éléments

Affectation : Du tableau = qw(2 éléments); = (2, ‘éléments’); D’un élément : $t2[2] = 4; vaut (3, ‘chaine’, 4);

Accès à un élément du tableau : $t[indice] avec indice de 0 à n-1 $t2[0] renvoie 3, $t2[1] renvoie ‘chaine’ et $t2[2] renvoie 4 Accès au dernier élément : $t[-1] retourne la valeur du dernier élément $t[$#t] retourne la valeur du dernier élément retourne la longueur du Pas d’erreur si accès à une case du tableau non définie $t[1000] = 12;  de 3 à 12, les valeurs sont undef et = 1001

Opérations sur les tableaux : Aplatissement : @t = (1, (deux, 36)); = (1, deux, 36); Intervalles : @t = (1..5, toto, 5..7) = (1,2, 3, 4, 5, toto, 5, 6, 7); Répétition : @t = (1,2, 3)X3; = (1, 2, 3, 1, 2, 3, 1, 2, 3);

Tableaux particuliers : @ARGV : contient les arguments de la ligne de commande $0 : contient le nom du programme @_ : contient les paramètres des fonctions

Affectations de tableaux à partir d’autres tableaux : @t ($t[1], $t[2]) = (2, toto); ($t[1], $t[2]) = (2, toto, 3); ($t[1], $t[2]) = (2); ($t[1], $t[2]) ($t[1], $t[2]) = ($t[2], $t[1]) ];  $t[1] == 2 et $t[2] == toto  $t[1] == 2 et $t[2] == toto, 3 inutile  $t[1] == 2 et $t[2] == undefined  $t[1] == $s[0] et $t[2] == $s[1]

Fonctions sur les tableaux et listes : Ajout et suppression d’éléments à Gauche : liste) : ajout de la liste à Gauche = (1, 2, 3, 4); 5, 6): @t == (5, 6, 1, 2, 3, 4) : suppression de l’élément à Gauche $v = == (2, 3, 4) et $v == 1

Fonctions sur les tableaux et listes : Ajout et suppression d’éléments à Droite liste) : ajout de la liste à Droite = (1, 2, 3, 4); 5, 6): @t == (1, 2, 3, 4, 5, 6) : suppression de l’élément à Droite $v = == (1, 2, 3) et $v == 4

Joindre/Découper des éléments d’une liste : scalaire = join(séparateur, liste); = (1, 2, 3, 4); $v = join  $v == 1:2:3:4 liste = split(/separateur/, chaine) ; @t2 = (/:/, $v); == (1, 2, 3, 4) Trier une liste : liste1 = sort(liste2);

Sélectionner des éléments : liste1 = grep {sélection} (liste2); @t = grep @t == (3, 4) @s = grep {$_ !=3 and $_ == (1, 2) Traiter une liste complète : liste2 = map({expression} liste1) @m = map == (2, 4, 6, 8)

Structure de données : tableaux associatifs ou tables de hachage
Association clé unique-valeur : ‘Paul’ => ’ ’ Déclaration : my %h; my %h = (); my %h = (‘Paul’ => ’ ’, ‘Virginie => ’ ’, ‘Pierre’ => ‘je ne sais pas encore’);

Accès à un élément : $h{clé} $h{Paul} renvoie ’ ’ Autovivification : création élément si accès alors que celui est non existant $h{‘Élise’} ajoutera le couple (‘Élise’ => ()) à %h.

Parcours des tables de hachage : keys : renvoie une liste des clés, ordre quelconque keys(%h) revoie ‘Paul’, ‘Pierre’, ‘Virginie’ values : renvoie la liste des valeurs, ordre quelconque values(%h) renvoie ‘je ne sais pas’, ’ ’, ’ ’

Parcours des tables de hachage : each : renvoie tous les couples un à un each(%h) renvoie le couple (‘Paul’, ’ ’) : 1er appel each(%h) renvoie le couple (‘Virginie, ’ ’) : 2ième appel each(%h) renvoie le couple (‘Pierre, ‘je ne sais pas encore’) : 3ième appel

Fonctions sur les tables de hachage : exists : renvoie vrai si l’élément existe exists($h{‘Paul’}) renverra Vrai exists($h{‘toto’}) renverra Faux delete : supprime de la liste le couple associé à la clé delete($h{‘Paul’}) supprime le couple (‘Paul’ => ’ ’) de %h

Fonctions sur les tables de hachage : reverse : inverse les clés et les valeurs reverse(%h) retourne (‘ ’ => ‘Paul’, ‘ ’ => ‘Virginie’, ‘je ne sais pas encore’ => ‘Pierre’) %h eq 0 : indique si la table de hachage est vide ou non

Tables de hachage et liste : Soit une = (1, 2, 3, 4, 5, 1, 12, 6, 7). my %h crée une table de hachage de la forme : %h : (1 => 2, retiré car une et une seule clé !!! 3 => 4, 5 => 6, 1 => 12, conservé 7 => 0);

Structures de contrôle
Plan du cours Introduction à Perl Structures de données Structures de contrôle Structures, fonctions Entrées-sorties Expressions régulières Références Modules Objets

Structure de contrôle Instructions de test :
Une seule instruction conditionnée instruction-unique if (condition); instruction-unique unless (condition); Un bloc conditionné limité par des accolades if (condition) { instructions; } if (condition) { instructions1; } else {instructions2;} if (condition1) { instructions1; } elsif (condition2) { instructions2; }

Boucle avec nombre itérations connu : for
Structure de contrôle Boucles : Boucle avec nombre itérations connu : for for (initialisation; condition ; incrément) { instructions; } for (my $i = 0; $i < 20; $i++) { print $i; };

Boucle sans nombre itération connu : while
Structure de contrôle Boucles : Boucle sans nombre itération connu : while instruction-unique while/until(condition); while (condition) {instructions; } do { instructions; } while (condition) my $j = 0; while ($j < 20) { print $j; $j += 2; } do { print $j; $j +=2; } while ($j < 20)

Structure de contrôle Boucles sur des listes de valeurs : foreach variable (liste) { instructions;} foreach my $v (1, 43, ‘toto’) { print $v; } foreach my $i 32, ‘titi’) { instructions; foreach { print $_;

Structure de contrôle Saut d’instructions : next : fin de l’exécution, incrément évalué puis test last : fin de la boucle redo :redémarrage du bloc d’instructions sans incrément my $i = 1; while (1) { $i++; last if ($i > 20); next if ($i%2 != 0) print $i; }

Structures de contrôle
Plan du cours Introduction à Perl Structures de données Structures de contrôle Structures, fonctions Entrées-sorties Expressions régulières Références Modules Objets

Les variables sont locales à la fonction !!!
Fonctions La déclaration d’arguments au niveau des fonctions n’est pas obligatoire sub nom_fonction { déclarations de variables; instructions; return scalaire ou liste; } Les variables sont locales à la fonction !!!

@_ : tableau contenant les paramètres d’appel de la fonction
Fonctions Arguments : @_ : tableau contenant les paramètres d’appel de la fonction +ss paramètres : my ($a, $b, $c) 1 paramètre : my ($a) shift : raccourcis pour un paramètre : my $a = shift;

Fonctions sub Puissance {  sub Puissance ($$) {
my ($v, $p) my ($v, $p) if ($v != 0) { if ($v != 0) { return $p**$v; return $p**$v; } else { } else { return 1; return 1; } } } } my $valeur = Puissance(0, 2); my $valeur2 = Puissance(2, 4, 6);

Entrées-sorties Plan du cours Expressions régulières Références
Introduction à Perl Structures de données Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

Entrées – Sorties / Standard
Entrée standard : STDIN my $v = < STDIN > affecte à $v la valeur qui est lue sur l’entrée Séparation des lignes de l’entrée : while ($v = < STDIN >) || while (<STDIN>) { instructions avec $v; || instructions avec $_; } do { $v = <STDIN>; #avec $v déclarée avant la boucle do-while } while ($v) Lorsque la dernière ligne est atteinte, <STDIN> retourne undef et les boucles arrêtent.

Entrées – Sorties / Standard
Sortie standard : STDOUT print (ce qu’il faut écrire); : écrit sur la sortie standard printf (paramètres de format,ce qu’il faut écrire) : écrit sur la sortie standard avec le bon format printf (‘ %5d %5d’, $g, $g); donne …..g…..g

Entrées – Sorties / Fichier
Opérateurs sur les noms de fichier : -e : chemin d’accès au fichier valide If (-e “/usr/temp/fichier”) { print ‘le fichier existe’; } -r : vérification des droits du fichier -w : vérification du droit d’écriture -x : vérification du droit d’exécution ……

Ouverture de fichier : open (HANDLE, “mode ouverture et fichier”) HANDLE : identifiant du fichier après ouverture EN MAJUSCULE (convention) Mode ouverture : open(FIC1, “+<index.txt”) or die (“not open file”) ; if (! open(FIC2, “<index.txt”)) { instructions; } Caractères Mode ouverture Aucun Lecture < > Écriture (écrasement) >> Écriture (ajout) +> Lecture et écriture (écrasement) +< Lecture et écriture (ajout)

Lecture du fichier Par ligne: $l = <FIC>; Toutes les lignes d’un coup = <FIC>; Parcours de toutes les lignes une à une : while (defined ($l = <FIC>)) || ($l = <FIC>) || (<FIC>)) { chomp($l); || chomp($l); || chomp($_); print “ $. : $l ”; || print “ $. : $l”; où $. == numéro de la ligne lue. }

Écriture dans un fichier : print(FIC “ce que j’ai à écrire $v”); printf(FIC “format”, $v); Fermeture d’un fichier : close(FIC);

Expressions régulières
Plan du cours Introduction à Perl Structures de données Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

Fonctionnalités : correspondance (matching) : m/motif/ substitution : s/motif/chaîne/ Opérateurs : =~, !~ ( ! $v =~ m/br/) $v =~ m/sentier/;  recherche du motif sentier dans $v, T ou  $v =~ s/sentier/voiture/;  remplacement du motif sentier par voiture dans $v

Caractères spéciaux précédés de \ pour la correspondance et la recherche : \ | ( ) [ ]~^ $ * + ? . If ($v =~ m/to\?to/) { Instructions; }

Ensembles : . : caractère quel qu’il soit $v =~ s/t.t./titi; [] : ensemble de caractère à rechercher $v =~ m/t[oai]t[oai]/; $v =~ s/p[1-9a-z]/pu; ^ : ensemble complémentaire $v =~ w/^[a-z]/;

Ensembles : \d : un chiffre \D : un non-numérique \w : un alphanumérique \W un non alpha-numérique \s : un espacement \S : un non-espacement $v =~m/ [+-] \d /

Quantificateurs : $me =~m/meuh{3}/; Regroupement : () $me =~m/(meuh){3}/; Motif Exemple Mots matchés * 0 ou plus m/a*/ Mot vide, a, aa, aaa + 1 ou plus m/a+/ a, aa, aaa ? 0 ou 1 m/a?/ Mot vide ou a {n} N fois m/a{3}/ aaa {n , } Au moins n fois m/a{3,}/ aaa, aaaa, aaaaa { , n} Au plus n fois m/a{,3}/ {n, m} Entre n et m fois m/a{2,3}/ aa, aaa

Alternatives : | $nom =~m/(Fred|Marie | Toto) Martin/; Assertions : Début de chaîne : ^ $v =~ m/^T/; Fin de chaîne : $ $v =~ m/ie$/;

Références Plan du cours Modules Objets Introduction à Perl
Structures de données Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

Les références sont des scalaires !! my $ref;
Les références permettent de créer des structures complexes  pointeurs en C Les références sont des scalaires !! my $ref; Elles permettent de passer comme argument aux fonctions des tableaux et des tables de hachages. Sub pointeurs ($$$) { my ($ref_tab, $ref_hash, $scalaire) $ref_tab->[3] = ‘zut’; foreach my ($cle, $valeur) = each(%$ref_hash) { print “$cle, $valuer”; } $scalaire = 4;

Les références permettent de créer des structures complexes
 pointeurs en C Opérateur sur les scalaires : anti-slash : \ my $refv = \$v; $refv = référence de $v $$refv = valeur de $v $$refv = 12;  $v == 12 @ de $v $refv 43.5 $v

Références $reft @t @ de @t
Opérateur sur les tableaux : anti-slash : \ my $reft = = (1, 2, 3 45, 65); $reft = référence @$reft Accès aux éléments : $$reft[2] == $ref[2] == $t[2] == 3 @ $reft @t 1 2 3 45 65

Références $reft %h @ de %h
Opérateur sur les tables de hachage : anti-slash : \ my $refh = \%h; avec %h = (Paul, 01, Virginie, 02); $refh = référence de %h %$refh == %h Accès aux éléments de %$refh : $refh{Paul} == $$refh{Paul} == $h{Paul} == 01 @ de %h $reft %h Paul => 01 Virginie => 02

Références Opérateur ref($p) : donne le type de la référence
“SCALAR” : pointeur sur scalaire “ARRAY” : pointeur sur tableau “HASH” : pointeur sur table de hachage FAUX : $p n’est pas un pointeur If (ref($p) eq “ARRAY” ) { foreach my $v { print $v; }

Références Références anonymes : my $ref1 = \34;
= (6, [16, 33], [‘el’, 0.3, 4], s) ;

Références

Références Accès au champ de la clé A : $r->[3]->{A}  $$r[3]{A}  $r->[3]{A} Accès au champ 2 de la clé P : $r->[3]->{P}->[2]  $$r[3]{P}[2]

Modules Plan du cours Objets Introduction à Perl Structures de données
Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objets

CPAN  modules à installer + documentation
Perl tire sa puissance de la richesse des modules existants : CPAN  modules à installer + documentation + use Module::Nom_Module ppm  modules déjà installés, à installer, installation

Modules Écrire son propre module : NomModule.pm # fichier Utils.pm
Package Utils; Use stritc; Sub bonjour { my $prenom = shift; print “bonjour $prenom”; } 1;

Modules Utiliser un module : use MonModule; #! /usr/local/bin/perl
Use Utils; Utils::bonjour(“Paul”);

Objet Plan du cours Introduction à Perl Structures de données
Structures de contrôle Entrées-sorties Expressions régulières Références Modules Objet

Objets Voici les trois grands principes d’implémentation des objets en Perl5 : Un objet est simplement une référence qui sait à quelle classe elle appartient (voir la commande bless). Une classe est un paquetage qui fournit des méthodes pour travailler sur ces références. Une méthode est une fonction qui prend comme premier argument une référence à un objet (ou bien un nom de paquetage).

Objets 1: # --- fichier Vehicule.pm --- 2: package Vehicule;
3: use strict; 4: sub new 5: { 6: my ($class,$nbRoues,$couleur) 7: my $self = {}; 8: bless($self, $class); 9: $self->{NB_ROUES} = $nbRoues; 10: $self->{COULEUR} = $couleur; 11: return $self; 12: } 13: 1; sub roule { my ($this,$vitesse) print "Avec $this->{NB_ROUES} roues, je roule a $vitesse.\n"; }

Objets #!/usr/bin/perl -w use strict; use Vehicule;
my $v = Vehicule->new( 2, "bleu" );  my $v = new Vehicule(2, "bleu" ); my $v2 = Vehicule->new( 4, "rouge" ); $v2->roule(15); Avec 2 roues, je roule à 15.

Perl Où trouver de l’aide ?

Perl Lancer l’interpréteur avec l’option -w qui affichera différents messages d’avertissement (variables non initialisées,etc.) très informatifs. Avec l’option -c permet de tester uniquement la validité du code sans l’exécuter. On peut les combiner en -wc, ce qui testera uniquement la validité syntaxique du code sans l’exécuter.

Perl Pour effectuer des tests encore plus stricts, vous pouvez commencer vos scripts use strict, qui apporte un certain nombre de restrictions visant à vous éviter de commettre des erreurs bêtes (notamment les fautes de frappe dans les noms de variables). L’option -w peut être remplacée par use warnings. Vous pouvez même ajouter le use diagnostics pour obtenir des messages d’avertissement plus détaillés.

Perl Si vous ne comprenez toujours pas l’erreur, il reste plusieurs solutions : d’abord, consulter les FAQ initialement maintenues par Tom Christiansen. À partir de la version 5.004_04 de Perl , ces FAQ sont distribuées avec Perl . La commande perldoc perlfaq vous donnera l’index de ces FAQ. Une traduction en français de cette FAQ (ainsi que d’autres documentations Perl ) est aussi disponible à l’URL

Perl Le réseau CPAN, a été mis en place dans le but de centraliser tous les documents et fichiers relatifs à Perl . Le site principal est ftp.funet.fi et il existe plusieurs miroirs en France dont : ftp://ftp.jussieu.fr/pub/Perl/CPAN/, ftp://ftp.lip6.fr/pub/perl/CPAN/, Il faut noter enfin l’existence de deux sites WWW : (site géré par les éditions O’Reilly) qui est une source d’informations très précieuse, ainsi que qui est maintenu par un groupe d’utilisateurs.

Élise VAREILLES vareille@enstimac.fr
Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES

Élise VAREILLES vareille@enstimac.fr Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES vareille@enstimac.fr.

Présentations similaires

Présentation au sujet: "Élise VAREILLES vareille@enstimac.fr Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES vareille@enstimac.fr."— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

Élise VAREILLES vareille@enstimac.fr Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES vareille@enstimac.fr.

Présentations similaires

Présentation au sujet: "Élise VAREILLES vareille@enstimac.fr Introduction à la programmation en Perl There is more than one way to do it Élise VAREILLES vareille@enstimac.fr."— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back