Perličky: práce se seznamy

Seznamy, řezy a pole

Perlovský seznam je vektor obsahující nula nebo více skalárních veličin. Seznam lze zapsat pomocí klasické závorkové konstrukce, často se však používá operátor qw() nebo qw// (což ušetří zmáčknutí SHIFTu). Operátor qw zachází se svým vnitřkem, jako by byl v jednoduchých uvozovkách a vytvoří seznam rozsekáním podle prázdných znaků. Dalším častým operátorem jsou dvě tečky .., které umí „počítat po jednom“.

$a = 5;
(1, $a, "f")        # (1, 5, "f")
(1, ($a, "f"))      # totéž
qw/raz dva tři/        # ('raz', 'dva', 'tři')
2 .. 5          # (2, 3, 4, 5)
"A" .. "C"      # ("A", "B", "C")
()          # prázdný seznam, velice užitečný

K prvkům seznamu lze přistupovat pomocí indexů. Indexem může být skalár nebo opět seznam. Skalární indexy začínají na hodnotě nastavené $[, což je obvykle 0. Indexy menší než toto číslo značí indexování seznamu od jeho konce. V případě indexování seznamu seznamem vytvoříme takzvaný řez, což je seznam obsahující prvky původního seznamu na zadaných indexech. Indexy řezu začínají opět od hodnoty $[.

(1, $a, "f")[0]         # 1
(1, $a, "f")[-1]        # "f"
qw/ahoj děti/[1]       # 'děti'
(0 .. 9)[3 .. 5]        # ('3', '4', '5')
((0 .. 9)[3 .. 5])[-2]      # 4
qw/nastoupil vystoupil/[1, 0]   # ('vystoupil', 'nastoupil')

Perlovské pole (zapsáno @a) pomocí symbolu @ pouze říká, abychom na symbol a nahlíželi jako na identifikátor seznamu, podobně jako bychom to česky vyjádřili pomocí přípony v plurálu („áčka“). Je důležité si uvědomit, že tímto získáváme seznam se všemi funkcemi všude tam, kde se objevuje zápis @a. Je to poněkud odlišný způsob nahlížení na pole, než jaký se používá v jiných moderních programovacích jazycích.

@a = qw/skákal pes přes oves/;
@b = qw/přes zelenou louku/;
@c = (2, -1 .. 1);
(@a, @b)[@c]            # přes louku skákal pes

Seznamy a hashe

Perlovský hash se má se seznamy celkem rád. Lze si opět představit, že zápis %a znamená „áčka, na která se nahlíží jako na páry (klíč, hodnota)“. Hashe se inicializují seznamem, operátor => převážně slouží k lepší čitelnosti kódu. Hashe lze indexovat vyhledáním klíče pomocí složených závorek. Česky bychom řekli „hodnota klíče v seznamu“( $a{'klíč'}). Jako index lze také použít seznam a tak vytvářet řezy. V tom případě však musíme prefixovat symbolem @, neboť řez je seznam. Dále lze hashe umístit do seznamu nebo přiřadit do pole a takto získat zpět seznam párů (klíč, hodnota). Pořadí párů však bude náhodné.

$ENV{'PATH'}        # '/bin:…'
@ENV{qw/HOME USER/} # všimněte si symbolu @, více indexy vytváříme seznam
%h = @a;        # ('skákal' => 'pes', 'přes' => 'oves')
$h{'přes'}     # 'oves'
%k = (%h, @b);      # index 'přes' se přepíše na 'přes' => 'zelenou'
            # a přidá se 'louku' => undef

@u = 'A' .. 'Z';
%v = @u;        # 'A' => 'B', 'C' => 'D', …

@w = %v;        # pořadí prvků je jiné než v @u, asociace párů však zůstane

Struktury a pojmenované parametry

Hashe se používají nejen čistě pro účely hashování, ale často také tam, kde by stála konstrukce struct v C.

%zaznam = ( 'jméno' => 'František Koudelka', 'oddíl' => 'STS Chvojkovice-Brod' );

(Jak vytvořit pole takových záznamů si ukážeme v příštím díle.)

Příbuznost hashů a seznamů lze využít také jako náhražku pojmenovaných parametrů funkcí.

sub spojeni {
    my %parametry = @_;
    print "Spojuji se na '$parametry{'kam'}' jako '$parametry{'kdo'}'\n";
}

# pak lze použít

spojeni(kdo => 'pes', kam => 'okno');
spojeni(kam => 'díra', kdo => 'kočka');

Spolu s tím si lze dopřát i luxus parametrů s výchozími hodnotami. Lze to udělat klasicky pomocí operátoru or, nebo využít fakt, že nová dvojice (klíč, hodnota) v seznamu přepíše starou.

sub spojeni {
    my %parametry = @_;
    $parametry{'kdo'} or $parametry{'kdo'} = $ENV{'USER'};
    print "Spojuji se na '$parametry{'kam'}' jako '$parametry{'kdo'}'\n";
}

# nebo

sub spojeni {
    my %parametry = (kdo => $ENV{'USER'}, @_);
    print "Spojuji se na '$parametry{'kam'}' jako '$parametry{'kdo'}'\n";
}

# pak lze zavolat

spojeni(kam => 'domu');

Seznamové operátory

K často používaným seznamovým operátorům patří přiřazení a  print. V případě přiřazení lze do seznamu na levé straně napsat skalární proměnné, jejichž obsah se tímto přiřadí. Operátor print použije k oddělení prvků seznamu hodnotu $,.

($home, $user) = $ENV{qw/HOME USER/};
print "Babka má ", secti_jabka(), " jablek.";

# obsah všech seznamů v dnešních příkladech lze rychle vypsat takto

$, = " "; print @pole;      # nebo (seznam)

# nebo beze změny $,

{ local $, = " "; print @pole; }

K řazení prvků se používá operátor sort. Řadit lze dle návratové hodnoty libovolné funkce (která je záporná, kladná, nebo nula), nicméně zajímavější je varianta s blokem kódu. V bloku jsou definované identifikátory $a a  $b jako reference na dvě porovnávané hodnoty.

sort { $a cmp $b } qw/pes prase ping/;      # seřadí jako řetězce
sort (1..100);                  # také jako řetězce
sort { $a - $b } (1..100);          # jako čísla
sort { $a <=> $b } (1..100);          # také jako čísla
sort { abs($a) <=> abs($b) } (-100..100); # jako čísla, bez znaménka

Chceme-li řadit podle nějaké složitější funkce, je vhodné si její hodnoty dopředu spočítat a řadit podle těchto hodnot.

$hodnoty{$_} = funkce($_) for @pole;
@serazeno = sort { $hodnoty{$a} <=> $hodnoty{$b} } @pole;
%hodnoty = undef;

(Toto lze provést poněkud elegantněji pomocí referencí a operátoru map. O referencích ale příště.)

Zmiňovaný operátor map umožňuje na seznamu provést libovolnou transformaci. Ve vykonávaném bloku přestavuje $_ odkaz na aktuálně zpracovávaný prvek. Na rozdíl od cyklu for však můžeme prvky seznamu mazat nebo přidávat, jestliže posledním výrazem v bloku nevyhodnotíme skalár, ale prázdný seznam, respektive seznam s více hodnotami.

@mocniny = map { 2**$_ } (0 .. 8);

# je zhruba ekvivalentní

for (0 .. 8) {
    $mocniny[$_] = 2**$_;
}

@mala_pismenka = map { lc($_) } @slova;

# výše uvedený cyklus
# $hodnoty{$_} = funkce($_) for @pole
# lze zapsat také takto

%hodnoty = map { $_ => funkce($_) } @pole;

# mazat prvky lze pomocí prázdného seznamu

@vetsi_nez_10 = map { $_ > 10 ? $_ : () } (1 .. 100);

Operátor grep je obdoba posledního příkladu na map. Pokud vyhodnocovací blok vrátí pravdivou hodnotu, prvek je v seznamu ponechán, jinak je vymazán. Pokud je grep vyhodnocen jako skalár, vrátí počet prvků, které testem prošly.

@skryte_soubory = grep { $_ =~ /^\./ } @soubory;
$autorizovan = grep { $jmeno eq $_ } @autorizovani_uzivatele;

Závěr

V dnešním díle jsme si ukázali některé mocnější techniky pro práci se seznamy, poli a hashi. Naše poznatky můžeme shrnout do následujícího prográmku.

#!/usr/bin/perl -w

use strict;

my ($max, $r) = (shift, 1);

die "Použití: $0 <kladné číslo>\n" unless defined $max and $max > 0;

$, = " ";

my @faktorial = ( 1, map {
    $r *= $_;
    $r;
} (1 .. $max) );

print @faktorial, "\n";

my @trojuhelnik = map {
    my $n = $_;
    map { $faktorial[$n] / $faktorial[$_] / $faktorial[$n - $_] } (1 .. $n);
} (1 .. $max);

print @trojuhelnik, "\n";

Generace pole faktoriálů spočívá ve vynásobení předchozí vypočtené hodnoty aktuálním prvkem ze sekvence 1 až $max. Jako výjimka je první prvek (index 0) inicializován napevno jedničkou. Pascalův trojuhelník pak vyrobíme po řádcích (vnější map), přičemž N-tý řádek obsahuje právě N prvků, které se vypočítají jako kombinační čísla (vnitřní map).

V příštím díle se budeme zabývat převážně referencemi, způsobem, jak vybudovat složitější datové struktury a jejich použitím spolu s již probranými operátory.