【问题标题】:Python vs CPP: Why is the difference in speed so huge?Python vs CPP:为什么速度差异如此之大?
【发布时间】:2019-11-24 10:48:36
【问题描述】:
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 &amp;&amp; time ./x

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

Python

运行:python x.py

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

谁能解释这两个程序所花费的时间之间的巨大差异?可以做些什么来加快 python 的速度?

【问题讨论】:

标签: python c++ performance


【解决方案1】:

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

C++ 中的i++ 编译为(在 x86-64 机器上)一个简单的 inc REGISTER 指令。需要一小部分周期来执行。

Python 中的i += 1 可以通过dis.dis('i += 1') 使用dis 模块进行反汇编,这告诉我们所涉及的字节码是:

  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

Try it online!

从技术上讲,所有以_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 的编译方式),加载下一条指令并更新代码位置信息(它还涉及重复检查以确保没有其他线程要求the GIL)。 LOAD_FASTLOAD_CONST 指令涉及 C 数组查找和引用计数调整(单独的单个引用计数调整相当于之前的 i++,除了它必须更改内存,而不是寄存器,因此速度较慢)。 STORE_FAST 类似地涉及 C 数组查找、引用计数调整(以减少现有值)以及通常释放内存(如果 decref 删除了对该值的最后一个引用)。 INPLACE_ADD 必须动态查找并调用函数指针来执行加法(它首先通过几层函数间接实现),它本身必须提取每个 Python int 的底层 C 值到做这项工作(如果数字足够大,这涉及到基于数组的数学,这会变得很难看),(通常)创建一个全新的 Python int 对象,并进行更多的引用计数调整。

基本上,为了获得与 C/C++ 在针对寄存器的单个廉价汇编指令中所做的等效,Python 必须执行(估计)六个函数调用(包括通过函数指针的一个),数十个内存查找、十几个引用计数调整等。坦率地说,最令人惊讶的是 Python 只需要比 C++ 长约 24 倍的时间。

我会注意到这里的相对成本对于简单的数学运算是最高的;单个字节码所做的工作越多,解释器开销就越不重要。不幸的是,对于这种情况,您的代码只是简单的数学运算,所以 Python(至少是 CPython)在这里是最糟糕的。

至于加速,主要规则是:

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

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


为了解决第 1 点,您的代码的 Pythonic 版本如下所示:

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 和手动计数器或forrange

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

Try it online!

forloopwhile 的循环体(每次循环执行一次,包括测试终止条件)从 LOAD_FASTSETUP_LOOP 之后运行到 JUMP_ABSOLUTE,每个循环包含 9 条指令;对于for,它从FOR_ITER 运行到JUMP_ABSOLUTE,仅包含三个指令。由于为所有这些指令完成的工作非常简单,因此很容易看出对于使用 while 循环的手动管理计数器而言,循环本身的开销会显着增加。

【讨论】:

    【解决方案2】:

    [SO]: Python vs CPP: Why is the difference in speed so huge? (@ShadowRanger's answer) 很好地解释了为什么(发生在幕后的基本原理)。以下是我在(增量)步骤中所做的一些尝试。

    1. 设置:

      操作系统、工具和其他信息。

      [cfati@cfati-5510-0:/cygdrive/e/Work/Dev/StackOverflow/q057044727]> ~/sopr.sh
      *** Set shorter prompt to better fit when pasted in StackOverflow (or other) pages ***
      
      [prompt]> uname -a
      CYGWIN_NT-10.0 cfati-5510-0 3.0.7(0.338/5/3) 2019-04-30 18:08 x86_64 Cygwin
      [prompt]>
      [prompt]> python3 -c "import sys;print(\"Python {0:s} {1:d}bit on {2:s}\".format(\" \".join(item.strip() for item in sys.version.split(\"\n\")), 64 if sys.maxsize > 0x100000000 else 32, sys.platform))"
      Python 3.6.8 (default, Feb 14 2019, 22:09:48) [GCC 7.4.0] 64bit on cygwin
      [prompt]>
      [prompt]> g++ --version | grep g++
      g++ (GCC) 7.4.0
      [prompt]>
      [prompt]> ls
      dll00.cpp  dll01.cpp  main00.cpp  script00.py  script01.py  script02.py  script03.py  script04.py
      
    2. C++ (0):

      将代码拆分为 2 个文件(稍后您将了解原因)。

      dll00.cpp

      #include <iostream>
      
      #if defined(_WIN32)
      #  define DLL_EXPORT_API __declspec(dllexport)
      #else
      #  define DLL_EXPORT_API
      #endif
      
      
      using std::cout;
      using std::endl;
      
      
      DLL_EXPORT_API int func00() {
          int non_primes = 1;
          for (int i = 2; i < 100000; i++) {
              for (int j = 2; j < i; j++) {
                  if (i % j == 0) {
                      non_primes++;
                      break;
                  }
              }
          }
          cout << non_primes << endl;
          return 0;
      }
      

      main00.cpp

      #include "dll00.cpp"
      
      
      int main() {
          return func00();
      }
      

      输出

      [prompt]> g++ -std=c++11 main00.cpp -o main000
      [prompt]>
      [prompt]> time ./main000
      90407
      
      real    0m1.384s
      user    0m1.359s
      sys     0m0.000s
      
    3. script00.py

      您的原始脚本(稍作修正)。

      #!/usr/bin/env python3
      
      
      def main():
          non_primes = 1
          i = 2
          while i < 100000:
              j = 2
              while j < i:
                  if i % j == 0:
                      non_primes += 1
                      break
                  j += 1
              i += 1
          print(non_primes)
      
      
      if __name__ == "__main__":
          main()
      

      输出

      [prompt]> time python3 script00.py
      90407
      
      real    0m53.738s
      user    0m53.703s
      sys     0m0.031s
      
    4. script01.py

      将(低效的)while 循环替换为 for(使用 range)。

      #!/usr/bin/env python3
      
      
      def main():
          non_primes = 1
          for i in range(2, 100000):
              for j in range(2, i):
                  if i % j == 0:
                      non_primes += 1
                      break
          print(non_primes)
      
      
      if __name__ == "__main__":
          main()
      

      输出

      [prompt]> time python3 script01.py
      90407
      
      real    0m34.142s
      user    0m34.124s
      sys     0m0.000s
      
    5. script02.py

      使用Python风格的0相等测试。

      #!/usr/bin/env python3
      
      
      def main():
          non_primes = 1
          for i in range(2, 100000):
              for j in range(2, i):
                  if not i % j:
                      non_primes += 1
                      break
          print(non_primes)
      
      
      if __name__ == "__main__":
          main()
      

      输出

      [prompt]> time python3 script02.py
      90407
      
      real    0m28.440s
      user    0m28.406s
      sys     0m0.031s
      
    6. script03.py

      针对这种情况。寻找除数的效率非常低。它会迭代直到数字本身(实际上它应该只求其平方根),产生大量无用的操作,加深了两种语言之间的性能差距。

      #!/usr/bin/env python3
      
      from math import sqrt
      
      
      def main():
          non_primes = 1
          for i in range(2, 100000):
              for j in range(2, int(sqrt(i) + 1)):
                  if not i % j:
                      non_primes += 1
                      break
          print(non_primes)
      
      
      if __name__ == "__main__":
          main()
      

      输出

      [prompt]> time python3 script03.py
      90407
      
      real    0m0.291s
      user    0m0.265s
      sys     0m0.015s
      

      正如所见,与以前的版本相比,差异巨大(快了近 100 倍),甚至比(原始)C 代码更好。

    7. C++ (1):

      上一步对算法本身进行了操作。 C++ 变量也要改一下,否则比较不公平。

      dll01.cpp

      #include <iostream>
      #include <math.h>
      
      #if defined(_WIN32)
      #  define DLL_EXPORT_API __declspec(dllexport)
      #else
      #  define DLL_EXPORT_API
      #endif
      
      
      using std::cout;
      using std::endl;
      
      
      #if defined(__cplusplus)
      extern "C" {
      #endif
      
      DLL_EXPORT_API int func00() {
          int non_primes = 1;
          for (int i = 2; i < 100000; i++) {
              for (int j = 2; j < static_cast<int>(sqrt(i) + 1); j++) {
                  if (i % j == 0) {
                      non_primes++;
                      break;
                  }
              }
          }
          cout << non_primes << endl;
          return 0;
      }
      
      #if defined(__cplusplus)
      }
      #endif
      

      main00.cpp 必须(显然)进行相应的修改 (#include "dll01.cpp")。

      输出

      [prompt]> g++ -std=c++11 main00.cpp -o main001
      [prompt]>
      [prompt]> time ./main001
      90407
      
      real    0m0.279s
      user    0m0.250s
      sys     0m0.030s
      
    8. 通过[Python 3.Docs]: ctypes - A foreign function library for PythonPython调用C++代码(C接口):

      使用上一步中的 C++ 代码。

      script04.py

      #!/usr/bin/env python3
      
      import ctypes
      
      
      def main():
          dll = ctypes.CDLL("./dll01.so")
          func = dll.func00
          func.argtypes = []
          func.restype = ctypes.c_int
          func()
      
      
      if __name__ == "__main__":
          main()
      

      输出

      [prompt]> g++ -std=c++11 -fPIC -shared dll01.cpp -o dll01.so
      [prompt]>
      [prompt]> time python3 script04.py
      90407
      
      real    0m0.327s
      user    0m0.281s
      sys     0m0.031s
      

    结论(取自以上示例):

    • 我已将每个步骤运行 3 次,并将中间结果放在这里。但是,具有有意义结果的测试应该运行数千次并计算平均值。此外,我使用 Cygwin 的事实可能会干扰结果

    • 编写 Pythonic 代码,性能提高了近 2 倍(#4.#5 .)

    • 编写高效算法,将两种语言之间的差异几乎减少到 0(#6. vs. #7.)和(纯)Python 代码的运行速度似乎比 #8.
      但是,不要让自己被这些事实欺骗。事实证明,如果操作数量增加(并且不一定由于效率低下),C++ 的工作速度会快很多。
      您可以通过将步骤 #8. 应用于 dll00.cpp

    • 来检查这一点

    【讨论】:

    • 只是为了后代,您能否包括您使用的 Python 版本(major.minor,32 位与 64 位)?每隔一段时间,他们就会更改解释器以改进异常缓慢的事情(例如,最近的版本显着降低了仅使用位置参数的方法调用的开销,因此在存在语法解决方案时避免方法调用的一些建议与以前相比不太相关),因此如果能够比较更高版本,例如,使range 更便宜,或者简单的算术,或者与0 的比较,或者其他什么,那就太好了。
    • @ShadowRanger:版本已经存在(在 #1. 中),添加了架构。
    • 谢谢。错过了版本,抱歉!
    【解决方案3】:

    您正在计算诸如非质数之类的东西,直到 n。用筛子这样做会快得多:

    def count_primes(n):
        count = 0
        w = [False]*n
        for m in range(2,n):
            if not w[m]:
                w[m*m::m] = [True] * ((n+m-m*m-1)//m)
                count+=1
        return count
    
    print(99999 - sieve(100000))
    

    这在几毫秒内运行,即使使用 python。

    【讨论】:

    • 虽然如此,但并非所有问题都可以用更好的算法解决;增加你的筛子边界,并同等地优化 C 代码(甚至更好,因为 C 代码可以做各种小技巧来减少内存使用,而不会降低性能,这是 Python 无法比拟的),你会当您提供越来越大的ns 时,发现 CPython 仍然落后。
    • 虽然这是真的,但该算法的大部分是使用C 代码执行的,这使得它以本机速度运行。
    • 是的,它的速度要快很多 ,但即便如此,同等优化的 C 代码也会胜出。我编写了类似的代码(它输出素数本身,而不仅仅是计数,并使用一些技巧来进一步减少每个循环的字节码),并且对于 @ 的输入,超优化的 Python 输给了超优化的 C 约 8 倍987654325@。不要误会我的意思,Python 代码的编写速度快得多,即使有一些荒谬丑陋的优化,仍然更容易阅读/验证。这就是编写 Python 的全部意义所在。它更快更容易编写,但代价是执行速度较慢。
    猜你喜欢
    • 2019-09-13
    • 2012-11-19
    • 1970-01-01
    • 2021-02-25
    • 2013-01-01
    • 1970-01-01
    • 1970-01-01
    • 2012-01-20
    • 2018-11-11
    相关资源
    最近更新 更多