CSV dans hachage

J'ai un fichier csv avec la première colonne d'une étiquette suivie de valeurs séparées par des virgules:

LabelA,45,56,78,90
LabelB,56,65,43,32
LabelC,56,87,98,45

J'aimerais que la première colonne (LabelA etc) à la Clé dans une table de hachage avec les valeurs numériques dans un tableau.

Je peux lire le fichier dans un tableau ou un scalaire, mais je ne suis pas sûre de savoir quoi faire après. Des Suggestions??

Edit:
Ok, donc il semble que cela affecte la valeur à une clé ..mais qu'en est délimité par des virgules, les numéros dans mon exemple? Où vont-ils? Sont-ils en %de hachage ? Si oui, pourriez-vous abrutir votre explication encore plus loin? Merci.

depesz est la création d'une table de Hachage de Tableaux. Essayez de lire le perldsc lien que je vous ai donné. C'est le "Structures de Données" livres de cuisine, et il y a une section sur le travail avec des tables de hachage de Tableaux, que j'ai aussi lié pour vous dans mon post. La section sur la Génération de HoA a un exemple qui est très similaire à ce que vous demandez.

OriginalL'auteur RH. | 2009-06-18

hash perl

7

Eh bien, supposons qu'il n'existe pas de caractères spéciaux et ainsi de suite.

D'abord d'ouvrir le fichier:
```
open my $fh, '<', 'some.file.csv' or die "Cannot open: $!";
```
Puis vous lire en boucle:
```
while (my $line = <$fh>) {
```
Par la suite, vous la retirez de fuite des caractères blancs (\n et les autres):
```
$line =~ s/\s*\z//;
```
Et de le diviser en tableau:
```
my @array = split /,/, $line;
```
Quand il est dans la gamme, vous obtenez un premier élément hors de la matrice:
```
my $key = shift @array;
```
Et de le stocker dans de hachage:
```
$hash{$key} = \@array;
```
(\@tableau fait référence à la matrice).

Code entier:
```
my %hash;
open my $fh, '<', 'some.file.csv' or die "Cannot open: $!";
while (my $line = <$fh>) {
  $line =~ s/\s*\z//;
  my @array = split /,/, $line;
  my $key = shift @array;
  $hash{$key} = \@array;
}
close $fh;
```
Ok, donc il semble que cela affecte la valeur à une clé ..mais qu'en est délimité par des virgules, les numéros dans mon exemple? Où vont-ils? Sont-ils en %de hachage ? Si oui, pourriez-vous abrutir votre explication encore plus loin? Merci.
Eh bien, cette ligne: $hash{$key} = \@tableau; met les valeurs de hachage. Vous pouvez ajouter: utiliser Data::Dumper; print Dumper(\%hash); à la fin du programme pour voir comment la structure de données des regards.
Remarque à quelqu'un d'autre à l'aide de cette méthode: une ligne vide dans l'entrée CSV entraînera une paire clé/valeur de '' => undef. Pas de la faute de cette méthode, cela a un sens dans le contexte de ce code, juste quelque chose d'être conscient de, par exemple, si vous utilisez un fichier Excel CSV fichier qui a quelques lacunes en ligne (les lignes vides).

OriginalL'auteur

Personnellement, j'aime le Texte::CSV_XS et IO::File module:

use Text::CSV_XS;
use IO::File;

# Usage example:
my $hash_ref = csv_file_hashref('some_file.csv');

foreach my $key (sort keys %{$hash_ref}){
   print qq{$key: };
   print join q{,}, @{$hash_ref->{$key}};
   print qq{\n};
}

# Implementation:
sub csv_file_hashref {
   my ($filename) = @_;

   my $csv_fh = IO::File->new($filename, 'r');
   my $csv = Text::CSV_XS->new ();

   my %output_hash;

   while(my $colref = $csv->getline ($csv_fh))
   {
      $output_hash{shift @{$colref}} = $colref;
   }

   return \%output_hash;
}

Text::CSV est partie de la distribution standard. J'ai donc choisit d'utiliser ce. Juste enlever _XS de l'UTILISATION et le constructeur.

OriginalL'auteur Todd Gardner

1

Voir perlfunc split et perldsc.
1. Lire chaque ligne.
2. Chomp.
3. Diviser sur des virgules.
4. Utiliser la première valeur dans le résultat comme la clé de votre HoA.
5. Les autres valeurs du tableau.
6. Stocker une ref pour le tableau dans la table de hachage sous la clé.
7. ...
8. Profit!!!
Faire un hachage de références de tableau:

Votre structure de données devrait ressembler à ceci:
```
my %foo = (
    LabelA => [  2, 3,  56, 78, 90 ],
    LabelB => [ 65, 45, 23, 34, 87 ],
    LabelC => [ 67, 34, 56, 67, 98 ],
);
```
OriginalL'auteur daotoad

Text::CSV::Hashify

Tour d'un fichier CSV dans un Perl hash:

# Simple functional interface
use Text::CSV::Hashify;
$hash_ref = hashify('/path/to/file.csv', 'primary_key');

# Object-oriented interface
use Text::CSV::Hashify;
$obj = Text::CSV::Hashify->new( {
        file        => '/path/to/file.csv',
        format      => 'hoh', # hash of hashes, which is default
        key         => 'id',  # needed except when format is 'aoh'
        max_rows    => 20,    # number of records to read; defaults to all
        ... # other key-value pairs possible for Text::CSV
} );

# all records requested
$hash_ref       = $obj->all;

OriginalL'auteur Pablo Bianchi

0

Je pense que cela peut aussi faciliter le travail.

$Refhashvariable sera une référence à un tableau de hachages.

Chaque hash contient les en-têtes (comme hashkey) et les valeurs d'un CSV ligne.
Le tableau contient les valeurs de hachage pour toutes les lignes du fichier CSV.
```
use Text::CSV_XS qw( csv );
$refhashvariable = csv(
    in      => "$input_csv_filename",
    sep     => ';',
    headers => "auto"
);    # as array of hash
```
Cela fonctionne pour moi. Je n'ai pas essayé en cas le CSV n'a pas les en-têtes.

OriginalL'auteur Joniale

Vous devez vous connecter pour publier un commentaire.