Python vs CPP：为什么速度差异如此之大？

Question

def main():
    i = 2
    sum = 1
    while i < 100000:
        j = 2
        while j < i:
            if i%j == 0:
                sum += 1
                break
            j += 1
        i += 1

    print(sum)


if __name__ == "__main__":
    main()



#include<iostream>

using namespace std;

int main() {
    int sum = 1;
    for (int i=2; i<100000; i++) {
        for (int j=2; j<i; j++) {
            if (i%j == 0) {
                sum++;
                break;
            }
        }
    }
    cout << sum << endl;
    return 0;
}

C ++

运行： g++ -std=c++11 x.cpp -o x && time ./x

时间： ./x 1.36s user 0.00s system 99% cpu 1.376 total

蟒蛇

运行： python x.py

时间： python x.py 32.10s user 0.21s system 98% cpu 32.854 total

谁能解释两个程序所花费的时间之间的巨大差异？怎样才能加快python的速度呢？

Answer 1

这是区别的一个简单示例：

i++在C 中，C 可以编译成简单的inc REGISTER指令（在x86-64机器上）。只需执行一小部分周期即可执行。

i += 1可以使用dis模块中的Python进行反汇编，通过dis.dis('i += 1')该模块可以通知我们所涉及的字节码为：

  1           0 LOAD_NAME                0 (i)
              2 LOAD_CONST               0 (1)
              4 INPLACE_ADD
              6 STORE_NAME               0 (i)
              8 LOAD_CONST               1 (None)
             10 RETURN_VALUE

在线尝试！

从技术上讲，所有的指令，在最终_NAME成为_FAST一个功能（我们拆开一个孤立的语句，所以它的表现略有不同），和LOAD_CONST (None)/RETURN_VALUE对将不是在一个真正的函数表达式存在（该功能必须这样做，但并非针对每个表达式），但足够接近。实际上，函数中的实际字节码将更像是：

  1           0 LOAD_FAST                0 (i)
              2 LOAD_CONST               0 (1)
              4 INPLACE_ADD
              6 STORE_FAST               0 (i)

这些指令中的每条指令都需要遍历一条switch语句或经过计算goto（取决于CPython的编译方式），加载下一条指令并更新代码位置信息（它还涉及反复检查以确保没有其他线程在请求GIL）。LOAD_FAST并且LOAD_CONST指令涉及到C数组查找和参考计数调整（单个参考计数调整仅i++与以前相同，不同之处在于它必须更改内存而不是寄存器，因此速度较慢）。STORE_FAST类似地，还涉及C数组查找，引用计数调整（以减小现有值），并经常释放内存（如果decref删除了对该值的最后一个引用）。
INPLACE_ADD必须动态查找并调用函数指针来执行加法（首先是通过几层函数间接实现），该过程本身必须提取每个Python的基础C值int才能完成工作（如果数字足够大，这涉及到基于数组的数学运算，这很丑陋），（通常）创建一个全新的Pythonint对象，并且还要进行更多的引用计数调整。

基本上，为了获得与C / C
在针对寄存器的单个廉价汇编指令中所做的等效操作，Python必须执行（估计）六个函数调用（包括一个通过函数指针的调用），数十个内存查找，一个一打左右的引用计数调整等。坦率地说，最令人惊讶的是Python所花的时间仅比C

长约24倍。

我会注意到，这里的 相对 成本对于简单的数学运算而言最高。单个字节码执行的工作越多，解释器开销的重要性就越小。不幸的是，这种情况下，你的代码是什么
，但 简单的数学，所以Python（至少，CPython的）是在最坏的情况在这里。

至于加快速度，主要规则是：

1. 编写Python代码，而不是C代码。当Pythonrange可以为您完成这项工作时，您正在手动维护计数器（并节省了大量单独的字节码指令）。正如我所提到的，这是解释器开销最高的最简单，最便宜的操作，但是这些操作通常是您实际上不需要做的事情，因为通常有更好的方法（例如，for循环range而不是while手动计数器调整循环）。
2. 对于大规模数学运算，请使用可以批量完成工作的扩展模块，例如numpy。一次添加的所有开销都是不好的；支付1000个附加费是微不足道的。
3. 尝试其他口译员（例如PyPy）
4. 使用Cython从您的Python代码编译C ++（需要添加适当的cdef声明）
5. 使用ctypes调用现有的C库，和/或写入原始Python的C扩展（当用Cython不能处理你想要的）

除此之外，您只需要接受动态类型的解释型语言总是会产生编译型，静态类型化语言所没有的开销。

要解决第1点，您的代码的Python版本应如下所示：

def main():
    sum = 1
    for i in range(2, 100000):
        for j in range(2, i):
            if i%j == 0:
                sum += 1
                break

    print(sum)

if __name__ == "__main__":
    main()

您甚至可以将内部循环替换为：

    sum += any(i % j == 0 for j in range(2, i))

尽管这不太可能带来任何性能上的好处，但是只是简化了一点代码。使用可以带来性能优势range，它将增量和测试的所有基本数学运算捆绑到一个专用函数中，从而显着减少了开销。

为了说明字节码复杂度的不同，请考虑一个仅执行以下操作的函数，该函数使用while和以及手动计数器或for和进行循环range：

def whileloop(n):
    i = 0
    while i < n:
        i += 1

def forloop(n):
    for i in range(n):
        pass

分解每个功能显示：

  3           0 LOAD_CONST               1 (0)
              2 STORE_FAST               1 (i)

  4           4 SETUP_LOOP              20 (to 26)
        >>    6 LOAD_FAST                1 (i)
              8 LOAD_FAST                0 (n)
             10 COMPARE_OP               0 (<)
             12 POP_JUMP_IF_FALSE       24

  5          14 LOAD_FAST                1 (i)
             16 LOAD_CONST               2 (1)
             18 INPLACE_ADD
             20 STORE_FAST               1 (i)
             22 JUMP_ABSOLUTE            6
        >>   24 POP_BLOCK
        >>   26 LOAD_CONST               0 (None)
             28 RETURN_VALUE

为whileloop和：

  8           0 SETUP_LOOP              16 (to 18)
              2 LOAD_GLOBAL              0 (range)
              4 LOAD_FAST                0 (n)
              6 CALL_FUNCTION            1
              8 GET_ITER
        >>   10 FOR_ITER                 4 (to 16)
             12 STORE_FAST               1 (i)

  9          14 JUMP_ABSOLUTE           10
        >>   16 POP_BLOCK
        >>   18 LOAD_CONST               0 (None)
             20 RETURN_VALUE

在线尝试！

为forloop。循环的主体（每次遍历执行一次，包括测试终止条件的东西），用于while从LOAD_FAST以下SETUP_LOOP到的运行JUMP_ABSOLUTE，每个循环包含9条指令；对于for，它从FOR_ITER到运行JUMP_ABSOLUTE，仅包含三个指令。由于所有这些指令的工作都很琐碎，因此很容易看到对于带有while循环的手动管理的计数器来说，循环本身的开销将如何显着增加。