Question

我对Perl编程有点陌生，我得到了一个哈希，可以这样表示：

$hash{"snake"}{ACB2}   = [70, 120];
$hash{"snake"}{SGJK}   = [183, 120];
$hash{"snake"}{KDMFS}   = [1213, 120];
$hash{"snake"}{VCS2}   = [21, 120];
...
$hash{"bear"}{ACB2}   = [12, 87];
$hash{"bear"}{GASF}   = [131, 87];
$hash{"bear"}{SDVS}   = [53, 87];
...
$hash{"monkey"}{ACB2}   = [70, 230];
$hash{"monkey"}{GMSD}   = [234, 230];
$hash{"monkey"}{GJAS}   = [521, 230];
$hash{"monkey"}{ASDA}   = [134, 230];
$hash{"monkey"}{ASMD}   = [700, 230];

哈希的结构总结如下：

%hash{Organism}{ProteinID}=(protein_length, total_of_proteins_in_that_organism)

我想根据某些条件对该哈希进行排序。首先，我只想考虑蛋白质总数大于100的那些生物，然后我要显示该生物的名称以及最大的蛋白质及其长度。

为此，我将采用以下方法：

    foreach my $org (sort keys %hash) {
        foreach my $prot (keys %{ $hash{$org} }) {
            if ($hash{$org}{$prot}[1] > 100) {
                @sortedarray = sort {$hash{$b}[0]<=>$hash{$a}[0]} keys %hash;

                print $org."\n";
                print @sortedarray[-1]."\n";
                print $hash{$org}{$sortedarray[-1]}[0]."\n"; 
            }
        }
    }

但是，它打印生物体名称的次数是蛋白质总数的多少倍，例如，它打印“蛇” 120次。此外，这排序不正确，因为我想我应该在排序行中使用变量$ org和$ prot。

最后，输出应如下所示：

snake
"Largest protein": KDMFS [1213]

monkey
"Largest protein": ASMD [700]

Answer 1

所有数据按打印顺序排序

use warnings;
use strict;
use feature 'say';

use List::Util qw(max);

my %hash;   
$hash{"snake"}{ACB2}   = [70, 120];
$hash{"snake"}{SGJK}   = [183, 120];
$hash{"snake"}{KDMFS}   = [1213, 120];
$hash{"snake"}{VCS2}   = [21, 120];
$hash{"bear"}{ACB2}   = [12, 87];
$hash{"bear"}{GASF}   = [131, 87];
$hash{"bear"}{SDVS}   = [53, 87];    
$hash{"monkey"}{ACB2}   = [70, 230];
$hash{"monkey"}{GMSD}   = [234, 230];
$hash{"monkey"}{GJAS}   = [521, 230];
$hash{"monkey"}{ASDA}   = [134, 230];
$hash{"monkey"}{ASMD}   = [700, 230];

my @top_level_keys_sorted = 
    sort {   
        ( max map { $hash{$b}{$_}->[0] } keys %{$hash{$b}} ) <=> 
        ( max map { $hash{$a}{$_}->[0] } keys %{$hash{$a}} )
    }   
    keys %hash;

for my $k (@top_level_keys_sorted) {
    say $k; 
    say "\t$_ --> @{$hash{$k}{$_}}" for 
        sort { $hash{$k}{$b}->[0] <=> $hash{$k}{$a}->[0] } 
        keys %{$hash{$k}};
}

这首先根据需求按arrayref值中的第一个数字对顶级键进行排序。有了排序的键列表，我们接下来进入每个键的hashref并进一步排序。该循环是我们根据需要调整输出的限制（总数前100个，长度最大等）。

它打印

snake
        KDMFS --> 1213 120
        SGJK --> 183 120
        ACB2 --> 70 120
        VCS2 --> 21 120
monkey
        ASMD --> 700 230
        GJAS --> 521 230
        GMSD --> 234 230
        ASDA --> 134 230
        ACB2 --> 70 230
bear
        GASF --> 131 87
        SDVS --> 53 87
        ACB2 --> 12 87

我无法确定输出结果是否应显示所有“ 蛋白质总数大于100 的生物”（文本）还是仅显示最大的一个（所需输出），所以我将全部保留它的。根据需要切断。要仅获取最大的值，请比较循环中每个键的最大值，或参见this post（相同的问题）。

请注意，哈希本身无法进行“排序”，因为它本质上是无序的。但是我们可以像上面那样打印出已排序的内容，或者根据需要生成可以排序的辅助数据结构。

Answer 2

您在使用

use strict;
use warnings;

在脚本的开头？这样至少可以突出一些问题的根源。没有它们，Perl会默默地做一些很容易指出是愚蠢，毫无意义甚至最有可能的编程错误的事情。

任务

$hash{"snake"}{ACB2}   = (70, 120);

仅会分配值120，因为该分配需要标量，但是左侧有很多值。

要分配arrayref，必须明确声明它：

$hash{"snake"}{ACB2}   = [70, 120];

您对信号（$，@，%）的使用似乎不正确。

如果要处理标量或单个数组或哈希值，请使用$。
如果要处理数组（或数组或哈希片（多个值）；请使用@，例如@array[0,2]将返回数组@array的第一项和第三项）。
如果要处理哈希，请使用%。

所以

@sortedarray[-1]

应该是

$sortedarray[-1]

因为您只访问一个值。

Answer 3

如果我对您的理解正确，那么下面的代码应该可以满足您的期望。我将结果保留在哈希表中，可以随意打印任何您想要的数据

use strict;
use warnings;

use Data::Dumper;

my $debug = 1;

my %data;
my $totalProteinsSearch = 100;

while( <DATA> ) {
    chomp;
    my @row = split ',';

    $data{$row[0]}{$row[1]} = { proteinLength => $row[2], totalProteins => $row[3] };
}

print Dumper(\%data) if $debug == 1;

my %result;

while( my($organism,$value) = each %data ) {
    while( my($proteinID, $data) = each %{$value} ) {
        next if $data->{totalProteins} < $totalProteinsSearch;
        $result{$organism} = {
                                proteinID => $proteinID,
                                proteinLength => $data->{proteinLength}, 
                                totalProteins => $data->{totalProteins} 
                            }
            if not defined $result{$organism}
                or 
            $data->{proteinLength} > $result{$organism}{proteinLength};
    }
}

print Dumper(\%result) if $debug;

__DATA__
snake,ACB2,70,120
snake,SGJK,183,120
snake,KDMFS,1213,120
snake,VCS2,21,120
bear,ACB2,12,87
bear,GASF,131,87
bear,SDVS,53,87
monkey,ACB2,70,230
monkey,GMSD,234,230
monkey,GJAS,521,230
monkey,ASDA,134,230
monkey,ASMD,700,230

例如，您可以打印信息，例如[关闭调试$debug = 0]

while( my($organism,$data) = each %result ) {
    printf "%s\nLargetst protein: %s [%d]\n\n",
            $organism, 
            $data->{proteinID},
            $data->{proteinLength};
}

Answer 4

您可以使用List::Util reduce来获取每个生物体的最大值。

我意识到您可能不熟悉List :: Util中的此功能，但是对于此问题的示例，它非常简单。

保存数据的结构的组成是以生物体为键的数组的哈希，存储在数组引用中的整行作为哈希的值。

数据结构的选择部分取决于所需输出的形式。

import boto3

s3 = boto3.resource('s3')
bucket = s3.Bucket('your-route')

# Data from S3 is also filtered by endswith from key property
for _ in bucket.objects.filter(Prefix=test_dir):
   if _.key.endswith('.zicu'):
      print('Value of object: ', _.key)

打印

#!/usr/bin/perl
use strict;
use warnings;
use List::Util qw/reduce/;

use constant {org_idx => 0, prot_idx => 1, len_idx => 2, cnt_idx => 3};

my %stuff;

while (<DATA>) {
    chomp;
    my @data = split /,/;

    # saving all 4 items (per line)
    # key is the organism
    push @{$stuff{$data[org_idx]}}, \@data; 
}

for my $org (sort keys %stuff) {
    my $aref = $stuff{$org}; # an array of arrays reference

    # to find the record with the max length
    # $max becomes an array reference containing all 4 of the items as a list
    my $max = reduce{$a->[len_idx] > $b->[len_idx] ? $a : $b} @$aref;

    next if $max->[cnt_idx] < 100;

    print $org, "\n";
    print "Largest protein: $max->[prot_idx] [$max->[len_idx]]\n";
}



__DATA__
snake,ACB2,70,120
snake,SGJK,183,120
snake,KDMFS,1213,120
snake,VCS2,21,120
bear,ACB2,12,87
bear,GASF,131,87
bear,SDVS,53,87
monkey,ACB2,70,230
monkey,GMSD,234,230
monkey,GJAS,521,230
monkey,ASDA,134,230
monkey,ASMD,700,230

Data :: monkey Largest protein: ASMD [700] snake Largest protein: KDMFS [1213]的转储者

%stuff

对具有多个条件的嵌套哈希进行排序

4 个答案: