python - 为什么 Python 和 Ruby 这么慢，而 Lisp 实现却快？

Question

我发现，在 Python 和 Ruby 中，函数调用和循环等简单的事情，甚至只是增加计数器的循环，比在 Chicken Scheme、Racket 或 SBCL 中花费的时间远多。

为什么会这样？我经常听到人们说慢是你为动态语言付出的代价，但是 Lisps 非常动态，而且速度也不是很慢(它们通常比 C 慢不到 5 倍；Ruby 和 Python 可以达到两位数)。此外，Lisp 风格使用递归，并不总是尾递归，很多，堆栈是堆中延续的链表等，这似乎是应该使 Lisp 比命令式 Python 和 Ruby 慢的东西。

Racket 和 SBCL 是 JITted，但是 Chicken Scheme 要么是静态编译的，要么使用非优化的解释器，这两者都应该非常不适合动态语言并且速度很慢。然而，即使对 Chicken Scheme 使用简单的 csi 解释器(它甚至不进行字节码编译!)，我的速度也远远超过 Python 和 Ruby。

与同样动态的 Lisps 相比，为什么 Python 和 Ruby 速度如此之慢？是因为它们是面向对象的并且需要巨大的 vtable 和类型层次结构吗？

示例:阶乘函数。 python :

def factorial(n):
    if n == 0:
        return 1
    else:
    return n*factorial(n-1)

for x in xrange(10000000):
    i = factorial(10)

Racket :

#lang racket

(define (factorial n)
  (cond
   [(zero? n) 1]
   [else (* n (factorial (sub1 n)))]))

(define q 0)

(for ([i 10000000])
  (set! q (factorial 10)))

计时结果:

ithisa@miyasa /scratch> time racket factorial.rkt
racket factorial.rkt  1.00s user 0.03s system 99% cpu 1.032 total
ithisa@miyasa /scratch> time python factorial.py
python factorial.py  13.66s user 0.01s system 100% cpu 13.653 total

Answer 1

本地编译的 Lisp 系统通常比非本地编译的 Lisp、Ruby 或 Python 实现快很多。

定义:

• native 编译 -> 编译为机器码
• 已编译 -> 编译为机器码或其他目标(如字节码、JVM 指令、C 代码……)
• 解释 Lisp -> 无需编译直接运行 s 表达式
• 解释的 Python -> 在字节码解释器中运行编译后的 Python。默认的 Python 实现并没有真正解释，而是使用编译器对字节码指令集进行编译。字节码被解释。通常字节码解释器比执行 native 代码慢。

但请记住以下几点:

• SBCL 使用 native 代码编译器。它确实不使用字节码机器或类似 JIT 编译器的东西从字节码到 native 代码。 SBCL 在运行前将所有代码从源代码编译为 native 代码。编译器是增量的，可以编译单个表达式。因此它也被 EVAL 函数和 Read-Eval-Print-Loop 使用。
• SBCL 使用优化编译器，该编译器利用类型声明和类型推断。编译器生成 native 代码。
• Common Lisp 允许进行各种优化，从而降低代码的动态性或非动态性(内联、早期绑定(bind)、无类型检查、专用于声明类型的代码、尾调用优化……)。利用这些高级功能的代码可能看起来很复杂 - 尤其是当需要告知编译器这些事情时。
• 如果没有这些优化，编译的 Lisp 代码仍然比解释代码快，但比优化的编译代码慢。
• Common Lisp 提供了 CLOS，即 Common Lisp 对象系统。 CLOS 代码通常比非 CLOS 慢——这种比较是有意义的。动态函数式语言往往比动态面向对象语言更快。
• 如果语言实现使用高度优化的运行时(例如对于 bignum 算术运算)，则慢速语言实现可能比优化编译器更快。有些语言有许多用 C 实现的复杂原语。这些原语往往很快，而其他语言可能非常慢。
• 也可以有 Python 的实现，它们生成和运行机器代码，例如 PyPy 的 JIT 编译器。自 Ruby 2.6 起，Ruby 现在也有了 JIT 编译器。

此外，有些操作可能看起来相似，但可能有所不同。迭代整数变量的 for 循环真的与迭代范围的 for 循环相同吗？