|
|
Etape 1
Les exercices seront
parfois
réalisés sur des fichiers de travail appartenant
à
un corpus travaillé selon plusieurs versions: la
première, brute p96.tab, est issue d'un tableur (un
tableur
manipule des cellules organisées en lignes et colonnes, et
permet de faire calculer la valeur d'une cellule à partir du
contenu d'une ou de plusieurs autres cellules). C'est la version qui a
été constitué dans le service de
réanimation néonatale à partir des
fiches papier
remplies par les infirmières. Dans ce fichier, le nombre
débutant la ligne concatène le numéro
de
bébé, celui du jour de l'observation et celui de
l'observation dans la journée.La seconde p96.bal nomme les
différentes informations contenues dans une fiche sur un
bébé un jour donné à un
moment
déterminé. On dispose aussi de p96.fic qui
regroupe
toutes les fiches et de p96.tag qui correspond
à une version étiquetée du corpus
bébé.
| |
| |
On copie le programme suivant dans Emacs
#!/usr/local/bin/perl
#
ce programme affiche "bonjour tout le monde"
print
"bonjour tout le monde\n";
Puis on l'exécute:
On modifie ce programme et on ajoute l'affichage du message : "Mon
premier programme écrit avec PERL".
On enregistre le programme sous le nom monpremierprog.pl
puis on exécute le programme:
On
a donc appris ici des choses élémentaires en
langage Perl: la fonction print
sert donc à afficher les éléments
écrit entre guillemets à la suite, le \n
permet de sauter une ligne et pour lancer un programme Perl via le
terminal il suffit de passer une ligne de commande avec la syntaxe
suivante: "perl
nom_du_programme.pl argument_1 argument_2 arugment_n".
|
|
| |
| |
On écrit un programme qui
crée trois variables $var1,
$var2 et $var3 auxquelles on affectera les valeurs 33, 44
et 55 respectivement.
On
ajoute des lignes au programme pour qu’il affiche les valeurs
de chaque variable en sortie.
On obtient le résultat suivant:
Comme on peut le voir il n'y a pas qu'une seule et unique
façon
d'utiliser la fonction print avec Perl. Ainsi on peut tout
écrire entre guillemets, mais on peut aussi ne pas mettre la
variable entre guillemets auquel cas il faudra penser à la
séparer du reste par des virgules.
On crée une variable $somme dans laquelle on met la somme
des
valeurs de chaque variable : $var1 + $ var2, $var1 + $var3, etc.
Puis on affiche la valeur de $somme et des variables
utilisées pour produire cette somme.
Et on obtient:
On crée une variable $produit dans laquelle vous met le
produit des valeurs de chaque variable.
On obtient alors:
On permute les valeurs de $var1, $var2 et $var3. C'est à
dire
que $var1 vaudra ce que valait $var2, $var2 ce que valait $var3, et
$var3 ce que valait $var1.
Pour faire cela on a utilisé une variable temporaire $tmp
afin
de stocker le contenu de $var1 pour ne pas le perdre lorsqu'on
transférait le contenu de $var2 dans $var1.
Le résultat qu'on obtient est le suivant:
|
|
|
| |
Parcours d'une liste
On va se servir du programme suivant afin de le corriger et de
parcourir une liste:
------------------------------------------
#!/usr/bin/perl -w
@liste1 = (lundi mardi mercredi jeudi vendredi samedi dimanche);
print "affichage global :\n";
print @liste1,"\n";
print "@liste1\n";
print "taille de \@liste1 = (à compléter...) \n";
print "son dernier élément est : (à
compléter...)\n";
print "affichage de \@liste1, élément par
élément :\n";
print "\navec une boucle foreach :\n";
------------------------------------------
On complète donc le programme:
On affiche tout d'abord la liste globale sans aucun espace. Puis on
recommence mais avec les espaces afin de faciliter la
lisibilité
(pour cela on utilise un outil bien pratique déjà
vu
"\n"). On affiche la taille de la liste en se servant de la fonction scalar qui
sert à renvoyer le nombre d'éléments
d'un tableau
(ici @liste1). Puis on affiche le dernier
élément
de la liste en se servant de $# qui renvoie le dernier
élément d'une liste.
Enfin on crée une boucle avec la fonction foreach: pour
chaque
variable $c de chaque ligne du tableau @liste1 j'affiche la variable
$c, ceci afin d'afficher chaque élément de la
liste (sans
oublier le petit retour à la ligne).
Le résultat obtenu:
Manipulations
de listes
On va commenter les différentes instructions, et prévoir
très précisément les affichages avant
d'expérimenter du programme suivant:
-----------------------------------------
#!/usr/bin/perl -w
@alpha = ('a'..'z'); @liste = (@alpha,0..9);
$el = $liste[3];
print "$el\n";
($a, $b, $c, @reste) = @liste ;
print "\$a= $a, \$b= $b, \$c =$c , \@reste= @reste\n";
($b, $a)= ($a, $b);
print "\$a= $a, \$b= $b \n";
$el = pop @liste;
print "\$el= $el, \@liste= @liste\n";
$el = shift @liste;
print "\$el= $el, \@liste= @liste\n";
print "\@alpha est la liste \n@alpha\n";
for ($i=0; $i<26 ; $i++) {
$el= pop @alpha;
unshift @alpha, $el;
}
print "\@alpha est maintenant \n@alpha\n";
-----------------------------------------
Et le résultat de ce programme:
|
|
| |
| |
1. Le texte du poème Les amants de Baudelaire est contenu dans le fichier amants.txt.
On va écrire un programme qui ouvre le fichier
amants.txt et qui écrit dans un deuxième
fichier moteneau.txt les seules lignes qui contiennent la
séquence de caractères "eau".
Fichier contenant le résultat: cliquez!!
Fichier contenant le programme: cliquez!!
2. On va réécrire le programme pour numéroter toutes les lignes qui contiennent la même séquence
Fichier contenant le résultat: cliquez!!
Fichier contenant le programme: cliquez!!
3. On va créer un nouveau programme pour produire dans un nouveau fichier contenant le premier mot de chaque vers.
Fichier contenant le résultat: cliquez!!
Fichier contenant le programme: cliquez!!
4. On va créer un nouveau programme pour produire dans un nouveau fichier contenant le dernier mot de chaque vers.
|
|
| |
| |
A partir du fichier amants.txt
, on va construire un programme qui produit en sortie le poème
précédent dans lequel on remplacera la forme
graphique "les" par "des" et "un", "deux" par "1", "2", etc.
Fichier contenant le résultat: cliquez!!
Fichier contenant le programme: cliquez!!
|
|
|
