Python比编译Haskell更快？

时间：2012-04-27 20:51:20

标签： python haskell quicksort

我有一个用Python和Haskell编写的简单脚本。它读取一个包含1,000,000个换行符分隔整数的文件，将该文件解析为整数列表，对其进行快速排序，然后将其写入已排序的其他文件。此文件的格式与未排序的文件相同。简单。

这是Haskell：

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))

这是Python：

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()

很简单。现在我用

编译Haskell代码 
$ ghc -O2 --make quick.hs

我和那两个人在一起时间：

$ time ./quick
$ time python qs.py

结果：

Haskell中：

real    0m10.820s
user    0m10.656s
sys 0m0.154s

的Python：

real    0m9.888s
user    0m9.669s
sys 0m0.203s

Python如何可能比本机代码Haskell更快？

由于

修改：

  • Python版本：2.7.1
  • GHC版本：7.0.4
  • Mac OSX，10.7.3
  • 2.4GHz Intel Core i5

由

生成的列表 
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()

所以所有数字都是唯一的。

7 个答案:

答案 0 :(得分：49)

原始Haskell代码

Haskell版本存在两个问题：

  • 您正在使用字符串IO，它会构建链接的字符列表
  • 您正在使用看起来像快速排序的非快速排序。

此程序在我的Intel Core2 2.5 GHz笔记本电脑上运行需要18.7秒。 （GHC 7.4使用-O2）

Daniel的ByteString版本

这有很大改进，但请注意它仍然使用低效的内置合并排序。

他的版本花了8.1秒（并没有处理负数，但这对于这次探索来说更不是问题。）

注意

此处的答案使用以下软件包：Vector，attoparsec，text和vector-algorithms。另请注意，使用timsort的kindall版本在我的机器上需要2.8秒（编辑：使用pypy需要2秒）。

文字版

我扯掉了Daniel的版本，将其翻译为Text（因此它处理了各种编码）并使用ST monad中的可变Vector添加了更好的排序：

import Data.Attoparsec.Text.Lazy
import qualified Data.Text.Lazy as T
import qualified Data.Text.Lazy.IO as TIO
import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Algorithms.Intro as I
import Control.Applicative
import Control.Monad.ST
import System.Environment (getArgs)

parser = many (decimal <* char '\n')

main = do
    numbers <- TIO.readFile =<< fmap head getArgs
    case parse parser numbers of
        Done t r | T.null t -> writeFile "sorted" . unlines
                                                  . map show . vsort $ r
        x -> error $ Prelude.take 40 (show x)

vsort :: [Int] -> [Int]
vsort l = runST $ do
        let v = V.fromList l
        m <- V.unsafeThaw v
        I.sort m
        v' <- V.unsafeFreeze m
        return (V.toList v')

这在4秒内运行（也不处理否定）

返回Bytestring

所以现在我们知道我们可以制作一个更快速的通用程序，那么如何快速制作ASCii -only版本呢？没问题！

import qualified Data.ByteString.Lazy.Char8 as BS
import Data.Attoparsec.ByteString.Lazy (parse,  Result(..))
import Data.Attoparsec.ByteString.Char8 (decimal, char)
import Control.Applicative ((<*), many)
import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Algorithms.Intro as I
import Control.Monad.ST


parser = many (decimal <* char '\n')

main = do
    numbers <- BS.readFile "rands"
    case parse parser numbers of
        Done t r | BS.null t -> writeFile "sorted" . unlines
                                                   . map show . vsort $ r

vsort :: [Int] -> [Int]
vsort l = runST $ do
        let v = V.fromList l
        m <- V.unsafeThaw v
        I.sort m
        v' <- V.unsafeFreeze m
        return (V.toList v')

这将在2.3秒内完成。

制作测试文件

万一有人好奇，我的测试文件是由：

生成的 
import Control.Monad.CryptoRandom
import Crypto.Random
main = do
  g <- newGenIO :: IO SystemRandom
  let rs = Prelude.take (2^20) (map abs (crandoms g) :: [Int])
  writeFile "rands" (unlines $ map show rs)

如果你想知道为什么vsort没有以更简单的形式打包在Hackage上......我也是。

答案 1 :(得分：40)

简而言之，请勿使用read。将read替换为如下函数：

import Numeric

fastRead :: String -> Int
fastRead s = case readDec s of [(n, "")] -> n

我获得了相当快的加速：

~/programming% time ./test.slow
./test.slow  9.82s user 0.06s system 99% cpu 9.901 total
~/programming% time ./test.fast
./test.fast  6.99s user 0.05s system 99% cpu 7.064 total
~/programming% time ./test.bytestring
./test.bytestring  4.94s user 0.06s system 99% cpu 5.026 total

只是为了好玩，上面的结果包括一个使用ByteString的版本（因此完全无视文件编码的问题，因此无法完成“21世纪的准备”测试），以获得ULTIMATE BARE-METAL SPEED。它还有一些其他的差异;例如，它发送到标准库的排序函数。完整的代码如下。

import qualified Data.ByteString as BS
import Data.Attoparsec.ByteString.Char8
import Control.Applicative
import Data.List

parser = many (decimal <* char '\n')

reallyParse p bs = case parse p bs of
    Partial f -> f BS.empty
    v -> v

main = do
    numbers <- BS.readFile "data"
    case reallyParse parser numbers of
        Done t r | BS.null t -> writeFile "sorted" . unlines . map show . sort $ r

答案 2 :(得分：30)

更多的是Pythonista而不是Haskellite，但我会采取刺：

  1. 在您测量的运行时只需读取和写入文件就会产生相当大的开销，这两个程序之间可能非常相似。另外，请注意，您已为这两个程序预热了缓存。

  2. 您的大部分时间都花在制作列表和列表片段的副本上。 Python列表操作经过了大量优化，是该语言中最常用的部分之一，列表推导通常也非常高效，大部分时间都花在Python解释器的C-land中。 Python中没有很多东西很慢但在静态语言中很快就会出现问题，例如对象实例上的属性查找。

  3. 您的Python实现会丢弃与数据透视表相同的数字，因此最终它可能会对较少的项目进行排序，从而使其具有明显的优势。 （如果您正在排序的数据集中没有重复项，这不是问题。）修复此错误可能需要在每次调用qs()时制作大部分列表的另一个副本，这会降低Python的速度再多一点。

  4. 您没有提到您正在使用的Python版本。如果您使用的是2.x，那么只需切换到Python 3.x就可以让Haskell击败Python。 ： - ）

    5. 我并不感到惊讶，这两种语言在这里基本上是一对一的（10％的差异并不值得注意）。使用C作为性能基准测试，Haskell因其懒惰的功能性质而失去了一些性能，而Python由于是一种解释性语言而失去了一些性能。一场不错的比赛。

    由于Daniel Wagner使用内置的sort发布了优化的Haskell版本，因此这是使用list.sort()的类似优化的Python版本：

    mylist = [int(x.strip()) for x in open("data")]
mylist.sort()
open("sorted", "w").write("\n".join(str(x) for x in mylist))
    在我的机器上

    3.5秒，而原始代码约为9秒。几乎仍然与优化的Haskell并驾齐驱。原因：它将大部分时间花在C编程库中。此外，TimSort（Python中使用的那种）是野兽。

答案 3 :(得分：9)

这是事后的事，但我认为大部分麻烦都在Haskell写作中。以下模块非常原始 - 可能应该使用构建器并且肯定会避免通过String进行显示的荒谬往返 - 但它很简单，并且比使用kindall改进的python的pypy明显更好，并且比其他地方的2和4秒Haskell模块更好在这个页面上（它让我感到惊讶的是他们使用了多少列表，所以我又做了几次曲柄。）

$ time aa.hs        real    0m0.709s
$ time pypy aa.py   real    0m1.818s
$ time python aa.py real    0m3.103s

我正在使用推荐用于矢量算法的未装箱矢量。以某种形式使用Data.Vector.Unboxed显然现在是做这种事情的标准，天真的方式 - 它是新的Data.List（用于Int，Double等）除了sort之外的所有东西令人恼火的IO管理，特别是在写端，我认为仍然可以大大改进。读取和排序一起大约需要0.2秒，因为你可以看到它要求它打印一堆索引而不是写入文件，因此写入的时间是其他任何时间的两倍。如果pypy花费大部分时间使用timsort或其他任何东西，那么看起来排序本身在Haskell中肯定会更好，而且就像你可以直接拿到这个darned向量一样......

我不确定为什么没有方便的函数来从自然格式读取和写入未装箱的东西的向量 - 如果有的话，这将是三行长并且会避免String并且要快得多，但也许我只是没见过他们。 

import qualified Data.ByteString.Lazy.Char8 as BL
import qualified Data.ByteString.Char8 as B
import qualified Data.Vector.Unboxed.Mutable as M
import qualified Data.Vector.Unboxed as V
import Data.Vector.Algorithms.Radix 
import System.IO

main  = do  unsorted <- fmap toInts (BL.readFile "data")
            vec <- V.thaw unsorted
            sorted <- sort vec >> V.freeze vec
            withFile "sorted" WriteMode $ \handle ->
               V.mapM_ (writeLine handle) sorted

writeLine :: Handle -> Int -> IO ()
writeLine h int = B.hPut h $ B.pack (show int ++ "\n")

toInts :: BL.ByteString -> V.Vector Int
toInts bs = V.unfoldr oneInt (BL.cons ' ' bs) 

oneInt :: BL.ByteString -> Maybe (Int, BL.ByteString)
oneInt bs = if BL.null bs then Nothing else 
               let bstail = BL.tail bs
               in if BL.null bstail then Nothing else BL.readInt bstail

答案 4 :(得分：2)

要跟进@kindall有趣的答案，这些时间取决于您使用的python / Haskell实现，运行测试的硬件配置以及您在两种语言中使用的算法实现。

尽管如此，我们可以尝试获得一些语言实现相对于另一种语言实现或从一种语言到另一种语言的相对性能的一些好的提示。有了像qsort这样众所周知的算法，这是一个很好的开始。

为了说明python / python比较，我刚刚在同一台机器上测试了CPython 2.7.3和PyPy 1.8上的脚本：

  • CPython：~8s
  • PyPy：~2.5s

这表明语言实现可能存在改进的空间，可能编译Haskell最多不能执行相应代码的解释和编译。如果您在Python中搜索速度，请考虑在需要时切换到pypy，如果您的覆盖代码允许您这样做。

答案 5 :(得分：2)

我注意到其他人因某种原因没有注意到的问题;你的haskell和python代码都有这个。 （请告诉我，如果它在自动优化中得到修复，我对优化一无所知）。为此我将在haskell演示。 在您的代码中，您可以定义较小和较大的列表，如下所示：

where lesser = filter (<p) xs
      greater = filter (>=p) xs

这很糟糕，因为你将ps中的每个元素与p进行两次比较，一次用于获取较小的列表，一次用于获取更大的列表。这（理论上;我没有检查时间）使你的排序使用两次同样多的比较;这是一场灾难。相反，您应该创建一个函数，使用谓词将列表拆分为两个列表，其方式为

split f xs

相当于

(filter f xs, filter (not.f) xs)

使用这种功能，你只需要比较列表一次中的每个元素，就可以知道要放在元组的哪一侧。
好吧，让我们这样做：

where
    split :: (a -> Bool) -> [a] -> ([a], [a])
    split _ [] = ([],[])
    split f (x:xs)
        |f x       = let (a,b) = split f xs in (x:a,b)
        |otherwise = let (a,b) = split f xs in (a,x:b)

现在让我们用

替换较小/较大的发电机 
let (lesser, greater) = split (p>) xs in (insert function here)

完整代码：

quicksort :: Ord a => [a] -> [a]
quicksort []     = []
quicksort (p:xs) =
    let (lesser, greater) = splitf (p>) xs
    in (quicksort lesser) ++ [p] ++ (quicksort greater)
    where
        splitf :: (a -> Bool) -> [a] -> ([a], [a])
        splitf _ [] = ([],[])
        splitf f (x:xs)
            |f x       = let (a,b) = splitf f xs in (x:a,b)
            |otherwise = let (a,b) = splitf f xs in (a,x:b)

由于某种原因，我不能在where子句中使用getter / less部分，所以我必须在let子句中使用它。 另外，如果它不是尾递归让我知道并为我修复它（我还不知道尾部回溯如何完全工作）

现在你应该为python代码做同样的事情。我不知道python所以我不能为你做。

修改 实际上在Data.List中已经有这样的函数叫做partition。请注意，这证明需要这种功能，否则将无法定义。 这会将代码缩小为：

quicksort :: Ord a => [a] -> [a]
quicksort []     = []
quicksort (p:xs) =
    let (lesser, greater) = partition (p>) xs
    in (quicksort lesser) ++ [p] ++ (quicksort greater)

答案 6 :(得分：1)

Python真的针对这类事情进行了优化。我怀疑Haskell不是。这是一个similar question，提供了一些非常好的答案。

相关问题
最新问题