帮助遍历/排序复杂的 Perl 数据结构（HoH with AoH fun）

【问题标题】：Help with walking / sorting a complex Perl data structure (HoH with AoH fun)帮助遍历/排序复杂的 Perl 数据结构（HoH with AoH fun）
【发布时间】：2011-08-17 21:51:06
【问题描述】：

我已经用头撞墙了几个小时了。

我有一个看起来像这样的数据结构（来自“Data::Dumper”的输出）。这是我自己的错，我在解析一些输入时创建了数据结构。

print Dumper $data;

___OUTPUT___
$VAR = { 'NAME' => {
                    'id' => '1234',
                    'total' => 192,
                    'results' =>  { 
                                     'APPLE'   => 48 ,
                                     'KUMQUAT' => 61 ,
                                     'ORANGE'  => 33 ,
                                  }
                   }

       }
  • 有数千个“NAME”键。
  • 只有一个“id”和一个“total”。
  • “结果”哈希中可能有一个或多个键/值对。

我想打印一个逗号分隔的列表，首先按“total”排序，然后按“results”数组中每个散列的值排序。

以下代码用于从已存储的数据结构中打印出 CSV。

use strict;
use warnings;
# [...lots of other stuff...]

open (my $fh, >out.csv);
print $fh "Name, ID, Label, Count, Total\n";

foreach ( sort { $data->{$b}->{total} <=> $data->{$a}->{total} }
    keys %{$data} )
{
    my $name = $_;
    foreach (
        sort {
            $data->{$name}->{results}->{$a} <=> $data->{$name}->{results}
              ->{$b}
        } values %{ $data->{$name}->{results} }
      )
    {

        print $fh $name . ","
          . $data->{$name}->{id} . "," . "'"
          . $_ . ","
          . $data->{$name}->{results}->{$_} . "," . "\n";
    }
    print $fh $name . ","
      . $data->{$name}->{id} . "," . "," . ","
      . $data->{$name}->{total} . "\n";
}

close($fh);

这很好，效果很好（除了提醒我为什么不再使用 Perl）。

示例输出如下：

Name, ID,  Label,   Count, Total
foo, 1234, ORANGE,    33,
foo, 1234, APPLE,     48,
foo, 1234, KUMQUAT,   61,
foo, 1234,     ,        ,  142
bar, 1101, BIKE,      20,
bar  1101,     ,        ,  20

但是！我注意到我遇到了关键冲突（在“结果”哈希中），由于我需要保留并报告所有数据，我决定尝试将“结果”更改为哈希数组......

print Dumper $data;

___OUTPUT___
$VAR = { 'NAME' => {
                    'id' => '1234',
                    'total' => 192,
                    'results' => [
                                   { 'APPLE'   => 48 },
                                   { 'KUMQUAT' => 61 },
                                   { 'ORANGE'  => 33 },
                                   { 'APPLE'   => 50 },
                                 ]
                   }
       }
  • 有数千个“NAME”键。
  • 只有一个“id”和一个“total”。
  • “结果”数组中可能有一个或多个哈希值。
  • “results”数组中的每个哈希都只有一个名称/值对。

不管有没有人读到这里，我不得不说写下来是相当有治疗作用的，所以我会继续……;-)

对于新的数据结构，排序/打印代码有问题。

use strict;
use warnings;
# [...lots of other stuff...]

open (my $fh, >out.csv);
print $fh "Name, ID, Label, Count, Total\n";

foreach ( sort { $data->{$b}->{total} <=> $data->{$a}->{total} }
    keys %{$data} )
{
    my $name = $_;
    foreach (
        sort {
            $data->{$name}->{results}->{$a} <=> $data->{$name}->{results}
              ->{$b}
        } values %{ $data->{$name}->{results} }
      )
    {
    # .... HELP ME FOR THE LOVE OF ALL THAT IS GOOD IN THE WORLD! ....
    # I'm at the point now where my brain is starting to slowly dribble from my
    # ears...
    }
    print $fh $name . "," 
      . $data->{$name}->{id} . "," . "," . ","
      . $data->{$name}->{total} . "\n";
}

close($fh);

如果你已经读到这里，我向你致敬。 如果你能帮忙，我为你鼓掌。

如果有人对数据结构的替代格式有任何建议，请告诉我！ （如果您有兴趣......我正在使用“触发器”运算符来捕获源文件的块，然后我使用这些块逐行创建数据结构。我也调用外部计算某些东西的程序（没有 Perl 等价物）并存储结果。）

谢谢

【问题讨论】：

  • 当你说有 1000 个 NAME 键时，我假设你的意思是每个都是一个唯一的名称，否则，数据结构是不可能的
  • 如果我理解正确，您使用 perl 收集数据，将其存储在 perl 变量中，然后在完成后您希望将此数据打印到排序的 CSV 文件？您真的需要在打印之前存储数据吗？
  • @stevecomrie - 是的，我将变量变量放在 CAPS 中的数据结构输出中......
  • @TLP - 我想过这个......由于我捕获数据的方式，我认为这有点棘手。另外，如果我逐行打印，如何对输出进行排序？
  • 嗯，一旦在文件中，就可以用excel来排序了。

标签： perl perl-data-structures


【解决方案1】：

好的，我只想说一次：结构复杂时总是使用对象

正如您所发现的，您的大脑会在尝试跟踪哈希数组的哈希数组时爆炸。这是创建对象结构的完美理由。如果你永远不会重复使用它也没关系。它使您的编程任务变得容易得多。

以下包花了我大约 30 分钟来编写和调试。如果你使用它，你会为自己省去很多心痛和调试。

作为奖励，当您发现您的错误假设（嘿，每个人都这样做！）您的 RESULT 数组中有多个具有相同键的项目时，您只需修改几行即可轻松定位代码尝试将所有内容保持在一起的整个程序。

我使用了您的数据结构，除了我将 RESULTS 设为一个数组，该数组包含一个包含两个项目（标签和数量）而不是哈希的数组。我本可以使用哈希，但是这样，我可以返回一个包含两个项目的数组。现在，我想起来，无论如何都没有理由这样做。

#! /usr/bin/env perl

use warnings;
use strict;
use feature qw(say);
use Data::Dumper;


my %hash;
my $obj;

$obj = structure->new();
$obj->Name("foo");
$obj->Total("foo", 142);
$obj->Id("foo", 1234);
$obj->Push(qw(foo  ORANGE  33));
$obj->Push(qw(foo  APPLE   48));
$obj->Push(qw(foo  APPLE   50));
$obj->Push(qw(foo  KUMQUAT 61));
$obj->SortResults("foo");

$obj->Name("bar");
$obj->Total("bar", 20);
$obj->Id("bar", 1100);
$obj->Push(qw(bar BIKE    20));
$obj->SortResults("bar");

say Dumper($obj);
exit 0;

########################################################################
package structure;

use Data::Dumper;

#
# New Structure containing all data
# 
sub new {
    my $class = shift;

    my $self = {};

    bless $self, $class;
    return $self;
}

#
# Either adds a new name object or returns name object;
#
sub Name {
    my $self = shift;
    my $name = shift;

    if (not defined $self->{$name}) {
        $self->{$name}->{ID} = undef;
        $self->{$name}->{TOTAL} = undef;
        $self->{$name}->{RESULTS} = [];
    }
    return $self->{$name};
}

#
# Returns a list of Names
#
sub NameList {
    my $self = shift;

    return keys %{$self};
}
#
# Either returns the id or sets $name's id
#
sub Id {
    my $self = shift;
    my $name = shift;
    my $id = shift;

    my $nameObj = $self->Name($name);
    if (defined $id) {
        $nameObj->{ID} = $id;
    }
    return $nameObj->{ID};
}

#
# Either returns the total for $name or sets $name's total
#
sub Total {
    my $self = shift;
    my $name = shift;
    my $total = shift;

    my $nameObj = $self->Name($name);
    if (defined $total) {
        $nameObj->{TOTAL} = $total;
    }
    return $nameObj->{TOTAL};
}

#
# Pushes new product and amount on $name's result list
#
sub Push {
    my $self = shift;
    my $name = shift;
    my $product = shift;
    my $amount = shift;

    my $nameObj = $self->Name($name);
    my @array = ("$name", "$amount");
    push @{$nameObj->{RESULTS}}, \@array;
    return @array;
}

#
# Pops product and amount on $name's result list
#
sub Pop {
    my $self = shift;
    my $name = shift;

    my $nameObj = $self->Name($name);
    my $arrayRef = pop @{$nameObj->{RESULTS}};
    return @{$arrayRef};
}

sub SortResults {
    my $self = shift;
    my $name = shift;

    my $nameObj = $self->Name($name);
    my @results = @{$nameObj->{RESULTS}};
my @sortedResults = sort {$a->[1] <=> $b->[1]} @results;
my $nameObj->{RESULTS} = \@sortedResults;
    return @sortedResults;
}

$obj-&gt;SortResults 将对结果进行就地排序，但无论如何您都可以使用它将结果作为排序列表检索。要按总计对项目进行排序，您可以使用：

my @sortedItems = sort {$obj->Total($a) <=> $obj->Total($b)} $obj->NameList();

简而言之，您可以节省自己的时间和清洁女工清理的烂摊子。 （爆炸的大脑很难从墙壁和天花板上擦掉）。

我从经验中了解到，每当您开始谈论包含指向其他散列的数组的散列的散列时，就该创建一个对象来处理混乱了。为这些类型的一次性工作创建对象似乎需要更长的时间，但根据我的经验，您通常可以在 30 分钟内大量制作所需内容并进行测试，这样可以节省您日后数小时的挫败感。

【讨论】：

  • 感谢大卫。我真的很感激你为此付出的时间。如果您知道我的意思，我认为您肯定只是“教人钓鱼”！欢呼
  • 不到一个小时后，我完成了脚本，并在此过程中学到了很多关于 OO Perl 的知识。再次感谢您对此的帮助。我将来肯定会重新使用这种方法！ （我不是专业的程序员，我只是天生懒惰，并尝试在可能的情况下使东西自动化）。非常感谢。如果我能更多地支持你，我会的！
【解决方案2】： 
use strict;
use warnings;
# [...lots of other stuff...]

open (my $fh, '>', 'out.csv');
print $fh "Name, ID, Label, Count, Total\n";

my $data = {
    'NAME' => {
        'id' => '1234',
        'total' => 192,
        'results' => [
            { 'APPLE'   => 48 },
            { 'KUMQUAT' => 61 },
            { 'ORANGE'  => 33 },
            { 'APPLE'   => 50 },
        ]
    }
};

# sort names by total, descending
for my $name ( sort { $data->{$b}{total} <=> $data->{$a}{total} } keys %{$data} )
{
    # sort results by count, ascending; is this what you want?
    for my $result ( sort { (%$a)[1] <=> (%$b)[1] } @{ $data->{$name}{results} } ) {
        my ($label, $count) = %$result;
        print $fh join(',', $name, $data->{$name}{id}, $label, $count, ''), "\n";
    }
    print $fh join(',', $name, $data->{$name}{id}, '', '', $data->{$name}{total}), "\n";
}

close($fh);

【讨论】：

  • 我自己的内部 Perl 解释器表明这是一个...我明天将进行测试并报告。非常感谢！
【解决方案3】：

您可能可以使用这样的数据结构来减少一层复杂性：

$VAR = [
         {
           'name' => 'foo',
           'id' => '1234',
           'total' => 192,
           'results' => [
                          { 'label' => 'APPLE', 'score' => 48 },
                          { 'label' => 'KUMQUAT', 'score' => 61 },
                          { 'label' => 'ORANGE', 'score' => 33 },
                          { 'label' => 'APPLE', 'score' => 50 },
                        ]
         },
       ];

所以，如果我记得我的 Perl，你会看到类似的东西：

foreach my $row ( sort( $a->{'total'} <=> $b->{'total'} ) @data ) {

    foreach my $result ( sort( $a->{'score'} <=> $b->{'score'} ) @{$row->{'results'}} ) {

    }

}

【讨论】：

  • 嗨史蒂夫 - 我没有考虑过那个数据结构。我可以看到这会更容易。感谢您的建议 - 谢谢
  • 我喜欢它，因为它保持简单。一个哈希数组，其中每个值要么是一个字符串，要么是另一个哈希数组。
猜你喜欢
  • 1970-01-01
  • 2020-06-24
  • 1970-01-01
  • 2012-04-21
  • 1970-01-01
  • 2011-09-26
  • 1970-01-01
  • 1970-01-01
  • 2019-04-09
相关资源
最近更新 更多
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode