Ich habe ein einfaches Skript in Python und Haskell geschrieben. Es liest eine Datei mit 1.000.000 durch Zeilenumbrüche getrennten Ganzzahlen, analysiert diese Datei in eine Liste von Ganzzahlen, sortiert sie schnell und schreibt sie dann sortiert in eine andere Datei. Diese Datei hat dasselbe Format wie die unsortierte. Einfach.

Hier ist Haskell:

<code>quicksort :: Ord a => [a] -> [a]
quicksort []     = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
    where
        lesser  = filter (< p) xs
        greater = filter (>= p) xs

main = do
    file <- readFile "data"
    let un = lines file
    let f = map (\x -> read x::Int ) un
    let done = quicksort f
    writeFile "sorted" (unlines (map show done))
</code>

Und hier ist Python:

<code>def qs(ar):
    if len(ar) == 0:
        return ar

    p = ar[0]
    return qs([i for i in ar if i < p]) + [p] + qs([i for i in ar if i > p])


def read_file(fn):
    f = open(fn)
    data = f.read()
    f.close()
    return data

def write_file(fn, data):
    f = open('sorted', 'w')
    f.write(data)
    f.close()


def main():
    data = read_file('data')

    lines = data.split('\n')
    lines = [int(l) for l in lines]

    done = qs(lines)
    done = [str(l) for l in done]

    write_file('sorted', "\n".join(done))

if __name__ == '__main__':
    main()
</code>

Sehr einfach. Jetzt kompiliere ich den Haskell-Code mit

<code>$ ghc -O2 --make quick.hs
</code>

Und ich male die beiden mit:

<code>$ time ./quick
$ time python qs.py
</code>

Ergebnisse:

Haskell:

<code>real    0m10.820s
user    0m10.656s
sys 0m0.154s
</code>

Python:

<code>real    0m9.888s
user    0m9.669s
sys 0m0.203s
</code>

Wie kann Python möglicherweise schneller sein als nativer Code Haskell?

Vielen Dank

BEARBEITEN:

Python-Version: 2.7.1GHC-Version: 7.0.4Mac OSX, 10.7.32,4 GHz Intel Core i5

Liste erstellt von

<code>from random import shuffle
a = [str(a) for a in xrange(0, 1000*1000)]
shuffle(a)
s = "\n".join(a)
f = open('data', 'w')
f.write(s)
f.close()
</code>

Alle Zahlen sind also eindeutig.