Sortierung nach Array (solved) (Allgemeines zu Perl)

[thread]18011[/thread]

Sortierung nach Array [solved]

Tags: perl5 hash Array sortieren Similar Threads

Readers: 23

Articles: hide open all | hide show old branches

+19 replies

bianca

2012-12-25 18:11

User since
2009-09-13
7016 articles
BenutzerIn

user image

Guten Abend und noch ein schönes Restweihnachtsfest!
Ich möchte im Script einen Hash, der als mehrspaltige Tabelle aufgebaut ist sortiert ausgeben. Dabei habe ich Sortierreihenfolge, Art der Felder und die jeweilige Richtung pro Spalte in jeweils einem Array.
Meine erste Idee war eine Schleife innerhalb von {sort}. Aber irgendwie dachte ich mir schon, dass das nicht so einfach wird.
Hier mein Versuch und weitere Details:

Code (perl): (dl )

#!/usr/bin/perl -w
use strict;
use warnings;

my %uebergabe = (
    data    => {
        1   => {
            1   => 'aaron',
            2   => 'suppe',
            3   => 10,
        },
        2   => {
            1   => 'aaron',
            2   => 'zander',
            3   => 20,
        },
        3   => {
            1   => 'hannes',
            2   => 'zander',
            3   => 20,
        },
    },
    art             => ['a','a','n'],   # Art der Spalte a=Alpha oder n=Nummer
    sortierprio     => [1,2,3],         # Erst nach Spalte 1, dann nach 2, dann nach 3
    sortierricht    => [1,0,1],         # Sortierrichtung 0=abwärts/rückwärts oder 1=aufwärts/vorwärts
);
tabellenhandler(\%uebergabe);

###############################################################################

sub tabellenhandler {
    my ($input) = @_;
    foreach my $zeile (
        sort {
            for (my $sp_sort = 0; $sp_sort < scalar @{$input->{sortierprio}}; $sp_sort ++) {
                if ($input->{sortierricht}[$sp_sort]) {
                    if ($input->{art}[$sp_sort] eq 'n') {
                        $input->{data}{$a}{$input->{sortierprio{$sp_sort}}} <=> $input->{data}{$b}{$input->{sortierprio{$sp_sort}}}
                    }
                    else {
                        $input->{data}{$a}{$input->{sortierprio{$sp_sort}}} cmp $input->{data}{$b}{$input->{sortierprio{$sp_sort}}}
                    }
                }
                else {
                    if ($input->{art}[$sp_sort] eq 'n') {
                        $input->{data}{$b}{$input->{sortierprio{$sp_sort}}} <=> $input->{data}{$a}{$input->{sortierprio{$sp_sort}}}
                    }
                    else {
                        $input->{data}{$b}{$input->{sortierprio{$sp_sort}}} cmp $input->{data}{$a}{$input->{sortierprio{$sp_sort}}}
                    }
                }
            }
        }
        keys %{$input->{data}}
    ) {
        print "Zeile:";
        foreach my $spalte (
            keys %{$input->{data}{$zeile}}
        ) {
            print " - ".$input->{data}{$zeile}{$spalte};
        }
        print "\n";
    }
}

Fehlermeldungen:

Quote
Useless use of numeric comparison (<=>) in void context at sub_tabellenhandler.pl line 38.
Useless use of string comparison (cmp) in void context at sub_tabellenhandler.pl line 41.
Useless use of numeric comparison (<=>) in void context at sub_tabellenhandler.pl line 46.
Useless use of string comparison (cmp) in void context at sub_tabellenhandler.pl line 49.
Can't call method "sortierprio" without a package or object reference at sub_tabellenhandler.pl line 41.

Verliert also den Zusammenhang zwischen dem sort{} Block und dem $a/$b.
Wie muss die Syntax richtig lauten?
Bei diesen Variablen erwarte ich in der Reihenfolge die Ausgabe der Zeilen 2, 1, 3, weil in Zeile 1 und 2 aaron zwar gleich sind aber deren Spalten 2 unterschiedlich und rückwärts sortiert sein sollen, also zander vor suppe.
Danke euch

Editiert von bianca: Code korrigiert, ändert aber die Fehlermeldungen nicht
Last edited: 2012-12-25 18:24:08 +0100 (CET)

10 print "Hallo"
20 goto 10

+6 replies
Muffi

2012-12-25 20:43

User since
2012-07-18
1465 articles
BenutzerIn

Der Code in einem sortblock sollte -1, 0 oder 1 zurückliefern.
Und zurückliefern sollt mit return gehn.
1 + 1 = 10
- +2 replies
- bianca
  
  2012-12-26 07:29
  
  User since
  2009-09-13
  7016 articles
  BenutzerIn
  
  OK, und wie nehme ich Bezug auf $a und $b? Also wie stelle ich den Vergleich an? Laut Fehlermeldung hat Perl ja an der Stelle wo ich es verwende den Bezug zum sort verloren.
  10 print "Hallo"
  20 goto 10
  - Muffi
    
    2012-12-26 09:02
    
    User since
    2012-07-18
    1465 articles
    BenutzerIn
    
    Welche Fehlermeldung meinst du genau?
    Die "void context" heissen, dass du was aufrufst, z.b. cmp, was ein Ergebnis zurückliefert, aber dich interessierts nicht. Von $a und $b les ich da nichts.
    1 + 1 = 10
- +3 replies
- bianca
  
  2012-12-26 13:26
  
  User since
  2009-09-13
  7016 articles
  BenutzerIn
  
  Sorry, ich raff es nicht.
  Also nochmal in Textform: Ich möchte nach allen drei Spalten sortieren. Wenn es immer drei Spalten wären würde ich also die Sortierungen mit || verknüpfen. Da die Spaltenzahl aber variiert habe ich eine Schleife drum gebaut, weil ich keine andere Möglichkeit weiß.
  Wie kann ich denn jetzt nur ein -1, 0 oder 1 zurückgeben, wenn ich doch nach allen drei Spalten sortieren will?
  10 print "Hallo"
  20 goto 10
  - +2 replies
  - murphy
    
    2012-12-26 15:16
    User since
    2004-07-19
    1776 articles
    HausmeisterIn
    
    Nach n Spalten zu sortieren heißt eigentlich, nach der ersten Spalte zu sortieren und Einträge bei denen die Werte in der ersten Spalte gleich sind nach den verbleibenden n-1 Spalten zu sortieren.
    
    In Code für einen Vergleichsoperator zwischen zwei Arrayreferenzen übersetzt:
    
    Code (perl): (dl )
    
    1 2 3 4 5 6 7 8 9 10
    
    use List::Util qw(min); sub arraycmp { my ($a, $b) = @_; for my $_ (0 .. min($#$a, $#$b)) { my $d = $a->[$_] <=> $b->[$_]; return $d unless $d == 0; } return 0; }
    
    When C++ is your hammer, every problem looks like your thumb.
    - bianca
      
      2012-12-26 15:37
      
      User since
      2009-09-13
      7016 articles
      BenutzerIn
      
      Und mein Code geht nach der Logik "gehe durch die Spalten von links nach rechts bis unterschiedliche Werte gefunden werden und sortiere danach".
      Finde ich an sich einigermaßen logisch. Frage ist nur, ob man das üblicherweise (best practice) so macht und ob das effizient ist.
      Edit: Sorry, sehe jetzt, dass das deine Antwort auf mein Nichts-Raff war. Bitte schau dir mal meinen Code unten an, ob das OK ist.
      10 print "Hallo"
      20 goto 10
+12 replies

bianca

2012-12-26 15:07

User since
2009-09-13
7016 articles
BenutzerIn

user image

Ich glaube, nun habe ich es doch geschnackelt.
Scheint soweit zu funktionieren.
Gibt es von euch Optimierungsvorschläge?
Ist das überhaupt korrekt, wie ich das gemacht habe oder fliegt das bei ein paar mehr Datensätzen durch die Luft? :)

Code (perl): (dl )

#!/usr/bin/perl -w
use strict;
use warnings;

my %uebergabe = (
    data    => {
        1   => {
            1   => 'aaron',
            2   => 'suppe',
            3   => 10,
        },
        2   => {
            1   => 'aaron',
            2   => 'zander',
            3   => 20,
        },
        3   => {
            1   => 'hannes',
            2   => 'zander',
            3   => 20,
        },
    },
    art             => ['a','a','n'],   # Art der Spalte a=Alpha oder n=Nummer
    sortierprio     => [3,2,1],         # Nummer der Spalte in der Reihenfolge der Sortierung
    sortierricht    => [1,1,1],         # Sortierrichtung 0=abwärts/rückwärts oder 1=aufwärts/vorwärts
);
tabellenhandler(\%uebergabe);

###############################################################################

sub tabellenhandler {
    my ($input) = @_;
    foreach my $zeile (
        sort {
            my $return = 0;
            my $spalte = -1;
            while (!$return && $spalte < scalar @{$input->{sortierprio}}) {
                $spalte ++;
                my $vergleich_spalte = $input->{sortierprio}[$spalte];
                if ($input->{sortierricht}[$vergleich_spalte - 1]) {
                    if ($input->{art}[$vergleich_spalte - 1] eq 'n') {
                        $return = $input->{data}{$a}{$vergleich_spalte} <=> $input->{data}{$b}{$vergleich_spalte};
                    }
                    else {
                        $return = $input->{data}{$a}{$vergleich_spalte} cmp $input->{data}{$b}{$vergleich_spalte};
                    }
                }
                else {
                    if ($input->{art}[$vergleich_spalte - 1] eq 'n') {
                        $return = $input->{data}{$b}{$vergleich_spalte} <=> $input->{data}{$a}{$vergleich_spalte};
                    }
                    else {
                        $return = $input->{data}{$b}{$vergleich_spalte} cmp $input->{data}{$a}{$vergleich_spalte};
                    }
                }
            }
            $return;
        }
        keys %{$input->{data}}
    ) {
        print "Zeile:";
        foreach my $spalte (
            sort {$a <=> $b}
            keys %{$input->{data}{$zeile}}
        ) {
            print " - ".$input->{data}{$zeile}{$spalte};
        }
        print "\n";
    }
}

10 print "Hallo"
20 goto 10

+6 replies
murphy

2012-12-26 16:11

User since
2004-07-19
1776 articles
HausmeisterIn

Der Code sieht korrekt aus, wenn auch ein wenig umständlich und unübersichtlich.

Ich finde zum Beispiel, dass Schleifen der Form for my $VAR (0 .. $BOUND) klarer lesbar sind als while-Schleifen mit manuellem Zählermanagement. Und eine Steuerung der Sortierrichtung könnte man beispielsweise elegant durch Multiplikation des Vergleichsergebnisses mit +1 oder -1 erreichen.

Übrigens verstehe ich auch nicht ganz, warum die Daten in Hashes mit numerischen Schlüsseln abgelegt sind. Wären da nicht vielleicht Arrays sinnvoller?
When C++ is your hammer, every problem looks like your thumb.
- +5 replies
- bianca
  
  2012-12-26 16:20
  
  User since
  2009-09-13
  7016 articles
  BenutzerIn
  
  2012-12-26T15:11:01 murphy
  Der Code sieht korrekt aus, wenn auch ein wenig umständlich und unübersichtlich.
  
  Wie würde es bei dir aussehen?
  
  2012-12-26T15:11:01 murphy
  Ich finde zum Beispiel, dass Schleifen der Form for my $VAR (0 .. $BOUND) klarer lesbar sind als while-Schleifen mit manuellem Zählermanagement.
  
  Ich finde die klare Darstellung der Laufbedingung so schön an dieser Syntax. Bei for müsste ich nach der ersten Spalte mit Unterschied mittels last abbrechen. Da mir aber die Laufbedingung hier wichtiger ist als das Durchzählen (im Optimalfalle läuft der Inhalt des while nur einmal je Zeile) habe ich es so geschrieben. Ist wohl Geschmacksache.
  
  2012-12-26T15:11:01 murphy
  Und eine Steuerung der Sortierrichtung könnte man beispielsweise elegant durch Multiplikation des Vergleichsergebnisses mit +1 oder -1 erreichen.
  
  Das verstehe ich garnicht. Wie meinst du das?
  
  2012-12-26T15:11:01 murphy
  Übrigens verstehe ich auch nicht ganz, warum die Daten in Hashes mit numerischen Schlüsseln abgelegt sind. Wären da nicht vielleicht Arrays sinnvoller?
  
  Ob das so bleibt, weiß ich noch nicht. War jetzt mal ein Einstieg.
  10 print "Hallo"
  20 goto 10
  - +4 replies
  - murphy
    
    2012-12-26 17:59
    User since
    2004-07-19
    1776 articles
    HausmeisterIn
    
    Bei mir sähe es in etwa so aus:
    
    Code (perl): (dl )
    
    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
    
    use 5.012; use warnings; use constant { # Common collation sequences ALPHA => sub { my ($a, $b) = @_; $a cmp $b }, NUMERIC => sub { my ($a, $b) = @_; $a <=> $b }, # Sort orders ASC => +1, DSC => -1 }; # Multicolumn sort function. # Params: # $columns = Arrayref of sort column definitions in priority order. # Each column definition is a hashref with the keys # index => Column index in the data rows # collate => Binary subref defining collation order # order => ASC for ascending or DSC for descending order # $data = Arrayref of data rows # Returns: # Arrayref of sorted data rows sub multisort { my ($columns, $data) = @_; [sort { for my $column (@$columns) { my $d = $column->{order} * $column->{collate}->($a->[$column->{index}], $b->[$column->{index}]); return $d unless $d == 0; } } @$data]; } # Runnable example: my @data = ( ['aaron', 'zander', 20], ['hannes', 'zander', 20], ['aaron', 'suppe', 10], ); my @columns = ( {index => 2, collate => NUMERIC, order => ASC}, {index => 1, collate => ALPHA, order => ASC}, {index => 0, collate => ALPHA, order => ASC}, ); use Data::Dumper; print Dumper multisort(\@columns, \@data);
    
    When C++ is your hammer, every problem looks like your thumb.
    - +3 replies
    - bianca
      
      2012-12-29 14:54
      
      User since
      2009-09-13
      7016 articles
      BenutzerIn
      
      2012-12-26T16:59:39 murphy
      Bei mir sähe es in etwa so aus:
      Sieht schlank aus. Danke für die Inspiration. Diese constant Geschichte könnte ich in einem anderen Bereich nochmal überdenken und bringt mich auf ganz neue Gedanken.
      
      Eine Frage hierzu:
      
      2012-12-26T16:59:39 murphy
      
      Code (perl): (dl )
      
      1 2 3 4 5
      
      my @columns = ( {index => 2, collate => NUMERIC, order => ASC}, {index => 1, collate => ALPHA, order => ASC}, {index => 0, collate => ALPHA, order => ASC}, );
      
      Was genau passiert im Moment der Zuweisung von collate => zu NUMERIC?
      Wenn ich diese Zuweisung in einem Hauptprogramm mache, wo die Sortierroutine noch garnicht vorhanden ist wird das nicht klappen, oder?
      
      Wichtig ist mir wirklich die Kapselung. Das Hauptprogramm bestückt ein Hash, gibt den an meinen tabellenhandler und bekommt fertigen HTML Code zurück. Ziel: In vielen Modulen immer und immer wieder den selben Perlcode einzustampfen in eine sub.
      
      Wie würdest du das lösen, wenn das streng in einer Richtung abhängig sein soll?
      Last edited: 2012-12-29 14:56:28 +0100 (CET)
      10 print "Hallo"
      20 goto 10
      - Muffi
        
        2012-12-29 22:25
        
        User since
        2012-07-18
        1465 articles
        BenutzerIn
        
        Perl hat keine wirklichen Konstanten. Der legt da einfach ne sub an.
        Und subs von ausserhalb kannst du erreichen per Package::subname
        1 + 1 = 10
      - murphy
        
        2012-12-30 17:03
        
        User since
        2004-07-19
        1776 articles
        HausmeisterIn
        
        Der Code
        
        Code (perl): (dl )
        
        {index => 2, collate => NUMERIC, order => ASC}
        
        erzeugt eine anonyme Hashreferenz, die unter anderem den Schlüssel 'collate' auf den Wert abbildet, welchen der Subroutinenaufruf NUMERIC() zurückgibt.
        
        Die Subroutine NUMERIC wurde zuvor mit Hilfe des Moduls constant erzeugt und gibt ihrerseits stets eine Subroutinenreferenz auf einen bestimmten Vergleichsoperator zurück.
        
        Der Code, der NUMERIC aufruft, muss natürlich diese Konstante bzw. spezielle Subroutine importiert haben. Möchte man das unbedingt vermeiden, so kann man stattdessen zum Beispiel den Sortiercode so abwandeln, dass er Strings in einem Hash nachschlägt.
        
        Hier eine Variante meines ursprünglichen Code, die diese Strategie verfolgt:
        
        Code (perl): (dl )
        
        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
        
        use 5.012; use warnings; my %collations = ( ALPHA => sub { my ($a, $b) = @_; $a cmp $b }, NUMERIC => sub { my ($a, $b) = @_; $a <=> $b }, ); my %orders = ( ASC => +1, DSC => -1 ); # Multicolumn sort function. # Params: # $columns = Arrayref of sort column definitions in priority order. # Each column definition is a hashref with the keys # index => Column index in the data rows # collate => Collation order # order => 'ASC' for ascending or 'DSC' for descending order # $data = Arrayref of data rows # Returns: # Arrayref of sorted data rows sub multisort { my ($columns, $data) = @_; [sort { for my $column (@$columns) { my $order = $orders{$column->{order}} or die 'illegal sort order ' . $column->{order}; my $collate = $collations{$column->{collate}} or die 'illegal collation sequence ' . $column->{collate}; my $index = $column->{index}; my $d = $order * $collate->($a->[$index], $b->[$index]); return $d unless $d == 0; } } @$data]; } # Runnable example: my @data = ( ['aaron', 'zander', 20], ['hannes', 'zander', 20], ['aaron', 'suppe', 10], ); my @columns = ( {index => 2, collate => 'NUMERIC', order => 'ASC'}, {index => 1, collate => 'ALPHA', order => 'ASC'}, {index => 0, collate => 'ALPHA', order => 'ASC'}, ); use Data::Dumper; print Dumper multisort(\@columns, \@data);
        
        When C++ is your hammer, every problem looks like your thumb.
+5 replies
Patterner

2012-12-26 20:46

User since
2007-01-02
25 articles
BenutzerIn

Was evtl. noch eine Alternative wäre: dynamisch Funktionen aufbauen die dann zum Sortieren benutzt werden (sowas wie *mysort = sub { $_[0] cmp $_[1]} :)
“I’m working on it.”
- +4 replies
- murphy
  
  2012-12-26 21:04
  
  User since
  2004-07-19
  1776 articles
  HausmeisterIn
  
  Wenn Du Dir meinen letzten Beitrag mal anschaust, wirst Du sehen dass ich genau das tue um die verschiedenen Datentypen zu abstrahieren, so dass der gesamte Code dann deutlich kürzer wird und mit weniger expliziten Fallunterscheidungen auskommt.
  When C++ is your hammer, every problem looks like your thumb.
  - +3 replies
  - Patterner
    
    2012-12-27 16:12
    User since
    2007-01-02
    25 articles
    BenutzerIn
    
    Ich habe mich nicht klar genug ausgedrückt... Ich dache eher an sowas wie
    
    Code (perl): (dl )
    
    1 2 3 4 5 6
    
    my $sub = 'sub { my ($a, $b) = @_; '; if ($type == NUMERIC) { $sub .= ' $a <=> $b '; } else ... $sub .= '}'; my $sortSub = eval $sub;
    
    (ungetestet...)
    “I’m working on it.”
    - murphy
      
      2012-12-28 02:08
      
      User since
      2004-07-19
      1776 articles
      HausmeisterIn
      
      Ich sehe zwar keinen Sinn darin eval zu benutzen um Code dynamisch zusammenzubauen, den man genausogut auch statisch hinschreiben könnte ohne das Programm komplizierter zu machen (eher im Gegenteil), aber möglich ist natürlich auch das :-)
      When C++ is your hammer, every problem looks like your thumb.
    - bianca
      
      2012-12-29 14:58
      
      User since
      2009-09-13
      7016 articles
      BenutzerIn
      
      Auch danke für diese Inspiration. Ich hatte letztens den Fall, dass ich mir gewünscht hätte, dynamischen Code bauen zu können.
      Aber das hatte sich dann als falsches Anwendungsgebiet dafür herausgestellt. pq war es glaube ich, die mich da auf den Boden zurück geholt hat :)
      Würde an sich gern auf soetwas verzichten, wenn es nicht ungedingt sein muss.
      10 print "Hallo"
      20 goto 10

View all threads created 2012-12-25 18:11.