Discussion :

[africanwinners]

Bonsoir

j'ai un code qui lit deux fichiers, calcule la somme d'une valeur si le premier champ et le second champ sont équivalents, le problème de mon code c'est qu'il retourne une liste non ordonnée

exemple de deux fichiers en entrée

....
c041 Q0 LEMONDE94-002117-19941018 0 21.96325105866688 BM25b0.75
c041 Q0 LEMONDE94-000437-19940604 1 20.92553123441875 BM25b0.75
c041 Q0 LEMONDE94-003052-19940126 2 19.31555377968807 BM25b0.75
....
c055......
c066.....

c041 Q0 LEMONDE94-001688-19940211 0 6.890913759741454 BM25b0.75
.......
c041 Q0 LEMONDE94-000437-19940604 30 4.278459538899437 BM25b0.75
.....

voila le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#!/usr/bin/perl
 
print "bonjour\n";
open(FIC, $ARGV[0]);
open(FICC, $ARGV[1]);
 
  my @a = ();
  my @b = ();
  my $l=0;
  my $v=0;
  my $g=0;
my $h=0;
my $t=0;
my $q=0;
print "choisis un nom de fichier\n";
 
 
chomp(my $fic2=<STDIN>);
open(FIC2, ">$fic2");
 
#print "choisis un nom de fichier pour la référence\n";
 
 
#chomp(my $fic3=<STDIN>);
#open(FIC3, ">$fic3");
 
 
#---------------------------------------------------
# initialisation des variables
#---------------------------------------------------
 
$i=0;
$j=0;
$u=0;
 
while (<FIC>) {
my $ligne=$_;
 
@aa=split(/\s/,$ligne);
$who = $aa[0];
 
 
        $key=$aa[2];
        $HoH{$who}{$key} = $aa[4];
 
 
 
 
 
$i++;
}
 
;
 
while (<FICC>) {
my $ligne=$_;
 
@aa=split(/\s/,$ligne);
$who = $aa[0];
 
 
        $key=$aa[2];
        $HoH2{$who}{$key} = $aa[4];
 
 
 
 
$i++;
}
print "\n";
 
 
foreach my $k (  keys %HoH){
#print "$k: ";
$i=0;
foreach ( keys%{HoH{$k}}){
 
$l= (0.1*$HoH2{$k}{$_})+ (0.9*$HoH{$k}{$_});
print FIC2 ("$k Q0 $_ $i $l  \n");
$i++;
#print "$kk \n";
}}

le problème est qui retourne une liste non trié sachant que je veux que les résultats doivient être par ordre décroissant de score $l

[Lolo78]

Bonjour,

comme tu fais le calcul de score à la toute fin de ton programme, tu ne peux pas savoir à ce moment dans quel ordre prendre les éléments. Donc, il faudrait sans doute stocker les données calculées que tu veux imprimer dans un tableau de tableaux (ou une autre structure de données), puis, après la fin de tes deux boucles for, trier le tableau selon tes besoins et imprimer les données dans l'ordre voulu.

Voici un exemple de modifications à la fin de ton programme (exemple non testé, faute de données suffisantes en entrée, mais je pense que ça devrait marcher et faire ce que tu désires).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
my @result;
foreach my $k ( keys %HoH ) {
    $i=0;
    foreach ( keys %{HoH{$k}} ) {
        $l = (0.1 * $HoH2{$k}{$_}) + (0.9 * $HoH{$k}{$_});
        # print FIC2 ("$k Q0 $_ $i $l  \n");
        push @result, ["$k Q0 $_ $i ", $l];
        $i++;
    }
}
@result = sort { $b->[1] <=> $a->[1] } @result;
print "$_->[0] $_->[1] \n" for @result;

A noter que je ne sais pas à quoi sert vraiment ta variable $i, il est possible que tu veuilles l'alimenter lors de l'impression finale du résultat et non dans les boucles for imbriquées. D'une façon générale, des noms de variables plus parlants ne seraient pas superflus.

Remarques supplémentaires importantes:
- Utilise toujours:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
use strict;
use warnings;

dans tes programmes. Cela permet au compilateur de détecter un certain nombre d'erreurs de codage qui sont sinon bien plus difficiles à détecter;
- Par pitié, formate et surtout indente ton code correctement (comme je l'ai fait ci-dessus), c'est vraiment essentiel pour la bonne compréhension du code par un être humain. J'ai vraiment failli ne pas répondre à ton post en lisant ton code, tu as eu de la chance que j'étais dans un bon jour.
- Utilise la syntaxe à trois arguments de l'instruction open et des filehandles lexicaux, et vérifie la valeur de retour de ces instructions, par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
open my $FIC, "<", $ARGV[0] or die "Ouverture impossible du fichier $ARGV[0] $!" ;

[africanwinners]

Merci Lolo 78 pour votre aide

j'ai pas encore testé votre solution

mais la solution que j'ai trouvé consiste à modifier le key du hash, donc j'ai mis le score comme key, c'est un peu risqué car un score peu être obtenu par plusieurs autre doc, mais dans ce cas ca a marché.
aussi j'ai utilisé le package use Sort::Key

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#!/usr/bin/perl
 use Sort::Key qw(keysort nkeysort ikeysort);
 
print "bonjour\n";
open(FIC, $ARGV[0]);
open(FICC, $ARGV[1]);
 
  my %ab = ();
  my $b = ();
  my @q=();
  my @ns=();
  my $a;
  my $l=0;
  my $j=0;
  my $g=0;
my $h=0;
my $t=0;
my $q=0;
 
my $fic="$j.key";
	open(FIC1, ">$fic");
print "choisis un nom de fichier\n";
 
 
chomp(my $fic2=<STDIN>);
open(FIC2, ">$fic2");
 
#print "choisis un nom de fichier pour la référence\n";
 
 
#chomp(my $fic3=<STDIN>);
#open(FIC3, ">$fic3");
 
 
#---------------------------------------------------
# initialisation des variables
#---------------------------------------------------
 
$i=0;
$j=0;
$u=0;
 
while (<FIC>) {
my $ligne=$_;
 
@aa=split(/\s/,$ligne);
$who = $aa[0];
 
 
        $key=$aa[2];
        $HoH{$who}{$key} = $aa[4];
 
 
# $b premier fichier celui qui contient tt les SN
 
 
$i++;
}
 
print $HoH{c041}{"LEMONDE94-002117-19941018"};
 
while (<FICC>) {
my $ligne=$_;
 
@aa=split(/\s/,$ligne);
$who = $aa[0];
 
 
        $key=$aa[2];
        $HoH2{$who}{$key} = $aa[4];
 
 
# $b premier fichier celui qui contient tt les SN
 
 
$i++;
}
print "\n";
 
 
foreach my $k (  keys %HoH){
#print "$k: ";
$i=0;
foreach ( keys%{HoH{$k}}){
 
$l= (0.1*$HoH2{$k}{$_})+ (0.9*$HoH{$k}{$_});
 
 
$ab{$l}=$_ ;
 
 
$q[$t]=$l;
 
#print "$kk \n";
#print FIC1 "$k $t $_ $l\n";
$t++;
 
if ($t==1000)
	{
	my @ns = nkeysort { $_ } @q;
	foreach my $g (reverse @ns){
 
print FIC2 "$k Q0 $ab{$g} $h $g \n";
$h++;
}
 
 
	$h=0;
	$t=0;
	}
 
}}

Merci

[africanwinners]

J'ai détecté un autre problème

pourquoi le deuxième hash ne peut pas être accédé correctement dans la 2ème boucle, il me retourne de fausse ligne, par exemple le key , il me retourne le dernier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
foreach my $k (  keys %HoH){
 
$i=0;
foreach ( keys%{HoH{$k}}){
 
$l=  1*$HoH{$k}{$_});
 
 
foreach my $u (  keys %HoH2){
 
 
print FIC2 "$u $_:$HoH2{$u}{$_}\n";}}

[Lolo78]

Bonjour,

désolé, mais ton code ne compile pas correctement, il manque une accolade fermante, et je ne peux pas deviner où elle manque. Si tu avais indenté ton code correctement comme je te l'ai demandé, tu aurais sans doute vu l'erreur ou j'aurais sans doute pu voir à quel endroit l'accolade manquante devrait probablement être, mais ce n'est pas possible avec le code que tu as posté.

Une indentation correcte du code n'est pas facultative, c'est essentiel.

Et je ne comprends pas ta description de l'erreur ou du problème que tu rencontres.

Je suggère que tu utilises le module Data:: Dumper pour afficher tes structures de données et que tu postes le résultat, ça nous aidera à t'aider.

[magicshark]

Pour indenter facilement il existe perl tidy
Djibril en a parlé ici ici
Il explique même comment en faire une macro pour notepad++.
Je précise que c'est avec perl de base rien à télécharger.

[Lolo78]

Pour indenter facilement il existe perl tidy
Djibril en a parlé ici ici
(...)

Oui, c'est une solution. Surtout quand on tombe sur du code mal formaté écrit par d'autres. Mais c'est tout-de-même un pis-aller.

Le mieux est quand même de s’astreindre à bien formater son code soi-même, car cela force à réfléchir à la structure de son code, et on évite de grosses erreurs de logique.

[magicshark]

Oui oui moi je dis ça pour donner une solution rapide et efficace. Il m'est arrivé de reprendre du code qui n'était qu'à moitié indenté, ou bien à la fin d'un programme je lance toujours l'outils pour avoir une indentation plus uniforme.
Mais en tant que développeur professionnel, je ne recommande pas l'indentation, je l'oblige .
Sinon on s'égare du sujet

[Artemus24]

Salut à tous.

J'ai fait l'exercice de africanwinners que je reproduis ci-après :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#!C:\perl64\bin\perl.exe -w
 
use strict;
use warnings;
use diagnostics;
use 5.24.1;
 
# =======================
# Controle des paramètres
# =======================
 
unless (defined $ARGV[0]) {say "Vous n'avez pas renseigné votre premier paramètre !"; exit -1}
unless (-e $ARGV[0]) {say "Le fichier $ARGV[0] n'existe pas !"; exit -1}
 
unless (defined $ARGV[1]) {say "Vous n'avez pas renseigné votre second  paramètre !"; exit -1}
unless (-e $ARGV[1]) {say "Le fichier $ARGV[1] n'existe pas !"; exit -1}
 
# ==================================
# Saisie du Nom du Fichier de Sortie
# ==================================
 
print "Choisissez un nom de fichier : ";
chomp(my $ficout=<STDIN>);
print "\n";
 
if (-e $ficout) {unlink $ficout;}
 
# ===================
# Lecture des Fichier
# ===================
 
my (@t,%hash);
 
open(FIC1, "<", $ARGV[0]) or die "Ouverture impossible fichier entrée $ARGV[0] : $!";
while (<FIC1>) { @t = split(/\s/,$_); $hash{$t[0]}{$t[2]}  = 0.9 * $t[4]; };
close FIC1;
 
open(FIC2, "<", $ARGV[1]) or die "Ouverture impossible fichier entrée $ARGV[1] : $!";
while (<FIC2>) { @t = split(/\s/,$_); $hash{$t[0]}{$t[2]} += 0.1 * $t[4]; };
close FIC2;
 
# =================
# Tri et Sauvegarde
# =================
 
my ($k,@res) = (1,);
 
open(FICOUT, ">", $ficout) or die "Ouverture impossible fichier entrée $ficout : $!";
while (my ($i, $ref) = each %hash) { while (my ($j, $v) = each %$ref) { push @res, [$v,$i.' Q0 '.$j.' '.$k++.' '.$v]; }}
foreach my $i ( sort { $b->[0] <=> $a->[0] } @res ) { say FICOUT $i->[1]; }
close FICOUT;
 
exit

Avec en entrée, le fichier fic1.txt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
c041 Q0 LEMONDE94-002117-19941018 0 21.96325105866688 BM25b0.75
c041 Q0 LEMONDE94-000437-19940604 1 20.92553123441875 BM25b0.75
c041 Q0 LEMONDE94-003052-19940126 2 19.31555377968807 BM25b0.75
c025 Q0 LEMONDE94-002117-19941018 0 21.96325105866688 BM25b0.75
c025 Q0 LEMONDE94-000437-19940604 1 20.92553123441875 BM25b0.75
c025 Q0 LEMONDE94-003052-19940126 2 19.31555377968807 BM25b0.75

et le fichier fic2.txt que voilà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
c041 Q0 LEMONDE94-001688-19940211 0 6.890913759741454 BM25b0.75
c041 Q0 LEMONDE94-000437-19940604 30 4.278459538899437 BM25b0.75
c025 Q0 LEMONDE94-001688-19940211 0 6.890913759741454 BM25b0.75
c025 Q0 LEMONDE94-000437-19940604 30 4.278459538899437 BM25b0.75

ET voici le résultat obtenu :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
c025 Q0 LEMONDE94-002117-19941018 4 19.7669259528002
c041 Q0 LEMONDE94-002117-19941018 7 19.7669259528002
c025 Q0 LEMONDE94-000437-19940604 3 19.2608240648668
c041 Q0 LEMONDE94-000437-19940604 8 19.2608240648668
c025 Q0 LEMONDE94-003052-19940126 2 17.3839984017193
c041 Q0 LEMONDE94-003052-19940126 6 17.3839984017193
c025 Q0 LEMONDE94-001688-19940211 1 0.689091375974145
c041 Q0 LEMONDE94-001688-19940211 5 0.689091375974145

J'ai essayé de ne pas passer par le tableau @res pour trier dans l'ordre descendant.
J'aurai voulu tout faire avec %hash mis je n'ai pas trouvé de solution.
Il se peut que de faire la hash table sous cette forme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$VAR1 = {
          'c041' => {
                      'LEMONDE94-001688-19940211' => '0.689091375974145',
                      'LEMONDE94-000437-19940604' => '19.2608240648668',
                      'LEMONDE94-002117-19941018' => '19.7669259528002',
                      'LEMONDE94-003052-19940126' => '17.3839984017193'
                    },
          'c025' => {
                      'LEMONDE94-003052-19940126' => '17.3839984017193',
                      'LEMONDE94-000437-19940604' => '19.2608240648668',
                      'LEMONDE94-001688-19940211' => '0.689091375974145',
                      'LEMONDE94-002117-19941018' => '19.7669259528002'
                    }
        };

facilite le calcul mais pose le problème du tri sur la numérique.
J'ai pu trier la valeur numérique dans le sous-tableau mais pas sur la totalité de la hash table.

Pensez-vous qu'il existe une solution uniquement en hash table ?

@+

[Lolo78]

Bonjour Artemus24,

oui, on peut travailler directement sur le hash, comme avec ce bout de code vite fait remplaçant la fin de ton programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
# =================
# Tri et Sauvegarde
# =================
 
open(FICOUT, ">", $ficout) or die "Ouverture impossible fichier entrée $ficout : $!";
my $j;
say FICOUT "@{$_}" for sort { $b->[3] <=> $a->[3] }  map {my $i = $_; map {[$i, ++$j, each %{$hash{$i} }]} keys %{$hash{$_}}} keys %hash;
close FICOUT;

Ce qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
$ cat out.txt
c025 3 LEMONDE94-002117-19941018 19.7669259528002
c041 7 LEMONDE94-002117-19941018 19.7669259528002
c025 2 LEMONDE94-000437-19940604 19.2608240648668
c041 6 LEMONDE94-000437-19940604 19.2608240648668
c025 4 LEMONDE94-003052-19940126 17.3839984017193
c041 8 LEMONDE94-003052-19940126 17.3839984017193
c025 1 LEMONDE94-001688-19940211 0.689091375974145
c041 5 LEMONDE94-001688-19940211 0.689091375974145

mais c'est pour le fun de l'exercice plus qu'autre chose; franchement, j'ai peur que ces map imbriqués ne soient quelque peu obscurs ou difficiles à comprendre pour beaucoup de lecteurs par rapport à tes for imbriqués bien plus naturels. Et puis, ça crée en fait aussi un tableau intermédiaire, mais c'est un tableau anonyme temporaire.

Je n'ai pas compris ce que tu voulais dire avec:

le problème du tri sur la numérique

[Artemus24]

Salut Lolo78.

mais c'est pour le fun de l'exercice plus qu'autre chose;

Au premier abord, oui, c'est pour le fun. Mais pas uniquement.
C'est aussi pour apprendre et se perfectionner dans le langage Perl.
Je trouve cela lassant qu'une seule personne réponde, sans avoir une autre approche, même si elle remet en cause ce qui est déjà proposé.

franchement, j'ai peur que ces map imbriqués ne soient quelque peu obscurs ou difficiles à comprendre pour beaucoup de lecteurs par rapport à tes for imbriqués bien plus naturels.

Je suis d'accord avec vous, mais c'est à nous d'enrichir par nos réflexions les solutions que l'on peut proposer.
Sinon, l'entraide et la qualité du service que l'on peut offrir risque d'être bas de gamme.
Le demandeur doit aussi faire l'effort de se mettre à niveau, n'est-ce pas ?
Et puis, si tout le monde apprend quelque chose, c'est quand même bien plus enrichissant.

Je n'ai pas compris ce que tu voulais dire avec:

le problème du tri sur la numérique

En effet, un mot a disparu. La phrase est "le problème du tri sur la valeur numérique".
D'une part, je ne suis pas trop expérimenté sur ces hash tables, et d'autre part, en cherchant sur le net, je n'ai pas vu de solution simple répondant à ce cas de figure.

Cela soulève deux questions :

1) est-ce que le choix de cette hash table (ou table associative) est bien adaptée au cumul de la valeur numérique ?
Je réponds partiellement oui car cette approche permet de simplifier le cumul sur le parcours du fichier (voir mon exemple).
Mais vu que la valeur est déterminée par deux clefs, il aurait fallu créer une table à deux entrées.
Or la table associative ne permet pas cela car nous avons toujours deux pairs, la clef (key) et la valeur (value).
Il aurait fallu concaténer les deux clefs pour en faire qu'une seule.

2) est-ce que le choix de la table associative est bien adaptée pour le tri final ?
Il se trouve que nous sommes obligé de changer de structure en passant de la table associative (%) à une table simple (@). A priori, la réponse est non !
La solution soulevée par africanwinners, consistant à inverser le rôle entre la clef et la valeur ne permet pas de gérer les doublons.
Je ne sais pas trop répondre à cette question car africanwinners ne nous dit rien sur sa façon de gérer les doublons (value) au final.

Désolé si je joue les candides, mais je ne suis pas assez expérimenté sur ce sujet pour y répondre tout seul.
Inversement, je peux faire des recherches sur le net, comme je l'ai fait précédemment en partant de votre solution que vous avez proposé au message #2.

J'ai quand même un problème de compréhension sur ce que désigne exactement le mot "hash".
Et quel est la grosse différence avec un tableau à plusieurs entrées ?

@+

[Lolo78]

1) est-ce que le choix de cette hash table (ou table associative) est bien adaptée au cumul de la valeur numérique ?

A mon avis, oui.

Il s'agit de faire une jointure entre deux fichiers (suivie de calculs), le hachage est bien la structure de données adaptée pour cela.

Mais vu que la valeur est déterminée par deux clefs, il aurait fallu créer une table à deux entrées.

C'est tout à fait possible. On pourrait faire un hachage de hachages, ou un hachage de tableaux. Là, africanwinners a choisi de faire deux hachages parallèles, ce n'est pas forcément une moins bonne solution.

Or la table associative ne permet pas cela car nous avons toujours deux pairs, la clef (key) et la valeur (value).
Il aurait fallu concaténer les deux clefs pour en faire qu'une seule.

C'est aussi une solution.

2) est-ce que le choix de la table associative est bien adaptée pour le tri final ?
Il se trouve que nous sommes obligé de changer de structure en passant de la table associative (%) à une table simple (@). A priori, la réponse est non !

Effectivement, on peut se poser la question.

Il est toutefois assez fréquent de procéder de cette manière: utiliser un hachage pour collecter les données puis reformater les données dans une autre structure pour faire les calculs.

La solution soulevée par africanwinners, consistant à inverser le rôle entre la clef et la valeur ne permet pas de gérer les doublons.
Je ne sais pas trop répondre à cette question car africanwinners ne nous dit rien sur sa façon de gérer les doublons (value) au final.

C'est à mon avis une mauvaise solution. Il y a un réel risque de perdre des données.

La chance d'avoir des doublons avec des données à 12 ou 15 chiffres significatifs qui seraient aléatoires est sans doute pratiquement négligeable, mais ce n'est pas le cas avec les données réelles.

Mais c'est une très bonne solution quand on a la garantie qu'il ne peut pas y avoir de doublons. Par exemple, exemple si je veux deux tables de correspondances (une dans chaque sens) entre le nom et le numéro des mois de l'année, je peux écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
my %h1 = (janvier => 1, fevrier => 2, mars => 3, avril => 4, ... decembre => 12);
my %h2 = reverse %h1; # donne :    1 => 'janvier', 12 => 'decembre',   2 => 'fevrier', etc.

parce que je sais qu'il ne peut y avoir des doublons.

J'ai quand même un problème de compréhension sur ce que désigne exactement le mot "hash".
Et quel est la grosse différence avec un tableau à plusieurs entrées ?

Un tableau est une liste de valeurs ordonnées et indexées par des valeurs numériques consécutives.

Un hachage est une liste non-ordonnée de paires clef-valeur. L'avantage numéro un du hachage est que les clefs n'ont pas besoin d'être numériques. On peut, en première approximation, considérer qu'un hachage est un tableau dont les indices n'ont pas besoin d'être numériques.

Par ailleurs, l'accès à une valeur à partir de la clef est très rapide et ne dépend pas de la taille du hachage (même avec un hachage d'un million d'entrées, l'accès à une valeur à partir de la clef est pratiquement instantané). C'est important pour de grosses structures de données.

Les deux inconvénients du hachage: l'ordre des données est pseudo-aléatoire et il ne peut y avoir de doublon de clef.

Comme indiqué ci-dessus, on peut construire des structures imbriquées: hachages de tableaux, tableaux de hachages, hachages de hachages, tableaux de tableaux, hachages de hachages de hachages, etc. Le choix de la bonne structure aura des impacts très importants sur la facilité de codage et sur les performances du traitement. Il faut donc bien y réfléchir. Mais quand un traitement se fait en plusieurs phases, comme dans le cas en question, il peut être judicieux de construire une première structure lors de la première phase et de la convertir en autre chose pour la suite.

J'espère que ça répond un peu à tes questions.

[Artemus24]

Salut Lolo78.

J'ai étudié la solution que vous m'avez communiqué au message #10. Je ne connaissais pas la puissance de ce "map", qui reste au premier abord, fort obscure.
J'ai compris qu'il fallait imbriquer les "map" pour obtenir la présentation recherchée. En tout cas merci pour cette astuce !
Comparativement, Ruby et Phyton sont-ils aussi puissant que le Perl ?

En tant qu'ouvrage en français, qu'est-ce que vous me conseillez ?
--> Philippe Banquet, Les fondamentaux du langage Perl 5 : Apprentissage par la pratique, Éditions ENI, 2013 (ISBN 2-74607-932-1)

C'est le mot hashing ou hash-coding qui ne m'est pas du tout familier.
En recherchant dans un vieux bouquin (Les structures de données et leur représentation en mémoire, de C. Pair et M. C. Gaudel, deuxième édition, décembre 1979), cela se nomme rangement dispersé, l'adressage calculé ou encore adressage associatif.
Je n'ai jamais utilisé cette structure de données car elle reste assez compliquée à mettre au point quand on ne dispose pas, comme dans le cas du Perl, d'un langage qui permet de l'utiliser facilement.
Même si je suis capable de le simuler, cela reste totalement incompréhensible pour quelqu'un qui ne maîtrise pas les bases de la structures des données, en cas de maintenance d'un programme.
Dans le plus compliqué que j'ai pratiqué, ce sont les listes chaînées et les arbres binaires. Quand j'avais besoin de simuler une table associative, j'utilisais un tableau mémoire en faisant une recherche dichotomique.
Je n'avais pas à gérer le cas des collisions dans l'adressage calculé. Mais l'inconvénient de cette approche nécessite quelques parcours supplémentaires que ne dispose pas les tables associatives.

J'espère que ça répond un peu à tes questions.

Oui.

@+

[Lolo78]

J'ai étudié la solution que vous m'avez communiqué au message #10. Je ne connaissais pas la puissance de ce "map", qui reste au premier abord, fort obscure.
J'ai compris qu'il fallait imbriquer les "map" pour obtenir la présentation recherchée. En tout cas merci pour cette astuce !

Franchement, ce n'est vraiment pas un bon exemple pour comprendre le fonctionnement de la fonction map. Un map prend des données à sa droite, les transforme à l'aide de la fonction en paramètre, et les renvoie sur sa gauche. Par exemple, pour générer les dix premiers nombres pairs, je peux prendre les dix premiers entiers de 1 à 10 et les multiplier par 2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
my @nb_pairs = map { $_ * 2 } 1..10;      # -> 2, 4, 6, 8, ... , 20

Il est assez fréquent d'enchaîner des maps linéairement et de construire une espèce de pipeline dans lequel les données subissent des transformations successives. C'est pratique et simple à comprendre. Il est beaucoup moins courant d'imbriquer les maps comme je l'ai fait dans le post # 10 ci-dessus, car c'est nettement moins simple à saisir.

La première partie de mon tutoriel sur la programmation fonctionnelle en Perl: http://laurent-rosenfeld.developpez....ateurs-listes/ explique en détail l'utilisation de map et de quelques autres fonctions de liste analogues. Je pense que c'est beaucoup plus simple à comprendre que mon exemple du post # 10. Je ne peux que t'en conseiller la lecture.

Comparativement, Ruby et Phyton sont-ils aussi puissant que le Perl ?

Ou là là, je suis obligé de répondre?

Disons que j'ai fait du Python pendant quelques années avant de passer à Perl il y a environ 13 ans, si j'ai changé, c'est parce que j'ai préféré Perl. Mais ce n'est que mon point de vue personnel, on peut en avoir un autre (et d'ailleurs, je conserve une certaine tendresse pour le Python, mais préfère et surtout maîtrise beaucoup mieux Perl aujourd'hui). Pour Ruby, je ne peux pas répondre, je l'ai un peu testé pour me faire une idée, mais je n'ai jamais écrit de vrais programmes en Ruby.

En tant qu'ouvrage en français, qu'est-ce que vous me conseillez ?
--> Philippe Banquet, Les fondamentaux du langage Perl 5 : Apprentissage par la pratique, Éditions ENI, 2013 (ISBN 2-74607-932-1)

Je ne connais pas ce livre, je ne peux donc en parler, mais je te conseillerais en priorité les livres de très bonne qualité publiés par O'Reilly à l'époque où O'Reilly publiait encore des livres en français, en particulier: Introduction à Perl et Programmation en Perl. Mais tu ne pourras les trouver qu'en occasion, je pense.

Sinon, il y a sur ce site une traduction française (co-traduite par mes soins) du livre de chromatic, Perl moderne. C'est gratuit et disponible aux formats HTML, PDF, ePub etc: https://perl.developpez.com/tutoriel...ern-perl-2014/. A mon avis, c'est un très bon livre, surtout quand on connaît déjà un peu.

Sur les hachages, ne te prends pas la tête. Dis-toi qu'un hachage, c'est comme un tableau sauf que les indices (les clefs, en fait) n'ont pas besoin d'être numériques. Et souviens-toi des deux propriétés complémentaires: non-ordonné et pas de doublons possibles sur les clefs. Cela suffit pour s'en servir efficacement.

Bonne fin de soirée,
Laurent.

[Artemus24]

Salut Lolo78.

Merci !

si j'ai changé, c'est parce que j'ai préféré Perl.

Oui mais Pourquoi ? Perl est-il plus intuitif, plus puissant, plus d'outils à sa disposition ... et je ne sais quoi d'autres qui font que Perl est à vos yeux; votre langage préféré ?

@+

[Lolo78]

Bonjour,

pour essayer de répondre, je vais raconter les circonstances qui m'ont amené à passer à Perl.

Comme je l'ai dit, je codais en Python depuis quelques années, et j'avais utilisé antérieurement TCL-TK.

Je me suis retrouvé à travailler dans un groupe de migration de données qui utilisait une suite de migration utilisant notamment une grosse centaine de petits outils écrits en Perl (typiquement 30 à 300 lignes de code). En tant qu'utilisateur de cette suite de migration, je n'avais pas vraiment besoin de comprendre en détail le fonctionnement de ces petits outils, mais il m'a semblé utile d'essayer de me former un peu au langage. J'ai donc passé deux ou trois après-midis à lire un tutoriel sur Perl trouvé sur le Net et à tester des petits bouts de code.

A un moment donné, nous nous sommes retrouvés avec des fichiers en entrée n'ayant pas le bon format de données. Pas de problème, me suis-je d'abord dit, je vais écrire un script Python pour reformater ces fichiers. Puis, juste après, je me suis dit: et pourquoi ne pas essayer de le faire en Perl, puisque j'essaie d'apprendre les rudiments du langage? J'ai donc essayé d'écrire cette moulinette en Perl, et j'y suis parvenu en à peine une demi-journée. Je n'aurais sans doute pas passé beaucoup moins de temps en Python. En outre, quand j'ai lancé le programme pour la première fois sur des données réelles volumineuses, il s'est exécuté si rapidement que j'ai d'abord cru qu'il n'avait rien fait; ce n'est qu'en consultant le fichier résultat et sa volumétrie que je me suis convaincu qu'il avait fait le travail voulu (à quelques détails de formatage près).

Le code était sans doute fort maladroit et probablement non-conforme à la plupart des bonnes pratiques, mais le fait est que j'ai réussi à écrire un vrai programme à usage professionnel après avoir passé peut-être une dizaine d'heures à lire un tutoriel sur le Net, alors que sur les forums Python que je consultais à l'époque, on ne parlait de Perl que pour dire que c'était un langage hautement mystérieux et incompréhensible. Pas du tout en fait, Perl s'était avéré simple à apprendre (du moins le petit sous-ensemble du langage que j'avais utilisé) et à utiliser, et il faisait exactement ce que je voulais. J'avais en particulier apprécié la façon naturelle et super-efficace dont les expressions régulières s'intégraient dans le cœur même du langage, ce qui est un plus considérable pour la manipulation de données textuelles.

Cette capacité à écrire un vrai programme solvant un vrai problème avec un petit sous-ensemble de Perl et après avoir passé seulement quelques heures à apprendre les bases du langage, alors que je ne connaissais absolument rien à Perl une ou deux semaines auparavant, m'a donné envie de continuer.

Pour moi, Perl reste le meilleur langage pour traiter des données textuelles, et c'est une partie essentielle de mon activité professionnelle. Python (ou Ruby) est peut-être meilleur pour d'autres usages. La devise de Perl est TIMTOWTDI (there is more than one way to do it, il y a plus d'une façon de le faire); si une autre façon de le faire, c'est de le faire en Python ou en Ruby, et qu'elle est plus efficace, alors pourquoi pas? je ne suis pas sectaire. Je n'ai pas encore rencontré le cas où ce serait vraiment mieux dans un autre langage (hormis de rares cas très particuliers ou des environnements spécialisés ou propriétaires), mais je ne suis sans doute pas réellement objectif: je maîtrise Perl tellement mieux qu'il est devenu peu probable que je puisse faire mieux dans un autre langage de même type.

Je continue à explorer les autres langages de programmation, ne serait-ce que pour essayer d'en garder les bonnes idées.

[Artemus24]

Salut à tous.

Pour moi, le perl n'est pas un langage de programmation, mais un langage de manipulation de données.
Quand je l'ai découvert, je faisais du développement (des interfaces) sur des machines Unix dans les années 90.
Je recevais des flux de données de diverses originies et j'avais besoin de manipuler les données afin de les mettre en forme.
Je n'avais pas envie d'apprendre un nouveau langage, surtout qu'à l'époque, internet n'existait pas et la documentation papier était pratiquement inexistante.
J'avais le choix entre le Korn-shell, le C-shell, le Bourn-shell, AWK et perl.
Je me suis renseigné sur AWK (achat d'un livre), mais j'ai trouvé cela casse-tête.
Je connaissais déjà le Korn-shell, que je ne trouvais pas trop adapté à la manipulation des données.
Le Bourn-shell et le C-shell sont du même gabarit que le Korn-shell.
Comme je connaissais le langage C, je n'ai pas eu de grosses difficultés à me mettre au perl.
Il est intuitif, performant et j'aime bien écrire un script sur quelques lignes et là, le perl correspond à ma façon de raisonner.
J'aime bien créer des outils que je peux me servir comme s'il s'agissait de commandes incluses dans le système d'exploitation.
Cela a duré le temps de cette mission (3 ans), car après je suis revenu au gros système IBM.

Pourquoi j'aime bien ce type de langage ?
C'est un langage de manipulation de données, qui permet aussi d'être une interface avec le système d'exploitation.
Il peut aussi s'exécuter sur d'autres machines, sans remanier le script, ce qui n'est pas toujours le cas des scripts shell.
C'est un langage que tout administrateur système sur des machines UNIX, LINUX devrait connaitre.

Et comme j'ai maintenant du temps à perdre, j'ai décidé de me remettre à ce langage.

@+

[Philou67430]

Pour moi, le perl n'est pas un langage de programmation, mais un langage de manipulation de données.

Si tu entends par là, que ce n'est pas un langage pour applications, c'est de moins en moins vrai. Associé au CPAN, perl permet le développement d'un panel très étendu d'applications "standalone" (PC).
Par ailleurs, il peut aussi servir à créer des serveurs ou des clients par les très nombreux protocoles internet pour lesquels il existe des modules.

[Artemus24]

Salut Philou67430.

Si tu entends par là, que ce n'est pas un langage pour applications, c'est de moins en moins vrai.

Je ne sous-entends rien du tout.

Si je désire faire un développement, genre procédurale ou objet, j'aurai plutôt tendance à faire du C/C++. Pourquoi ?
Parce que se sont des langages destinés à ce genre d'usage. Et il y a une richesse incroyable en ce qui concerne les bibliothèques.
L'autre raison, en est la rapidité à l'exécution car ce sont des langages compilés.

Inversement, Perl est un langage interprété, même s'il existe une phase compilée qui permet d'améliorer la rapidité à l'exécution.
Donc il sera toujours plus lent qu'un programme entièrement compilé !
Le manque de type des données, ce qui nécessite parfois de faire des conversions implicites.

Maintenant, j'ai déjà vu des applications développées dans des langages non adaptés à l'usage que l'on veut en faire.
J'ai tendance à dire que chaque langage à son usage, et qu'il ne faut pas se tromper dans la finalité que l'on désire obtenir.
En ce qui me concerne, le perl est un langage destiné à faire de l'administration sur un ordinateur. Je le compare au rexx sur gros système.

Par ailleurs, il peut aussi servir à créer des serveurs ou des clients par les très nombreux protocoles internet pour lesquels il existe des modules.

Je ne dis pas le contraire, mais si je dois transporter des marchandises d'un point à un autre, dois-je utiliser un vélo ou un camion ?
Sans trop m'avancer, je pense que le camion est bien plus adapté à cet usage.
Et bien, en ce qui concerne les langages, c'est pareil, il y en a qui sont plus spécialisés que d'autres à l'usage que l'on veut en faire.

@+

[Philou67430]

Si je désire faire un développement, genre procédurale ou objet, j'aurai plutôt tendance à faire du C/C++. Pourquoi ?
Parce que se sont des langages destinés à ce genre d'usage. Et il y a une richesse incroyable en ce qui concerne les bibliothèques.

C'est exactement le point que je voulais souligner avec perl, l'incroyable richesse du CPAN, qui permet aujourd'hui de toucher à peu près à tous les domaines de développement.

L'autre raison, en est la rapidité à l'exécution car ce sont des langages compilés.

Inversement, Perl est un langage interprété, même s'il existe une phase compilée qui permet d'améliorer la rapidité à l'exécution.
Donc il sera toujours plus lent qu'un programme entièrement compilé !

Est-ce le besoin premier d'une application classique...
Je ne veux pas dire que Perl est le langage de prédilection pour toutes les applications, mais le résumer à un "manipuleur de données" me semble réducteur. J'utilise perl tous les jours en production pour de plus ou moins petits outils (certains avec un GUI). Il permet un développement rapide et un prototypage d'applications ou d'algorithmes également facilité par sa densité sémantique.

Le manque de type des données, ce qui nécessite parfois de faire des conversions implicites.

Je suppose que tu voulais dire des conversions explicites, car la plupart du temps, perl opère des conversions implicites automagiquement (c'est le propre des langages faiblement typé).

Maintenant, j'ai déjà vu des applications développées dans des langages non adaptés à l'usage que l'on veut en faire.
J'ai tendance à dire que chaque langage à son usage, et qu'il ne faut pas se tromper dans la finalité que l'on désire obtenir.
En ce qui me concerne, le perl est un langage destiné à faire de l'administration sur un ordinateur. Je le compare au rexx sur gros système.

Je ne dis pas le contraire, mais si je dois transporter des marchandises d'un point à un autre, dois-je utiliser un vélo ou un camion ?
Sans trop m'avancer, je pense que le camion est bien plus adapté à cet usage.
Et bien, en ce qui concerne les langages, c'est pareil, il y en a qui sont plus spécialisés que d'autres à l'usage que l'on veut en faire.

Ce 1er chapitre extrait de "Perl pour l'impatient" résume assez bien mon opinion à propos de perl