Question

我写了一个简单的斐波纳契测试程序来比较node.js和python的性能。事实证明，python需要5秒才能完成计算，而node.js则以200毫秒结束为什么python在这种情况下表现如此糟糕？

蟒

import time

beg = time.clock()
def fib(n):
    if n <=2:
        return 1
    return fib(n-2) + fib(n-1)

var = fib(35)

end = time.clock()
print var
print end - beg

的node.js

var beg = new Date().getTime();

function fib(n)
{
    if (n <= 2)
        return 1;

    return fib(n-2) + fib(n-1);
}

var f = fib(35);
var end = new Date().getTime();

console.log(f);
console.log(end - beg);

Answer 1

真的不可能像这样建立一个人为的基准，并获得足够有用的结果，以便对速度做出全面的陈述;基准测试非常复杂，在某些情况下，运行时甚至可以完全分解基准测试的一部分，因为他们意识到有更快的方法来完成你想要做的事情。

然而，最重要的是你没有将Python与node.js进行比较，你要比较他们的解释器：CPython到V8。 Python和Javascript有类似的语言特性影响性能（垃圾收集，动态类型，甚至整数堆分配我认为？）所以当你运行这个基准测试时，它实际上是解释器之间的枪战。

在这种背景下，即使像这样的基准测试通常没有价值，但问题“为什么V8比CPython在这种事情上更快”确实有一个答案：这是因为JIT编译器

因此，如果您想进行直接比较，请尝试在PyPy上运行Python代码，PyPy是一个带有JIT的Python解释器。或者尝试在没有JIT的运行时上运行Javascript代码。但是，在那时，您可能会发现基准测试太难而且太复杂而无法使用这样的脚本来判断哪种语言更快。

Answer 2

Node使用JIT compiler，用于注意同一代码块何时使用相同类型的输入运行多次并将其编译为机器代码。 Node甚至可能注意到这是一个纯粹的函数并且内联了一些结果，但是从这种编译器的本质来看，它很难从外部分辨出来。

CPython是一个天真的翻译，会完全按照你的说法去做。然而，正在尝试编写一个名为PyPy的Python JIT（用Python编写，不能少），正如您所看到的，结果很有希望：

$ time python2 fib.py
9227465
python2 fib.py  2.90s user 0.01s system 99% cpu 2.907 total
$ time pypy fib.py
9227465
pypy fib.py  1.73s user 0.03s system 96% cpu 1.816 total

Answer 3

如果你在Python中使用memoized fibonacci函数，你会发现它变得更快：

import time

beg = time.clock()

def memoize(f):
    cache = {}
    def decorated_function(*args):
        if args in cache:
            return cache[args]
        else:
            cache[args] = f(*args)
            return cache[args]
    return decorated_function

@memoize
def fib(n):
    if n <=2:
        return 1
    return fib(n-2) + fib(n-1)

var = fib(35)

end = time.clock()
print(var)
print(end - beg)

您可以在javascript中执行相同操作：

function memoize( fn ) {
    return function () {
        var args = Array.prototype.slice.call(arguments),
            hash = "",
            i = args.length;
        currentArg = null;
        while (i--) {
            currentArg = args[i];
            hash += (currentArg === Object(currentArg)) ?
            JSON.stringify(currentArg) : currentArg;
            fn.memoize || (fn.memoize = {});
        }
        return (hash in fn.memoize) ? fn.memoize[hash] :
        fn.memoize[hash] = fn.apply(this, args);
    };
}

var beg = new Date().getTime();

function fib(n)
{
    if (n <= 2)
        return 1;

    return fib(n-2) + fib(n-1);
}

var f = memoize(fib)(35);
var end = new Date().getTime();

console.log(f);
console.log(end - beg);

看起来javascript方面没有性能提升，这往往表明这里已经存在某种内置的memoization机制。

致谢：http://ujihisa.blogspot.fr/2010/11/memoized-recursive-fibonacci-in-python.html，http://addyosmani.com/blog/faster-javascript-memoization/

Answer 4

我会把它写成评论，但由于我还没有足够的分数这样做，我已经添加了另一个答案。

正如许多答案/评论所提到的pypy，它现在比原始问题的日期晚了几年，我想我会更新最新版本的{{{ 3}}和CPython运行问题中的python代码：

Windows 7 64位，Intel Xeon E5-1607 3GHz
  U：＆gt; python --version
  Python 2.7.5

  U：＆gt; python fib.py
  9227465个
  的 3.54921930198

  U：＆gt; pypy --version
  Python 2.7.3（2cec7296d7fb，2013年11月12日，13：24：40）
  [PyPy 2.2.0与MSC v.1500 32位]

  U：＆gt; pypy fib.py
  9227465个
  的 0.385597246386

因此，在这个微观基准测试中，此时此pypy比pypy快 9次。它仍然看起来像node.js会更快。

干杯，蒂姆。

Answer 5

有一种方法可以通过使用 lru_cache() 装饰器来加速 Cpython 的递归。然后，结果会比 NodeJS 更快。在下面的链接中找到有关递归和 lru_cache() 的更多信息。

https://realpython.com/lru-cache-python/#using-lru_cache-to-implement-an-lru-cache-in-python

https://realpython.com/python-thinking-recursively/

from functools import lru_cache
import time
beg = time.time()

@lru_cache()
def fib(n):     
    if n <=2:        
        return 1 
    return fib(n-2) + fib(n-1)  
var = fib(35)  
end = time.time() 
print (var)
print (end - beg)

C:\Users\steps\Desktop>python dot.py 
9227465
0.0

为什么python在递归时比node.js慢得多

5 个答案: