经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » Python » 查看文章
为什么 Python 代码在函数中运行得更快?
来源:cnblogs  作者:咸鱼Linux运维  时间:2023/9/20 9:31:34  对本文有异议

哈喽大家好,我是咸鱼

当谈到编程效率和性能优化时,Python 常常被调侃为“慢如蜗牛”

有趣的是,Python 代码在函数中运行往往比在全局范围内运行要快得多

小伙伴们可能会有这个疑问:为什么在函数中运行的 Python 代码速度更快?

今天这篇文章将会解答大家心中的疑惑

原文链接:https://stackabuse.com/why-does-python-code-run-faster-in-a-function/

译文

要理解为什么 Python 代码在函数中运行得更快,我们需要首先了解 Python 是如何执行代码的

我们知道,python 是一种解释型语言,它会逐行读取并执行代码

当运行一个 python 程序的时候,首先将代码编译成字节码(一种更接近机器码的中间语言)然后 python 解释器执行字节码

  1. def hello_world():
  2. print("Hello, World!")
  3. import dis
  4. dis.dis(hello_world)
  1. #结果
  2. 2 0 LOAD_GLOBAL 0 (print)
  3. 2 LOAD_CONST 1 ('Hello, World!')
  4. 4 CALL_FUNCTION 1
  5. 6 POP_TOP
  6. 8 LOAD_CONST 0 (None)
  7. 10 RETURN_VALUE

由上所示,python 中的 dis 模块将函数 hello_world 分解为字节码

需要注意的是,python 解释器是一个执行字节码的虚拟机,默认的 python 解释器是用 C 编写的,即 CPython

还有其他的 python 解释器如 Jython(用 Java 编写),IronPython(用于 .net)和PyPy(用 Python 和 C 编写)

为什么 Python 代码在函数中运行得更快

我们来编写一个简单的例子:定义一个函数 my_function,函数内部包含一个 for 循环

  1. def my_function():
  2. for i in range(100000000):
  3. pass

编译该函数的时候,字节码可能如下所示

  1. SETUP_LOOP 20 (to 23)
  2. LOAD_GLOBAL 0 (range)
  3. LOAD_CONST 3 (100000000)
  4. CALL_FUNCTION 1
  5. GET_ITER
  6. FOR_ITER 6 (to 22)
  7. STORE_FAST 0 (i)
  8. JUMP_ABSOLUTE 13
  9. POP_BLOCK
  10. LOAD_CONST 0 (None)
  11. RETURN_VALUE

这里的关键指令是 STORE_FAST ,用于存储循环变量 i

现在我们把这个 for 循环放在 python 脚本的顶层(全局范围内),然后再来看一下字节码

  1. for i in range(100000000):
  2. pass
  1. SETUP_LOOP 20 (to 23)
  2. LOAD_NAME 0 (range)
  3. LOAD_CONST 3 (100000000)
  4. CALL_FUNCTION 1
  5. GET_ITER
  6. FOR_ITER 6 (to 22)
  7. STORE_NAME 1 (i)
  8. JUMP_ABSOLUTE 13
  9. POP_BLOCK
  10. LOAD_CONST 2 (None)
  11. RETURN_VALUE

可以看到关键指令变成了 STORE_NAME,而不是 STORE_FAST

字节码 STORE_FASTSTORE_NAME 快,因为在函数中,局部变量存储在固定长度的数组中,而不是存储在字典中。这个数组可以通过索引直接访问,使得变量检索非常快

基本上,它只是一个指向列表的指针,并增加了 PyObject 的引用计数,这两个都是高效的操作

另一方面,全局变量存储在一个字典。当访问全局变量时,Python 必须执行哈希表查找,这涉及计算哈希值,然后检索与之关联的值

虽然经过优化,但仍然比基于索引的查找慢

基准测试验证

我们知道在 Python 中,代码执行的速度取决于代码执行的位置——在函数中还是在全局作用域中

让我们用一个简单的基准测试的例子来比较一下

首先定义一个求阶乘的函数

  1. def factorial(n):
  2. result = 1
  3. for i in range(1, n + 1):
  4. result *= i
  5. return result

然后在全局范围内执行相同的代码

  1. n = 20
  2. result = 1
  3. for i in range(1, n + 1):
  4. result *= i

为了对这两段代码进行基准测试,我们可以在 Python 中使用 timeit 模块,它提供了一种简单的方法来对少量 Python 代码进行计时

  1. import timeit
  2. # 函数
  3. def benchmark():
  4. start = timeit.default_timer()
  5. factorial(20)
  6. end = timeit.default_timer()
  7. print(end - start)
  8. benchmark()
  9. # Prints: 3.541994374245405e-06
  10. # 全局范围
  11. start = timeit.default_timer()
  12. n = 20
  13. result = 1
  14. for i in range(1, n + 1):
  15. result *= i
  16. end = timeit.default_timer()
  17. print(end - start)
  18. # Pirnts: 5.375011824071407e-06

可以看到,函数代码的执行速度比全局作用域代码要快

需要注意的是,这两段代码最好不要放在同一脚本中,要分开单独运行

这是因为 benchmark() 函数在执行时间上增加了一些开销,并且全局代码在内部进行了优化

cProfile 分析

python 提供了一个 cProfile 内置模块

让我们用它来分析一个新例子:在局部和全局范围内计算平方和

  1. import cProfile
  2. def sum_of_squares():
  3. total = 0
  4. for i in range(1, 10000000):
  5. total += i * i
  6. i = None
  7. total = 0
  8. def sum_of_squares_g():
  9. global i
  10. global total
  11. for i in range(1, 10000000):
  12. total += i * i
  13. def profile(func):
  14. pr = cProfile.Profile()
  15. pr.enable()
  16. func()
  17. pr.disable()
  18. pr.print_stats()
  19. #
  20. # Profile function code
  21. #
  22. print("Function scope:")
  23. profile(sum_of_squares)
  24. #
  25. # Profile global scope code
  26. #
  27. print("Global scope:")
  28. profile(sum_of_squares_g)

上面的例子中,可以认为sum_of_squares_g() 函数是全局的,因为它使用了两个全局变量, itotal

从性能分析结果中,可以看到函数代码在执行时间方面比全局更有效

  1. Function scope:
  2. 2 function calls in 0.903 seconds
  3. Ordered by: standard name
  4. ncalls tottime percall cumtime percall filename:lineno(function)
  5. 1 0.903 0.903 0.903 0.903 profiler.py:3(sum_of_squares)
  6. 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}
  7. Global scope:
  8. 2 function calls in 1.358 seconds
  9. Ordered by: standard name
  10. ncalls tottime percall cumtime percall filename:lineno(function)
  11. 1 1.358 1.358 1.358 1.358 profiler.py:10(sum_of_squares_g)
  12. 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}

如何优化 python 函数的性能

前面我们知道,Python 代码在函数中运行往往比在全局范围内运行要快得多

如果想要进一步提高 python 函数代码效率,不妨考虑一下使用局部变量而不是全局变量

另一种方法是尽可能使用内置函数和库。Python 的内置函数是用 C 实现的,比 Python 快得多

比如 NumPy 和 Pandas,也是用 C 或 C++ 实现的,它们比实现同样功能的 Python 代码速度更快

又比如同样是实现数字求和的功能,python 内置的 sum 函数要比你自己编写函数速度更快

原文链接:https://www.cnblogs.com/edisonfish/p/17715522.html

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号