Welche Zweitsprache? Python oder Perl?

[Colttt]

Ohh man ihr macht es einen echt nicht einfach..

Perl ist öfters auf Systemen installiert(Linux,solaris,BSD).. Python ist logischer zu programmieren und ist mächtiger (wenn man sich die Softwareprojekte so anschaut)

[Radfahrer]

(Wobei ich persönlich, wenn ich zwischen den beiden eher Perl wählen würde, weil ich Einrückung und damit die Syntax von Python nicht mag.

Wie sich die Geschmäcker doch unterscheiden.
Ich empfinde gerade die Einrückungen und die dadurch wegfallenden Klammer-Orgien bei Python als sehr elegant. Auch sonst finde ich die Python-Syntax sehr schön.

[uname]

Ich habe mal ein Beispiel rausgesucht. Die rekursive Berechnung von 5 Fakultät (5!) also im Prinzip 5! = 5 * 4 * 3 * 2 * 1

Perl:

Code: Alles auswählen

#!/usr/bin/perl -w

sub fakul
 {
  my $x=$_[0];
  if($x)     
    {
      return $x * fakul($x-1);  
    }
  return 1;
 }

print fakul(5) . "\n";

Python:

Code: Alles auswählen

#!/usr/bin/python

def fakul (n):
    if n == 1:
        return 1
    else:
        res = n * fakul (n-1)
        return res

print(fakul(5))

Man muss dazu sagen, dass ich die Beispiele im Internet gefunden habe. Perl wartet auf den Wert 0 und gibt dann 1 zurück. Python hat als Rekursions-Ende den Wert 1. Ich denke auffällig ist vor allem, dass man bei Perl bei den Variablen ein $ vorschreibt. Dafür gefallen mir die geschweiften Klammern. Leider habe ich kein Beispiel welches objektorientiert arbeitet oder ein schönes Beispiel mit Hashes.

[Radfahrer]

Jepp, schönes Beispiel.
Ich finde da den Python-Code sehr viel eleganter.

[wanne]

Das ist elegent:

Code: Alles auswählen

use List::Util qw(reduce);

$n = shift;
print reduce {$a * $b} 1..$n;

Kein Funktionsoverhead kein nichts. Und dabei vermutlich um längen schneller.
Wobei python auch fold könnte.

[peschmae]

Falls jemand nach einem Beispiel für die Unleserlichkeit von Perl gefragt hätte, wäre das die Richtige Antwort gewesen

MfG Peschmä

[Radfahrer]

Ich hatte eigentlich auch gedacht, dass elegant nicht gleichbedeutend mit unverständlich. Elegant heißt auch nicht möglichst wenig Zeilen.

[Liffi]

Unleserlich ist eher sowas (valides Perl):

Code: Alles auswählen

    ''=~(        '(?{'        .('`'        |'%')        .('['        ^'-')
    .('`'        |'!')        .('`'        |',')        .'"'.        '\\$'
    .'=='        .('['        ^'+')        .('`'        |'/')        .('['
    ^'+')        .'||'        .(';'        &'=')        .(';'        &'=')
    .';-'        .'-'.        '\\$'        .'=;'        .('['        ^'(')
    .('['        ^'.')        .('`'        |'"')        .('!'        ^'+')
   .'_\\{'      .'(\\$'      .';=('.      '\\$=|'      ."\|".(      '`'^'.'
  ).(('`')|    '/').').'    .'\\"'.+(    '{'^'[').    ('`'|'"')    .('`'|'/'
 ).('['^'/')  .('['^'/').  ('`'|',').(  '`'|('%')).  '\\".\\"'.(  '['^('(')).
 '\\"'.('['^  '#').'!!--'  .'\\$=.\\"'  .('{'^'[').  ('`'|'/').(  '`'|"\&").(
 '{'^"\[").(  '`'|"\"").(  '`'|"\%").(  '`'|"\%").(  '['^(')')).  '\\").\\"'.
 ('{'^'[').(  '`'|"\/").(  '`'|"\.").(  '{'^"\[").(  '['^"\/").(  '`'|"\(").(
 '`'|"\%").(  '{'^"\[").(  '['^"\,").(  '`'|"\!").(  '`'|"\,").(  '`'|(',')).
 '\\"\\}'.+(  '['^"\+").(  '['^"\)").(  '`'|"\)").(  '`'|"\.").(  '['^('/')).
 '+_,\\",'.(  '{'^('[')).  ('\\$;!').(  '!'^"\+").(  '{'^"\/").(  '`'|"\!").(
 '`'|"\+").(  '`'|"\%").(  '{'^"\[").(  '`'|"\/").(  '`'|"\.").(  '`'|"\%").(
 '{'^"\[").(  '`'|"\$").(  '`'|"\/").(  '['^"\,").(  '`'|('.')).  ','.(('{')^
 '[').("\["^  '+').("\`"|  '!').("\["^  '(').("\["^  '(').("\{"^  '[').("\`"|
 ')').("\["^  '/').("\{"^  '[').("\`"|  '!').("\["^  ')').("\`"|  '/').("\["^
 '.').("\`"|  '.').("\`"|  '$')."\,".(  '!'^('+')).  '\\",_,\\"'  .'!'.("\!"^
 '+').("\!"^  '+').'\\"'.  ('['^',').(  '`'|"\(").(  '`'|"\)").(  '`'|"\,").(
 '`'|('%')).  '++\\$="})'  );$:=('.')^  '~';$~='@'|  '(';$^=')'^  '[';$/='`';

Auch wenn python auf dem Vormarsch ist, würde ich es nicht so sehen, dass perl deswegen komplett an Bedeutung verliert. CPAN bietet so unfassbar viel, das muss Python erst mal aufholen . Auch heute gibt es noch Firmen, die auf Perl setzen (z.B. xing oder booking.com).

[Meillo]

Wie konstruktiv ist die Diskussion zwischen Perl und Python denn noch? Das ist doch nicht anders als Emacs vs. vi: Eine Glaubensfrage, da man sachlich kein Ergebnis finden wird. Also lassen wir das ...

[Radfahrer]

Stimmt. Muss halt jeder selber ausprobieren und sich eine eigene Meinung bilden.

Wobei vim natürlich um Welten besser ist als emacs.

[wanne]

Falls jemand nach einem Beispiel für die Unleserlichkeit von Perl gefragt hätte, wäre das die Richtige Antwort gewesen

Ich finde das hundert mal verständlicher als die oben genannte rekursive Variante.

Ich habe gerade mal gegoogelt wie man das in python macht:

Code: Alles auswählen

def mul (a,b):
        return a * b

def fakt(n):
        return reduce(mul,range(1,n+1))

print(fakt(5))

Eigentlich nicht viel uneleganter. Nur, dass dank der dämlichen Einrückregel aus {$a * $b} gleich 3 volle Zeilen werden.
PS: kann man python dazu bringen, dass es etwas schönere Fehlermeldungen ausgibt als: "invalid Syntax"?

@Liffi: Wie unleserlich in keiner anderen Programmiersprache hättest du so schnell deutlich machen können, dass es um Bierflaschen geht. Das kann ich trotz Kurzsichtigkeit noch aus 50m erkennen.

[Colttt]

also ich werde jetzt wahrscheinlich mit python angucken.. vor allem weil ich mir bcfg2 näher angucken möchte..

[catdog2]

Eigentlich nicht viel uneleganter. Nur, dass dank der dämlichen Einrückregel aus {$a * $b} gleich 3 volle Zeilen werden.

1. Die ist nicht dämlich
2. Kann man auch anders schreiben z.B.:

Code: Alles auswählen

def fakt(n):
        return reduce(lambda x, y: x*y,range(1,n+1))

Oder die funktion eben ganz in einer Zeile:

Code: Alles auswählen

fakt = lambda n: reduce(lambda x, y: x*y,range(1,n+1))

//edit: bei def muss man nicht mal eine newline machen, also geht auch

Code: Alles auswählen

def fakt(n): return reduce(lambda x, y: x*y,range(1,n+1))

Kein Funktionsoverhead kein nichts. Und dabei vermutlich um längen schneller.

Da würde ich mich nicht so weit aus dem Fenster lehen. Bei perl bist du an den perl Interpreter gebunden weil die Sprache nicht formal definiert ist. Bei python musst du nicht zwangsläufig die vergleichsweise langsame Referenzimplementierung benutzen sondern kannst z.B. pypy verwenden.

Perl ist öfters auf Systemen installiert(Linux,solaris,BSD).. Python ist logischer zu programmieren und ist mächtiger (wenn man sich die Softwareprojekte so anschaut)

Python ist zumindest im Linux Bereich ähnlich verbreitet alleine schon weil viele Distributionen tools mitliefern, die das benutzen.
Wie schon angedeutet ist Python halt eine sauber formal definierte Sprache und perl das exakte Gegenteil davon. Mag zwar im ersten Moment toll erscheinen, dass praktisch alles irgendwie funktioniert aber man tut sich sicherlich keinen Gefallen, gerade wenn es mal komplexer als ein paar Zeilen wird.

[wanne]

Kein Funktionsoverhead kein nichts. Und dabei vermutlich um längen schneller.

Da würde ich mich nicht so weit aus dem Fenster lehen. Bei perl bist du an den perl Interpreter gebunden weil die Sprache nicht formal definiert ist. Bei python musst du nicht zwangsläufig die vergleichsweise langsame Referenzimplementierung benutzen sondern kannst z.B. pypy verwenden.

Also ich habe gerade mal enchmarken wollen. Die rekursive Variante gibt schon vor 1000 auf. Geschwindigkeit ist also kein Problem.
Allerdings ist die von dir gepostete Variante um Lengen schneller als meine perl variante, wenn man auf bigintegers umstellt.

[novalix]

Also ich habe gerade mal enchmarken wollen. Die rekursive Variante gibt schon vor 1000 auf.

Wow, da hätte ich doch ein wenig mehr Durchhaltevermögen erwartet.
Auf sbcl:

Code: Alles auswählen

(defun factorial (n)
    (reduce #'*(loop for i from 1 to n collect i)))

Benchmark (10.000):

Code: Alles auswählen

(time (factorial 10000))
Evaluation took:
  0.111 seconds of real time
  0.072000 seconds of total run time (0.060000 user, 0.012000 system)
  [ Run times consist of 0.008 seconds GC time, and 0.064 seconds non-GC time. ]
  64.86% CPU
  153,328,020 processor cycles

Die rekursive und die tail recursive Variante liefern recht ähnliche Ergebnisse.
A propos Ergebnis: Das poste ich hier nicht. Kann sich ja jeder selbst ausrechnen.

[wanne]

Compilierende Sprachen sind ungerecht. Und endrekursive Varianten in Lisp und C zählen nur als Interativ:

C:

Code: Alles auswählen

#include <stdio.h>
#include <gmp.h>

int main(int arg, char** argv)
{
        if(arg!=2)
                exit(1);
        unsigned long to = atol(argv[1]);
        MP_INT num;
        mpz_init_set_ui(&num,2UL);
        for(unsigned long i=3;i<=to;i++)
                mpz_mul_ui(&num,&num,i);
        char* out=NULL;
        printf("0x%s",mpz_get_str(out,16,&num));
}

Code: Alles auswählen

$ time ./cfakt 10000 > /dev/null 

real    0m0.016s
user    0m0.008s
sys     0m0.004s

Code: Alles auswählen

$ time ./cfakt 100000 > /dev/null 

real    0m2.168s
user    0m1.820s
sys     0m0.000s

[novalix]

An die Laufgeschwindigkeit von C kommt man mit Lisp nicht wirklich ran.
Ich mit Sicherheit nicht:

Code: Alles auswählen

(time (fact-tail 30000))
Evaluation took:
  0.879 seconds of real time
  0.896000 seconds of total run time (0.888000 user, 0.008000 system)
  [ Run times consist of 0.080 seconds GC time, and 0.816 seconds non-GC time. ]
  101.93% CPU
  1,752,832,040 processor cycles
  796,106,064 bytes consed

Endrekursiv mit Typendeklaration.
An dem C-Beispiel sieht man aber auch, dass es recht aufwendig ist, optimierte Programme zu schreiben. Optimierter Lisp code sieht dann auch irgendwann aufgeblähter und kryptischer aus.
Bleibt der Vorteil, dass man mit Lisp arbeiten kann wie mit einer interpretierten Skript-Sprache, auch wenn wie im Falle von sbcl jeglicher code on the fly kompiliert wird. Die Performancewerte liegen dabei meist näher an C als an Perl et al.