Vlákno názorů k článku Perličky: úvod do referencí od LENIN POWER - Prosimvas kdo jeste Perl neumite, tak se ho...

Prosimvas kdo jeste Perl neumite, tak se ho radsi neucte. Kdybych se misto perlu naucil rovnou Python, udelal bych lip.

Ne!

Pane,
ve článku nikdo nikoho nenutil se něco učit. Tento jazyk byl vymyslen člověkem z praxe pro lidi, řešící praktické věci. V žádném případě není výlupek ctností a akademické krásy - na druhou stranu, zatím co v jiných jazycích dokončujete ještě deklarace, tak perlista už balí. Používám několik jazyků, ale díky organizované strávě modulů (CPAN) a díky časovému stresu jsem si za hlavní (a poslední) jazyk zvolil perl. A udělal jsem dobře.

Nechápu, jak něco tak až psychopatického jako Python, může mít tolik příznivců. Grafická úprava součástí programu - peklo smrt čerti.

jee, tohle je pekne! Diky za krasnou ilustraci proc Python ne. Vyse uvedeny kod v Pythonu nebude fungovat (kvuli formatovani).
Jo, nemuzete pastnout kod do HTML komentaroveho systemu, nemuzete psat one-linery, atd.

Pred elsif Vam chybi zavorka.

Misto $$a[$ia++] je myslim citelnejsi psat $a->[$ia++].

Hmm, jak vlastne v Pythonu reknu ze mam lokalni promennou? Pri prvnim prirazeni? To je fakt spatne, protoze pak neodhalite preklep ve jmene promenne uz v compile-time.

Michani objektoveho zapisu s funkcemi (ret.append() versus len(a)) je taky dost divne.

-Yenya

Souhlasim s kritikou. Navic ta dvojita reference (push @$ret, ...) je zbytecna - staci push @ret... a pak return [ @ret ];

To je argumentace stylem : umim Perl jen trochu - jednoduchy problem v nem vyresim neprehledne - takze Perl je spatny. Ja osobne bych to resil takhle - myslim ze to je jeste lepsi nez ten ukazkovy Python.

sub merge
{
    my @a=@{$_[0]};
    my @b=@{$_[1]};
    my @ret=();
    my $minlen = (@a<@b ? @a : @b);
    push @ret, map { shift @a, shift @b } (0 .. $minlen-1);
    push @ret, @a;
    push @ret, @b;
    return [ @ret ];
}

Nečitelnost není vlastností jazyka ale programátora. Co třeba takhle?

sub merge {
	my $r_a=shift;
	my $r_b=shift;
	my @ret=();
	my ($ia,$ib)=(0,0);
	my ($ctia,$ctib)=(1,1);   # 0..necti 1..cti 2..konec
	my ($maxa,$maxb);         # maximalni indexy
	my $prveka;
	my $prvekb;

	$maxa=$#{@{$r_a}};
	$maxb=$#{@{$r_b}};

	while (1) {
		$ctia=2 if ($ia>$maxa);
		$ctib=2 if ($ib>$maxb);
		last if ($ctia==2 and $ctib==2);

		if ($ctia==1) {
			$prveka=$r_a->[$ia++];
			$ctia=0;
		}
		if ($ctib==1) {
			$prvekb=$r_b->[$ib++];
			$ctib=0;
		}

		if ($prveka<$prvekb) {
			push(@ret,$prveka);
			$ctia=1;
		}
		elsif ($prveka==$prvekb) {
			push(@ret,$prveka);
			push(@ret,$prvekb);
			$ctia=$ctib=1;
		}
		else {
			push(@ret,$prvekb);
			$ctib=1;
		}
	}
	return (\@ret);

Pekne, ale trosku moc kodu na jednoduchou vec. V Perlu na tohle mame operatory pro praci se seznamy - viz muj prispevek vyse: http://www.root.cz/clanky/perlicky-uvod-do-referenci/nazory/187417/

Síla? Vážně? A kromě toho, že se to vám nováčkům pěkně čte to má jaké unikátní výhody? Zatím jsem si totiž všiml jediné věci: když se kód rozformátuje, tak jste v hajzlu a opravit to znamená projít a zkontrolovat celou funkcionalitu, protože pouhé odsazení má syntaktický význam - náležitost do sub-bloků kódu. Kromě toho to taky znamená, že si s tím moc nepohrajete, co? Jak to není pod sebou, je to blbě... Zajímavá myšlenka, opravdu!

Co mě ale nejvíc fascinuje - když nějaký beginner (soudím podle tvé implementace) porovnává dva jazyky a přitom zná jen jeden z nich. Fakt přínos.

Teď ti ukážu čtyři možnosti implementace: tvoji, a la Perl, lepší a správnou. První tři jsou ekvivalentní, čtvrtá funguje jak bych si představoval (obecněji). Je to subjektivní hodnocení, takže necháme ostatní, aby to posoudili. Samozřejmě existuje nekonečně mnoho způsobů jak v Perlu správně napsat to, oč jsi se pokusil ty, a to je důvod, proč mám Perl rád.

Mimochodem, nikdy nemám problém s "čitelností", kde se tahle kravina vzala? A reference? Kde bysme byli s C bez pointerů (i.e. referencí) nebo hůř, kdyby C (de)referenci provádělo automaticky?

Přiložený zdroják je samostatný, stačí paste a spustit. Je to i s benchmarkem všech metod.

#!/usr/bin/env perl
# vi:ft=perl

use Benchmark qw( :all );

my @TA1 = qw/ 1 2 3 /;				# Test case A
my @TA2 = qw/ 1 5 3 4 5 6/;

my @TB1 = qw/ 2 2 3 4 5 6/;			# Test case B
my @TB2 = qw/ 1 3 3 4 7 /;

my (@M1, @M2);					# Vysledky
  
#########################[ Reseni 1 ]########################
#
# Tvoje sragora, mimochodem v prvnim "push" jsi mel chybu,
# cpal jsi do vysledku prvky pole A misto pole B. A chybela
# ti zavorka pred elsif.
#
# Uz jen ty reference a dereference vsude, pane boze!!
#
sub merge {
	my ($a, $b) = @_;
	my $ret = [];
	my $ia = 0;
	my $ib = 0;
	while (1) {
		if ($ia == @$a) {
			last if $ib == @$b;
			push @$ret, $$b[$ib++];
		} elsif ($ib == @$b or $$a[$ia] < $$b[$ib]) {
			push @$ret, $$a[$ia++];
		} else {
			push @$ret, $$b[$ib++];
		}
	}
	return $ret;
}

@M1 = @{merge(\@TA1, \@TA2)};
@M2 = @{merge(\@TB1, \@TB2)};
print "Reseni 1a: @M1\tReseni 1b: @M2\n";


#########################[ Reseni 2 ]########################
#
# Takhle bych to napsal od boku.
# Lepsi? Co myslis?
#
sub merge2( \@\@ ) {
	my @a = @{$_[0]};
	my @b = @{$_[1]};
	my @c = map { my @c; push @c, shift @b while $b[0]<=$_ && @b; @c, $_ } @a;
	return @c, @b;
}

@M1 = merge2 @TA1, @TA2;
@M2 = merge2 @TB1, @TB2;
print "Reseni 2a: @M1\tReseni 2b: @M2\n";


#########################[ Reseni 3 ]########################
#
# To same, jen bez kopirovani poli a s primou indexaci.
#
sub merge3( \@\@ ) {
	my ($a, $b) = @_;
	my (@c, $i);
	map { push @c, $b->[$i++] while $b->[$i] <= $_; push @c, $_ } @{$a};
	return @c, @{$b}[$i..$#{$b}];
}

@M1 = merge3 @TA1, @TA2;
@M2 = merge3 @TB1, @TB2;
print "Reseni 3a: @M1\tReseni 3b: @M2\n";


#########################[ Reseni 4 ]########################
#
# Tvuj priklad ale testovaci pole spojuje blbe, viz vystup,
# protoze predpoklada, ze jsou obe setridena. Co z toho leze
# kdyz nejsou jsi videl. Ale beru, zes to tak treba chtel.
#
# Tohle reseni je ze vsech nejlepsi, protoze pole zmerguje
# i v pripade, ze nejsou predem setridena a hlavne je trikat
# rychlejsi nez ostatni (a nepotrebuje extra funkci:)
#

@M1 = sort @TA1, @TA2;
@M2 = sort @TB1, @TB2;
print "Reseni 4a: @M1\tReseni 4b: @M2\n\n";


##########################[ Timing ]#########################
my $c = 100000;
print "Cas reseni 1:\n\t"; timethis($c,
	sub { @M1 = @{merge(\@TA1, \@TA2)}; @M2 = @{merge(\@TB1, \@TB2)} });
print "Cas reseni 2:\n\t"; timethis($c,
	sub { @M1 = merge2 @TA1, @TA2; @M2 = merge2 @TB1, @TB2 });
print "Cas reseni 3:\n\t"; timethis($c,
	sub { @M1 = merge3 @TA1, @TA2; @M2 = merge3 @TB1, @TB2 });
print "Cas reseni 4:\n\t"; timethis($c,
	sub { @M1 = sort @TA1, @TA2; @M2 = sort @TB1, @TB2 });

Výstup:

Reseni 1a: 1 1 2 3 5 3 4 5 6	Reseni 1b: 1 2 2 3 3 3 4 4 5 6 7
Reseni 2a: 1 1 2 3 5 3 4 5 6	Reseni 2b: 1 2 2 3 3 3 4 4 5 6 7
Reseni 3a: 1 1 2 3 5 3 4 5 6	Reseni 3b: 1 2 2 3 3 3 4 4 5 6 7
Reseni 4a: 1 1 2 3 3 4 5 5 6	Reseni 4b: 1 2 2 3 3 3 4 4 5 6 7

Cas reseni 1:
	timethis 100000:  3 wallclock secs ( 2.93 usr +  0.00 sys =  2.93 CPU) @ 34129.69/s (n=100000)
Cas reseni 2:
	timethis 100000:  3 wallclock secs ( 3.05 usr +  0.00 sys =  3.05 CPU) @ 32786.07/s (n=100000)
Cas reseni 3:
	timethis 100000:  3 wallclock secs ( 2.75 usr +  0.00 sys =  2.75 CPU) @ 36363.64/s (n=100000)
Cas reseni 4:
	timethis 100000:  1 wallclock secs ( 0.97 usr +  0.00 sys =  0.97 CPU) @ 103092.78/s (n=100000)

Disclaimer: pouzivam Perl >10 let.

Kod je zda se dobry, ale nektere konstrukty bych nepouzil.
V prvni verzi kodu bych asi spis nadeklaroval pole @ret a na konci udelal
"return \@ret;" - uvnitr kodu by bylo mene dereferencovani a byl by tak jeste
o kousek citelnejsi a mozna i rychlejsi.

Vsem kdo v Perlu pisou delsi veci doporuji knihu Perl Best Practices: http://www.oreilly.com/catalog/perlbp/ - ne ze bych se vsim tam uvedenym souhlasil pro sve projekty, ale aspon se autor obtezuje vysvetlit, proc si mysli ze by soucasti programatorskeho stylu neco konkretniho melo nebo nemelo byt. Je to pekne psane a prinuti to cloveka se zamyslet.

Z konstrukci ktere PerlBP nedoporucuje bych tady konkretne nepouzil prototypy v merge2 a merge3 - prototypy maji nekolik podstatnych nevyhod: napriklad chovaji se jinak v kodu ktery je uvedeny drive nez ta funkce a jinak v kodu pod ni; dale pokud uz reference na ta dve pole mate nekde z drivejska v promenne, tak nemuzete zavolat merge3(@moje_dva_arrayrefy).

Ale jinak samozrejme, TIMTOWTDI.

-Yenya

Uprimne receno, docela by me zajimalo, zda jenom tak placate nebo jste zkusil v Pythonu neco (vetsiho, na mensich kusech se to tak nepozna) naprogramovat.

Kdyz je clanek o referencich, historku ze zivota: Znal jsem cloveka, co byl zaryty Perlista, a na Python take velmi nadaval. Shodou okolnosti nechapal, proc Python reference nepotrebuje - v Perlu mu prisly nezbytne. Pozdeji zkusil programovat v Pythonu; dnes na nej neda dopustit, a na Perl si ani nevzpomene.

Napsal jsem jednu netrivialni aplikaci v Pythonu. Reknu Vam, co se mi na Pythonu oproti Perlu nelibilo:

1. Zadne deklarace. Nekdo to povazuje za vyhodu, me to desne chybelo. Hledat chyby v kodu, kde se clovek prepise v nazvu promenne nebo kde zapomene vytvorit promennou pred telem vnoreneho bloku je fakt opruz.

2. Prakticky nepouzitelne defaultni hodnoty parametru funkci. Myslim, ze jednoduchy priklad je dostacujici vysvetleni:

def t (s = []):
  s.append (1)
  return s

print t()
print t()

3. Nedostacujici uzavery/lambda funkce. Python ma sice konstrukt lambda:, ale v jeho tele muze byt pouze vyraz.

4. Chybejici reference. Chybejici reference znemoznuje napsat neco tak zakladniho, jako je funkce swap.

Tohle jsou vsechno zasadni veci. Pak existuje spousta dalsich mensich problemu jako napr. osklive __identifikatory__, nutnost psat vsude self., chybejici autovivifikace atd.

Ja som na tom skor opacne, napisal som len asi jednu netrivialnu aplikaciu v Perle a viac som napisal v Pythone. Tymto ale nechcem povedat, ze Perl je horsi ako Python, alebo naopak. Oba povazujem za velmi dobre. Keby tu nebol Perl ani Python by tu mozno nebol, lebo Python prebral vela od Perlu. Perl je starsi. Python sa mozno v mnohom snazil byt modernejsi. Niekomu sa to paci a niekomu nie. To je individualna zalezitost.

1. Ziadne deklaracie ma nijako nerozculuju. Ani v Perle predsa netreba premenne deklarovat. Alebo ako to myslis?

2. Pre pouzitie defaultnych hodnot si zvolil akurat priklad so zoznamom v ktorom to nefunguje. Python vzdy vytvara na zoznamy referencie a z toho plynie aj spravanie funkcie t(). Ak ju zavolas s argumentom prazdnym alebo neprazdnym zoznamom, bude fungovat, tak ako ocakavas, napr:

print t([])
print t([])
print t(t([]))
print t(['a','b'])
print t(['x'])

Toto ako zaobchadza Python s listami ma tiez netesi, lebo pri priradeni list2=list1 sa vytvori len nova referencia na ten isty list. Ak chce clovek vytvorit novy list ako kopiu stareho treba urobit list2=list1[:]
Inac ale defaultne hodnoty vo funkciach prakticky funguju, napr:

def halo(meno="Vaclav"):
  return "Halo %s" % meno

print halo()
print halo ('MikRom')

3. Lambda funkcie neposkytuju taku funkcionalitu ako pomenovane funkcie - ano s tym suhlasim, ale Guido sam nema zrejme lambdy rad a chcel ich v Pythone 3000 povodne aj zrusit. Zrejme si mysli, ze sa moc nepouzivaju. 4. Ze referencie nechybaju, toho dokazom je tvoj priklad s funkciou t(). Na zoznamy sa vzdy pouzivaju referencie. Swap tiez funguje

l1=['a','b']
l2=['x','y']
print "l1=%s, l2=%s" % (l1, l2)
l1, l2 = l2, l1
print "l1=%s, l2=%s" % (l1, l2)

Ina vec je, ze netreba explicitne dereferencovat ako v Perle. Ale to pracu so zlozitejsimi strukturami podla mna skor zjednodusuje.

5. __identifikatory__: Ano v Pythone si treba zapamatat co znamena

if __name__ == "__main__":
  ...

ale je to podobne ako vediet v Perle, co to je $_,@_,...

6. self: Python prostrednictvom self pri premennej, resp. funkcii rozlisuje, ci sa jedna o atribut, resp. metodu aktualneho objektu, alebo o nejaky globalny identifikator (ak tam self nie je). Self je vlastne referencia na slovnik, ktory reprezentuje dany objekt. Identifikator self pochadza z Perlu. Python prebral z Perlu sposob, ze objekty su reprezentovane cez asociativne polia (t.j. slovniky). A v Perle sa tiez doporucuje odkaz na aktualny objekt oznacovat ako $self.

Ked som prvykrat skusal Python, tiez mi povinne odsadzovanie pripadalo nasilne. Ale nerobilo mi to problemy, pretoze som tak pisal aj predtym.
Vynutene odsadzovanie ma aj svoje vyhody - precitaj si napriklad toto: Python: Myths about Indentation

Perl dokazu generovat z jineho programu snadno. Generovani Pythonu z jineho programu je problem, protoze musim navic ke vsemu ostatnimu drzet globalni stav indentovani; anebo musim generovat dvoupruchodove, kde v druhem pruchodu zformatuji.

Dekuji za radu, ale rozhodl jsem se ji nenasledovat.

Pominu-li, ze generovat Python z jineho programu je nesmysl (diky dynamickym vlastnostem jazyka), presto myslim, ze nemusite. Staci, kdyz ve funkci ktera vola funkci generujici radek(y) kodu, do toho radku pripisete prislusnou uroven. Tim se vam ta globalni uroven udrzi rekurzivne. Priklad:

def generuj_soucet(a,b):
  yield 'print '+str(a)+'+'+str(b)

def generuj_funkci_soucet(x,y):
  yield 'def soucet('+str(x)+','+str(y)+')'
  for s in generuj_soucet(a,b):
    yield '  '+s

for s in generuj_soucet(1,2):
  print s

for s in generuj_funkci_soucet('cislo1','cislo2'):
  print s

Pak muzete generator generuj_soucet pouzit na obou urovnich, a budete mit zarovnani spravne, jak ukazuje funkce generuj_funkci_soucet.

Naopak, generování kódu má smysl i v dynamickém jazyku, ba co víc, tam pro něj jsou i mnohem lepší podmínky, neb generátory pro statické jazyky jsou většinou děs na používání. Přínos generování kódu v dynamickém jazyků může být ohromný - třeba sražení zdrojového kódu na zlomek velikosti, a to i ve velkých aplikacích (nebo možná právě v nich) a z toho plynoucí lepší udržovatelnost (samozřejmě hovořím o čistých způsobech generování kódu, nikoli o nějakém prasáckém lepení řetězců dohromady).

Tomu moc nerozumim. Neni proste v dynamickem jazyce lepsi, nez ten kod vygenerovat, ho rovnou provest? A pokud ho chcete generovat kvuli rychlosti, neni lepsi generovat rovnou C? A generovat kod, ktery bude dale nekdo upravovat rucne, mi nepripada zrovna dobry napad (z hlediska spravy). To jsou asi vsechny moznosti, proc byste neco takoveho chtel delat. Asi by se hodil nejaky konkretni priklad.

Nevim co nazyvate "cistym zpusobem generovani kodu" - kod (ve smyslu zdrojak) jsou prece retezce. Nevim, jak byste to chtel delat cisteji bez retezcu, asi by zase pomohl nejaky priklad. Vyse uvedeny program si navic nedava vyssi ambice, nez byt kratkou ilustraci toho, o cem autor tvrdil, ze to neni mozne.