Discussion :

[helkha86]

Bonjour
j ai un ficheir de base qui contient plusieur type d 'infos du genre:
NOM
ferrat
lain
...
...
...
aubert

PRENOM
jean
...
...
...
amel

Numero de tele
04.25.85.36.12
...
...
...
01.21.00.25.12
je veux une fonction qui permet de classifier ces donnée de maniere:

NOM PRENOM Num de tele
ferrat jean 04.25.85.36.12... ...
... ...
... ...
aubert amel 01.21.00.25.12


tres cordialement

[Quantactique]

Plusieurs question avant cela :

1- Ton fichier contient t-il les noms ET les prénoms ET les numéros ou ces données sont elles dans différents fichiers.

2- A chaque nom on retrouve obligatoirement au moins un prénom et un numéro de téléphone, il n'y à pas de gens dont il nous manque une des infos ?

3- Pour demain c'est bon ? ^^

[helkha86]

tous ces donnes sont dans le meme fichier!!! juste que par de chaque type de donnée j ai environ 500( por les nom j ai 500nom de famille et de meme pour les prenoms et nums de tels)

j ai une propostion on declare un tableau:
push (@type_array,noms);
push (@type_array,prenoms);
push (@type_array,nums de tels);

oui ca m'arrange pour demain!!

[Philou67430]

Alors pour demain, regarde du coté des types hash (%) imbriqués dans un type tableau (@). Pour cela, lire la doc en tapant la commande

Code :

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

perldoc perldata

ou ici, en français.

Bonne lecture

[helkha86]

d'accord
a demain alors

[Lolo78]

Hum, un hash de tableaux, c'est une notion assez avancée, pour demain, tu risques de t'y perdre un peu.

Tu peux simplement créer trois tableaux: @prenoms, @noms, @numtel.

Tu lis le fichier séquentiellement. Quand tu rencontres la ligne avec le mot NOMS, tu commences à mettre les mots que tu rencontres dans ton tableau @noms (avec un "push", par exemple), tant que tu ne rencontres pas la ligne avec le mot PRENOMS. Quand tu rencontres cette ligne, tu commences à mettre le contenu de tes lignes dans le tableau @prenoms, tant que tu ne rencontres pas la ligne Numéro de téléphone.

Lors de l'une des itérations, tu incréments le compteur $nb_max initialement mis à 0 pour connaître le nombre de ligne total.

Quand tu as fini, tu parcours tes trois tableaux en parallèle avec quelque chose comme ça (non testé):

Code :

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

1
2
3
4
5
6
7
open FILE_OUT, ">fichier_noms.txt" or die "Impossible d'ouvrir le fichier";
$i = 0;
while ($i < $nb_max) {
     print FILE_OUT "$prenom[$i] $nom[$i] $numtel[$i] \n";
     $i ++;
     }
close FILE_OUT;

C'est un peu moins élégant qu'un hash de tableaux, mais ce sera plus facile à réaliser.

[Philou67430]

Hum, un hash de tableaux, c'est une notion assez avancée, pour demain, tu risques de t'y perdre un peu.

Un tableau de hash

Cette méthode permet d'introduire très tôt (et relativement "naturellement"), la notion de "structure" qui n'existe pas nativement en perl comme dans les langages fortement typés tel que C.

Exemple (j'ai considéré que le premier nom d'une liste est le nom du champ, et que chaque liste est séparée de la suivante par une ligne vide) :

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
open my $FIC, "<", "base.txt" or die "Cant open base.txt : $!\n";
my @base;
my ($index, $field) = (0);
while (defined(my $line = <$FIC>)) {
  chomp($line);
  if (!defined($field)) {
    $field = $line; # initialisation du nom du champ si vide
    next;
  }
  if (!length($line)) {
    undef $field; # reset du nom du champ si ligne vide
    $index = 0;
    next;
  }
  if ($field) {
    $base[$index++]->{$field} = $line;
  }
}
 
use Data::Dumper;
print Data::Dumper->Dump([\@base], [qw(*base)]);

[Quantactique]

Oui moi j'aurais fait comme Lolo78. C'est simple à réaliser bien que moins propre. En tout cas, à toi de voir celle que tu préfère, les 2 fonctionnent aussi bien.

Tu peux essayer ça (pas testé) ça devrait fonctionner. C'est assez simpliste mais ça fait le travail demandé.

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
#!/usr/bin/perl
 
use strict;
use warnings;
 
my (@in, @nom, @prenom, @tel, $i);
my $nom = 0;
my $prenom = 0;
my $tel = 0;
 
open(IN, "<nomprenomtel.txt") || die "\n"."E/S : $!"."\n";
 
while(<IN>){
	chomp($_);
	push(@in, $_);
}
 
close(IN);
 
for($i = 0; $in[$i] ne "PRENOM"; $i++){
	push(@nom, $in[$i]);
}
 
for(; $in[$i] ne "NUMERO DE TEL"; $i++){
	push(@prenom, $in[$i]);
}
 
for(; $i < $#in+1; $i++){
	push(@tel, $in[$i]);
}
 
 
open(OUT, ">>fichierSortie.txt") || die "E/S : $!";
 
for($i = 0; $i <= $#tel; $i++){
	print OUT "$nom[$i] $prenom[$i] $tel[$i]"."\n";
}
 
close(OUT);

Si tu veux des explications dit le.

[Lolo78]

Un tableau de hash

Tableau de hashes, hash de tableaux ou même tableaux de tableaux (ça, ce n'est vraiment pas très beau dans notre cas), les trois structures sont susceptibles de marcher. Mais tu as raison, c'est vrai qu'un tableau de hashes modélise mieux et plus élégamment les données du cas présenté qu'un hash de tableaux.

Cela dit, "slurper" tout un fichier en mémoire n'est pas toujours une bonne idée. Ici, avec trois fois 500 lignes, ça ne pose pas de problème, mais j'ai eu des choses similaires à faire avec des fichiers de plusieurs dizaines de millions de lignes

Dans ce cas, je ferais sans doute quelque chose comme ça (code incomplet non testé):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
my ($prenom, $nom, $numtel);
open PRENOMS, "<file_in.txt" or die "etc. \n";
open NOMS, "<file_in.txt" or die "etc. \n";
open NUMTEL, "<file_in.txt" or die "etc. \n";
 
while (<PRENOMS>) {
    next unless /^PRENOM$/;
    }
while (<NOMS>) {
    next unless /^NOM$/;
    }
while (<NUMTEL>) {
    next unless /^Numero$/;}

J'ai maintenant trois handlers de fichier positionnés chacun au début de la liste voulue (<PRENOMS> est au début de la liste des prénoms, etc.). Il suffit de lire les trois fichiers en parallèle.

Code :

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

1
2
3
4
5
6
7
8
9
open FILE_OUT, ">fichier_noms.txt" or die "Impossible d'ouvrir le fichier";
while ($numtel = <NUMTEL> {
     $nom = <NOMS>;
     $prenom = <PRENOMS>;
     print FILE_OUT "$prenom $nom : $numtel \n";
     }
close FILE_OUT;
close PRENOMS;
close etc.

Personnellement, c'est ce que je ferais même avec un petit fichier, parce que l'on peut toujours avoir à réutiliser le script dans des conditions très différentes.

[ours_en_pluche]

re,

lolo, dans tes handler, tu as aussi ce qui suit non ?

par exemple, dans l handler correspondant a NOM, tu as aussi la liste des prenoms et num de tel ?
dans l'handler correspondant a PRENOM, tu as aussi les nums de tel non ?

cordialement

[Lolo78]

lolo, dans tes handler, tu as aussi ce qui suit non ?

par exemple, dans l handler correspondant a NOM, tu as aussi la liste des prenoms et num de tel ?
dans l'handler correspondant a PRENOM, tu as aussi les nums de tel non ?

Oui, mais la boucle while qui contrôle le parcours en parallèle du fichier est le handler <NUMTEL>, donc quand on arrive à la fin des numéros de téléphone, on est (c'est mon hypothèse d'après l'énoncé du problème) à la fin du fichier, le process s'arrête. Donc, puisque l'hypothèse de départ est qu'il y a exactement autant de lignes de noms, de prénoms et de numéro de téléphone, je ne vais pas plus loin que voulu sur les prénoms et les noms.

Quand j'écris:

Code :

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

$nom = <NOMS>

$nom est une variable scalaire et je ne récupère qu'un seul nom et je positionne mon filehandler sur la position suivante du fichier. C'est la boucle while qui fait que l'on lit tout le fichier.

Cela dit, mon code est incomplet, il faudrait au minimum ajouter un chomp sur $nom, $prenom et $numtel (sinon le nom, le prénom et le numéro de téléphone ne seront pas sur la même ligne). On pourrait aussi ajouter des tests pour éviter tout débordement, mais ce n'est pas nécessaire si on considère que le fichier en entrée est bien formé. Dans la vraie vie, mon expérience m'a appris à être plus prudent...

[ours_en_pluche]

re,

ok, je comprend mieux
merci

moi j'aurai tout séparé par un regexp, mais c est vrai que si y a plusieurs milliers de noms, mouarf la mémoire

cordialement

[Philou67430]

Cela dit, "slurper" tout un fichier en mémoire n'est pas toujours une bonne idée.

Tu noteras que ce n'est pas ce que j'ai proposé (while (defined($line = <$FILE>)) { ... })

Ici, avec trois fois 500 lignes, ça ne pose pas de problème, mais j'ai eu des choses similaires à faire avec des fichiers de plusieurs dizaines de millions de lignes

Personnellement, je considère qu'il faut toujours faire au plus simple tant que l'on a pas de contrainte particulière (pas d'optimisation apriori).
Donc je n'ai pas d'apriori sur l'usage du slurp de fichier.
Cela dit, le traitement ligne par ligne (while (<FILE>)) au lieu du slurp (@lines = <FILE> ou foreach my (<FILE>)) offre un avantage : la variable $. donne toujours le numéro de ligne en cours de traitement (alors qu'après un slurp, elle vaut le dernier numéro de ligne). C'est contournable en comptant les lignes dans une variable à part, mais ça alourdit inutilement l'algorithme.

Quant à l'idée de Lolo de boucler avec plusieurs handle (j'avoue n'avoir jamais utilisé cette technique, qui m'a surpris au premier abord), elle me parait "lourde" (je ne vois pas de simplification significative en terme d'algorithmique ou de consommation mémoire par rapport à une lecture séquence à handle unique) et pas générique (en cas de modification du contenu du fichier source comme un déplacement des numéros de téléphone avant les prénoms, une nouvelle catégorie "adresse" ajoutée à la fin) le script doit être ré-écrit. Je préfère donc la lecture séquentielle à handle "unique".

[Philou67430]

Dans la vraie vie, mon expérience m'a appris à être plus prudent...

Dans la vie de bio-informaticien, il faut être doublement prudent...

[Lolo78]

Tu noteras que ce n'est pas ce que j'ai proposé (while (defined($line = <$FILE>)) { ... })

J'employais le terme "slurper" au sens large, dans le sens qu'avec la méthode que tu proposes (comme d'ailleurs dans celle que j'avais initialement proposée avec trois tableaux), tout le fichier est chargé en mémoire et réside en mémoire pour la durée du traitement.

Avec de gros fichiers, c'est niet.

Alors qu'en utilisant trois itérateurs (mes trois handlers de fichier), il n'y a à tout moment qu'au maximum trois lignes du fichier en mémoire (un nom, un prénom et un numéro de téléphone). Et ça change tout quand on manipule comme moi des fichiers qui peuvent atteindre plusieurs gigaoctets.

Je dois souvent comparer deux fichiers provenant de deux applications différentes (format différents, mais certaines données au moins doivent être en commun) afin de trouver les lignes qui sont communes et celles qui sont orphelines (données dans un fichier et pas dans l'autre, c'est généralement une anomalie qu'il faut corriger). Quand les fichiers sont petits, je me contente de lire l'un des fichiers et de le stocker dans un hash en mémoire (autrement dit, je le "slurpe" au sens large), puis je lis l'autre fichier et je pointe les données communes en cherchant dans le hash. Je produis trois fichiers: données communes, orphelins à droite et orphelins à gauche.

Cette méthode est inexploitable quand les fichiers deviennent très gros car la mémoire exploserait (crois-moi, je connais le message "out of memory"). Dans ce cas, je dois impérativement m'y prendre autrement, je fais ce que l'on appelle un appareillage ou un appariement. Je trie les fichiers selon une clef commune (sort Unix, par exemple), puis je parcours les deux fichiers en parallèle pour détecter les données communes et les données manquantes à droite ou à gauche, un peu à la manière de l'algo (nettement plus simple) que j'ai proposé.

[Philou67430]

Je te crois lolo, pas de soucis. Je dis simplement que si l'on n'a pas de contraintes particulières (comme celle de fichiers démesurés), il n'est pas utile de faire des optimisations particulières, et donc on peut (doit) rester très générique (et simple).

Pour ce qui est du slurp (au sens large que tu entends) : il arrive que dans un fichier de plusieurs Giga-octets, on ai pas besoin de plus de 0,1% des données, ce qui peut devenir traitable en mémoire. Par ailleurs, on peut aussi utiliser d'autres techniques de stockage des informations extraites (base de données, tie) qui n'influent pas sur l'algorithme de lecture séquentielle à un handle, et qui ménagent la mémoire utilisée.

Cordialement.

[helkha86]

merci a vous tous de votre participation heir j ai pa pu participer avec vous a la discussion (a cause d un bleme de connexen) sinon j ai essayé une de ces methode malheuresement ca n as pa fonctionne (NB mon ficheir d'OUT est d extension .csv est ce que ce type de fichier doivent avoir un autre traitement )
sinon j ai essaye un code propore a moi aussi ca na fais la tache tache sur le console il m'affiche le message suivant
Use of uninitialized value in concatenation (.) or string at ./test.pl line 68, <FILE> line 984.
si vous vouvez mon code je suis a vous disposition

[Philou67430]

Sans avoir le code sous les yeux, ça va être franchement difficile

[helkha86]

cette erreur est du qu'un ligne est debuté par 0 donc qd j ai ajouter cette instruction ca bien marcher, sinon je recupre tjr pas les infos dans le fichier de sortie
if ($LINE =~ /^\d*/)
{
next;
}

[helkha86]

my $file = $ARGV[0];
my ($LINE,$i,$TIMESTAMP,$AUTHOR ,$CHECKS_TYPE);
my $where = `pwd`;
my @file =();
my @resul=();
chomp ($where);
$TIMESTAMP = `date`;
chomp($TIMESTAMP);
$AUTHOR = `whoami`;
chomp($AUTHOR);
open(FILE,"<$file") || die "ERROR: the file $file not found\n";
open(OUT,">$where/mon_ficheir.csv") || die "ERROR: the file $file not found\n";
print OUT "Creation Date:$TIMESTAMP\n";
print OUT "Author:$AUTHOR\n";
print OUT "\n,,"; # Add csv sep's for the date's


$LINE= <FILE>;


while(<FILE>){
# Ignore the underlines and blank lines:
if ($LINE =~ /^\s*-+\s*$/)
{
next;
}

if($LINE =~ /^\s*-+\s*$/ )
{
next;
}
# Ignire commented out line
if ($LINE =~ /^#.*$/ ) {
next;
}
# Ignorer la dernier ligne
if ($LINE =~ /^\d*/)
{
next;
}
($CHECKS_TYPE = "$1") if ($LINE =~ /^\s*(nom)\s*$/);
($CHECKS_TYPE = "$1") if ($LINE =~ /^\s*(prenom)\s*$/);
($CHECKS_TYPE = "$1") if ($LINE =~ /^\s*(numtel\s*$/);
push( @resul, $CHECKS_TYPE);
}

for($i=0;$i<$#resul+1;$i++)
{
print OUT "$resul[$i]\n";
}

close FILE;
close OUT;