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

运行：python x.py

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

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

Answer 1

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

C ++中的

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

Python中的

i += 1可以通过dis与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

Try it online!

从技术上讲，所有以_NAME结尾的指令都变成函数中的_FAST（我们分解了一个孤立的语句，因此其行为略有不同），以及LOAD_CONST (None) / {{1实函数中的表达式将不存在对（该函数必须执行此操作，但不是每个表达式都必须这样做），但必须足够接近。实际上，函数中的实际字节码更像是：

RETURN_VALUE

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

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

我会注意到，对于简单的数学运算，此处的相对成本最高；单个字节码执行的工作越多，解释器开销的重要性就越小。不幸的是，对于这种情况，您的代码只是简单的数学运算，因此Python（至少是CPython）在这里最糟糕。

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

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

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

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

numpy

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

cdef

尽管这不太可能产生任何性能上的好处，只是简化了一点代码。使用ctypes可以提高性能，它将所有增量和测试的基本数学捆绑到一个专用函数中，从而大大减少了开销。

为演示字节码复杂度的差异，请考虑一个仅执行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

Try it online!

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，仅包含三个指令。由于所有这些指令的工作都很琐碎，因此很容易看出使用for循环进行手动管理的计数器，循环本身的开销将显着增加。

Answer 2

[SO]: Python vs CPP: Why is the difference in speed so huge? (@ShadowRanger's answer)很好地解释了为什么（幕后发生的理性）。这是我逐步完成的一些尝试。

设置：

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

[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
dll0.cpp  dll1.cpp  main.cpp  script00.py  script01.py  script02.py  script03.py  script04.py

C ++ （0）：

将代码分成2个文件（稍后您将了解原因）。

dll0.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 func() {
    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;
}

main.cpp ：

#include "dll0.cpp"


int main() {
    return func();
}

输出：

[prompt]> g++ -std=c++11 main.cpp -o main0
[prompt]>
[prompt]> time ./main0
90407

real    0m1.384s
user    0m1.359s
sys     0m0.000s

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

script01.py ：

通过 for （使用 range ）替换了（无效的） while 循环。

#!/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

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

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 代码还要好。

< / li>

C ++ （1）：

上一步对算法本身进行操作。还要更改 C ++ 变体，否则比较会不公平。

dll1.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 func() {
    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

main.cpp 必须（显然）必须进行相应的修改（#include "dll1.cpp"）。

输出：

[prompt]> g++ -std=c++11 main.cpp -o main1
[prompt]>
[prompt]> time ./main1
90407

real    0m0.279s
user    0m0.250s
sys     0m0.030s

通过[Python 3.Docs]: ctypes - A foreign function library for Python从 Python 调用 C ++ 代码（ C 接口）：

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

script04.py ：

#!/usr/bin/env python3

import ctypes


def main():
    dll = ctypes.CDLL("./dll1.so")
    func = dll.func
    func.argtypes = []
    func.restype = ctypes.c_int
    func()


if __name__ == "__main__":
    main()

输出：

[prompt]> g++ -std=c++11 -fPIC -shared dll1.cpp -o dll1.so
[prompt]>
[prompt]> time python3 script04.py
90407

real    0m0.327s
user    0m0.281s
sys     0m0.031s

结论（从上述示例中得出）：

我已经将每个步骤运行了3次，并将中间结果放在这里。但是，具有有意义结果的测试应运行数千次，并应计算平均值。另外，我正在使用 Cygwin 的事实可能会干扰结果
编写 Python ic代码，性能几乎提高了2倍（ ＃4。 ， ＃5 。 ）
编写一种有效的算法，将两种语言之间的差异几乎减小到了0（ ＃6。 vs。 ＃7。 ）和（纯） Python 代码似乎比 ＃8。 < / strong>。
但是，不要让自己被这些事实欺骗。事实证明，如果操作数量增加（并且由于效率低而不一定），则 C ++ 的运行速度会更快。
您可以通过对 dll0.cpp

应用步骤 ＃8。 进行检查。

Answer 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，它也以毫秒为单位。

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

C ++

Python

3 个答案: