1 / 82

Introduction à la programmation en Perl There is more than one way to do it

Introduction à la programmation en Perl There is more than one way to do it. Élise VAREILLES vareille@enstimac.fr. 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. Plan du cours.

eydie
Download Presentation

Introduction à la programmation en Perl There is more than one way to do it

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  2. 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

  3. 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

  4. 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

  5. Introduction à Perl Avantage de Perl : écriture rapide d’applications puissantes qui peuvent tourner sur plusieurs plate-formes, prototypage rapide

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

  7. 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

  8. 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

  9. 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’

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

  11. Structure de données : données scalaires • 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 $123548 = 123548;

  12. 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;

  13. Structure de données : données scalaires / Opérateurs et fonctions • 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

  14. Structure de données : données scalaires / Opérateurs et fonctions • 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)

  15. Structure de données : données scalaires • 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

  16. Structure de données : données scalaires • 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

  17. 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

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

  19. Structure de données : tableaux et listes • Affectation : • Du tableau : @t1 = qw(2 éléments); OU @t1 = (2, ‘éléments’); • D’un élément : $t2[2] = 4;  @t2 vaut (3, ‘chaine’, 4);

  20. Structure de données : tableaux et listes • 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 de @t • $t[$#t] retourne la valeur du dernier élément de @t • scalar(@t) retourne la longueur du tableau @t • Pas d’erreur si accès à une case du tableau non définie $t[1000] = 12;  • de 3 à 12, les valeurs de @t sont undef • et scalar(@t) = 1001

  21. Structure de données : tableaux et listes • Opérations sur les tableaux : • Aplatissement : • @t = (1, (deux, 36));  @t = (1, deux, 36); • Intervalles : • @t = (1..5, toto, 5..7)  @t = (1,2, 3, 4, 5, toto, 5, 6, 7); • Répétition : • @t = (1,2, 3)X3;  @t = (1, 2, 3, 1, 2, 3, 1, 2, 3);

  22. Structure de données : tableaux et listes • Tableaux particuliers : • @ARGV : contient les arguments de la ligne de commande • $0 : contient le nom du programme • @_ : contient les paramètres des fonctions

  23. Structure de données : tableaux et listes • Affectations de tableaux à partir d’autres tableaux : • @t = @s; • ($t[1], $t[2]) = (2, toto); • ($t[1], $t[2]) = (2, toto, 3); • ($t[1], $t[2]) = (2); • ($t[1], $t[2]) = @s; • ($t[1], $t[2]) = ($t[2], $t[1]) • my @new = @t[2 .. 15]; •  @t == @s  $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]

  24. Structure de données : tableaux et listes • Fonctions sur les tableaux et listes : • Ajout et suppression d’éléments à Gauche : • unshift(@tab, liste) : ajout de la liste à Gauche • Soit @t = (1, 2, 3, 4); • unshift(@t, 5, 6): • @t == (5, 6, 1, 2, 3, 4) • shift(@tab) : suppression de l’élément à Gauche • Soit @t = (1, 2, 3, 4); • $v = shift(@t): •  @t == (2, 3, 4) et $v == 1

  25. Structure de données : tableaux et listes • Fonctions sur les tableaux et listes : • Ajout et suppression d’éléments à Droite • push(@tab, liste) : ajout de la liste à Droite • Soit @t = (1, 2, 3, 4); • push(@t, 5, 6): • @t == (1, 2, 3, 4, 5, 6) • pop(@tab) : suppression de l’élément à Droite • Soit @t = (1, 2, 3, 4); • $v = shift(@t): •  @t == (1, 2, 3) et $v == 4

  26. Structure de données : tableaux et listes • Joindre/Découper des éléments d’une liste : • scalaire = join(séparateur, liste); • Soit @t1 = (1, 2, 3, 4); • $v = join (‘:’, @t); •  $v == 1:2:3:4 • liste = split(/separateur/, chaine) ; • @t2 = (/:/, $v); •  @t2 == (1, 2, 3, 4) • Trier une liste : liste1 = sort(liste2);

  27. Structure de données : tableaux et listes • Sélectionner des éléments : liste1 = grep {sélection}(liste2); • @t = grep {>2} @t1; • @t == (3, 4) • @s = grep {$_ !=3 and $_ !=4} @t1 •  @s == (1, 2) • Traiter une liste complète : liste2 = map({expression} liste1) • @m = map ({$_*2} @t1); •  @m == (2, 4, 6, 8)

  28. 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

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

  30. Structure de données : tableaux associatifs ou tables de hachage Accès à un élément :$h{clé} $h{Paul} renvoie ’01.23.45.67.89’ Autovivification : création élément si accès alors que celui est non existant $h{‘Élise’} ajoutera le couple (‘Élise’ => ()) à %h.

  31. Structure de données : tableaux associatifs ou tables de hachage • 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’, ’01.23.45.67.89’, ’01.02.03.04.05’

  32. Structure de données : tableaux associatifs ou tables de hachage • Parcours des tables de hachage : • each: renvoie tous les couples un à un • each(%h) renvoie le couple (‘Paul’, ’01.23.45.67.89’) : 1er appel • each(%h) renvoie le couple (‘Virginie, ’01.02.03.04.05’) : 2ième appel • each(%h) renvoie le couple (‘Pierre, ‘je ne sais pas encore’) : 3ième appel

  33. Structure de données : tableaux associatifs ou tables de hachage • 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’ => ’01.23.45.67.89’) de %h

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

  35. Structure de données : tableaux associatifs ou tables de hachage • Tables de hachage et liste : • Soit une liste @liste = (1, 2, 3, 4, 5, 1, 12, 6, 7). • my %h = @liste; 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);

  36. 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

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

  38. 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; };

  39. 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)

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

  41. 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; • }

  42. 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

  43. 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 !!!

  44. 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;

  45. Fonctions sub Puissance {  subPuissance ($$) { 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);

  46. 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

  47. 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.

  48. 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

  49. 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 • ……

  50. Entrées – Sorties / Fichier • 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; }

More Related