猛戳加速键:你拥有这些Python加速技能吗?

开发 后端
但其实很多时候,Python的效率并没有达到它应有的速度,有一些让它马达开足的小技巧,一起来学习吧!

本文转载自公众号“读芯术”(ID:AI_Discovery)。

Python有时用起来确实很慢,我敢打赌你肯定抱怨过这一点,尤其是那些用惯了C,C ++或Java的人。

但其实很多时候,Python的效率并没有达到它应有的速度,有一些让它马达开足的小技巧,一起来学习吧!

[[331840]]

1. 避免使用全局变量

  1. import mathsize = 10000 
  2. for x in range(size): 
  3.     for y in range(size): 
  4.         z = math.sqrt(x) + math.sqrt(y) 

许多程序员一开始都会用Python语言编写一些简单的脚本。编写脚本时,通常直接使用全局变量,就像上面这段代码。

但由于全局变量和局部变量的实现方式不同,全局变量中定义的代码要比在函数中定义的函数运行起来慢得多。把脚本语句放入函数中,通常运行速度可提高15%-30%。如下所示:

  1. import mathdef main(): 
  2.     size = 10000 
  3.     for x in range(size): 
  4.         for y in range(size): 
  5.             z = math.sqrt(x) +math.sqrt(y)main() 

2. 避免数据重复

避免无意义的数据复制

  1. def main(): 
  2.     size = 10000 
  3.     for _ in range(size): 
  4.         value = range(size) 
  5.         value_list = [x for x in value] 
  6.         square_list = [x * x for x invalue_list]main() 

这段代码中,value_list完全没有必要,这会创建不必要的数据结构或复制。

  1. def main(): 
  2.     size = 10000 
  3.     for _ in range(size): 
  4.         value = range(size) 
  5.         square_list = [x * x for x invalue]main() 

另一个原因在于Python的数据共享机制过于偏执,没有很好理解或信任内存模型,例如滥用copy.deepcopy()函数。我们可以删除此类代码中的复制操作。

交换值时无需使用中间变量

  1. def main(): 
  2.     size = 1000000 
  3.     for _ in range(size): 
  4.         a = 3 
  5.         b = 5 
  6.         temp = a 
  7.         a = b 
  8.         b = tempmain() 

上述代码在交换值时创建了一个临时变量temp。如果没有中间变量,代码会更加简洁,运行速度也更快。

  1. def main(): 
  2.     size = 1000000 
  3.     for _ in range(size): 
  4.         a = 3 
  5.         b = 5 
  6.         a, bb = b, amain() 

使用字符串联方法join ,而不是'+'

  1. import string 
  2. from typing import Listdef concatString(string_list: List[str]) -> str: 
  3.     result = '' 
  4.     for str_i in string_list: 
  5.         result += str_i 
  6.     return resultdef main(): 
  7.     string_list =list(string.ascii_letters * 100) 
  8.     for _ in range(10000): 
  9.         result =concatString(string_list)main() 

另一要点是a+b对字符串进行拼接,由于在Python中字符串是不可变的对象,所以实际上a和b分别复制到了应用程序的新内存空间中。

因此,如果拼接n个字符串会产生“ n-1”个中间结果,则每个字符串都会产生应用和复制内存所需的中间结果,从而严重影响操作效率。

在使用join()串联字符串时,首先计算需要应用的总内存空间,然后立即申请所需的内存,再把每个字符串元素复制到内存中。

  1. import string 
  2. from typing import Listdef concatString(string_list: List[str]) -> str: 
  3.     return ''.join(string_list)defmain(): 
  4.     string_list = list(string.ascii_letters* 100) 
  5.     for _ in range(10000): 
  6.         result =concatString(string_list)main() 

3. 避免使用以下函数属性

避免访问模块和函数属性

  1. import mathdef computeSqrt(size:int): 
  2.     result = [] 
  3.     for i in range(size): 
  4.         result.append(math.sqrt(i)) 
  5.     return resultdef main(): 
  6.     size = 10000 
  7.     for _ in range(size): 
  8.         result = computeSqrt(size)main() 

use(属性访问运算符)会触发特定方法,例如getattribute()和getattr(),这些方法将执行字典操作,会产生额外的时间消耗。

通过使用import语句,可以消除属性访问:

  1. from math import sqrtdefcomputeSqrt(size: int): 
  2.     result = [] 
  3.     for i in range(size): 
  4.         result.append(sqrt(i)) 
  5.     return resultdef main(): 
  6.     size = 10000 
  7.     for _ in range(size): 
  8.         result = computeSqrt(size)main() 

前文中我们讨论了局部变量可以比全局变量实现更快查找,对于经常访问的变量(如sqrt),可以通过更改为局部变量以加快操作速度。

  1. import mathdef computeSqrt(size:int): 
  2.     result = [] 
  3.     sqrt = math.sqrt 
  4.     for i in range(size): 
  5.         result.append(sqrt(i)) 
  6.     return resultdef main(): 
  7.     size = 10000 
  8.     for _ in range(size): 
  9.         result = computeSqrt(size)main() 

避免类属性访问

  1. import math 
  2. from typing import Listclass DemoClass: 
  3.     def __init__(self, value: int): 
  4.         self._value = value 
  5.     
  6.     def computeSqrt(self, size: int)-> List[float]: 
  7.         result = [] 
  8.         append = result.append 
  9.         sqrt = math.sqrt 
  10.         for _ in range(size): 
  11.             append(sqrt(self._value)) 
  12.         return resultdef main(): 
  13.     size = 10000 
  14.     for _ in range(size): 
  15.         demo_instance = DemoClass(size) 
  16.         result =demo_instance.computeSqrt(size)main() 

避免的原理也适用于类的属性,并且访问self._value的速度要比访问局部变量的速度要慢。通过把需要频繁访问的类属性分配给局部变量,可以提高代码执行速度。

  1. import math 
  2. from typing import Listclass DemoClass: 
  3.     def __init__(self, value: int): 
  4.         self._value = value 
  5.     
  6.     def computeSqrt(self, size: int)-> List[float]: 
  7.         result = [] 
  8.         append = result.append 
  9.         sqrt = math.sqrt 
  10.         value = self._value 
  11.         for _ in range(size): 
  12.             append(sqrt(value)) 
  13.         return resultdef main(): 
  14.     size = 10000 
  15.     for _ in range(size): 
  16.         demo_instance = DemoClass(size) 
  17.        demo_instance.computeSqrt(size)main() 

4. 避免不必要的抽象

  1. class DemoClass: 
  2.     def __init__(self, value: int): 
  3.         self.value = value@property 
  4.     def value(self) -> int: 
  5.         return self._value@value.setter 
  6.     def value(self, x: int): 
  7.         self._value = xdef main(): 
  8.     size = 1000000 
  9.     for i in range(size): 
  10.         demo_instance = DemoClass(size) 
  11.         value = demo_instance.value 
  12.         demo_instance.value = imain() 

每当使用其他处理层(例如装饰器、属性访问、描述符)封装代码时,代码运行的速度也会变慢。在大多数情况下,重新检查是否有必要使用属性访问器定义是很有必要的。

使用getter/setter函数访问属性通常是被C/C++程序员遗忘的一种编码样式。如果确实没有必要,就使用简单属性就好。

  1. class DemoClass: 
  2.     def __init__(self, value: int): 
  3.         self.value = valuedef main(): 
  4.     size = 1000000 
  5.     for i in range(size): 
  6.         demo_instance = DemoClass(size) 
  7.         value = demo_instance.value 
  8.         demo_instance.value = imain() 

5. 选择合适的数据结构

众所周知,列表是Python中的动态数组。当预分配的内存空间用完时,会预分配一定的内存空间,然后继续向其中添加元素。然后复制之前的所有原始元素,形成一个新的内存空间,在插入新元素之前销毁先前的内存空间。

因此,如果频繁添加或删除,或者添加或删除的元素数量太大,列表的效率就会变低,目前最好使用collections.deque。

此双端队列具有堆栈和队列的特性,并且可以在两端以O(1)复杂度执行插入和删除操作。

列表搜索操作非常耗时。当需要频繁查找某些元素或按顺序频繁访问这些元素时,保持列表 对象有序的情况下使用二分法,使用二进制搜索以提高搜索效率,但二进制搜索仅适用于有序元素。

另一个常见的要求是找到最小值或最大值。此时,可以使用heapq模块列出转换为堆的列表,因此获取最小值的时间复杂度为O(1)。

6. 循环优化

使用 for 循环代替while 循环

  1. def computeSum(size: int) ->int: 
  2.     sum_ = 0 
  3.     i = 0 
  4.     while i < size: 
  5.         sum_ += i 
  6.         i += 1 
  7.     return sum_def main(): 
  8.     size = 10000 
  9.     for _ in range(size): 
  10.         sum_ = computeSum(size)main() 

要知道,Python中的for循环要比while循环快得多。

  1. def computeSum(size: int) ->int: 
  2.     sum_ = 0 
  3.     for i in range(size): 
  4.         sum_ += i 
  5.     return sum_def main(): 
  6.     size = 10000 
  7.     for _ in range(size): 
  8.         sum_ = computeSum(size)main() 

使用隐式for循环,而不是显式for循环

对于上面的示例,可以进一步使用隐式for循环替换显式for循环

  1. def computeSum(size: int) ->int: 
  2.     return sum(range(size))def main(): 
  3.     size = 10000 
  4.     for _ in range(size): 
  5.         sum = computeSum(size)main() 

减少内部循环的计算

  1. from math import sqrtdef main(): 
  2.     size = 10000    for x in range(size): 
  3.         for y in range(size): 
  4.             z = sqrt(x) + sqrt(y)main() 

在上述for循环中的代码sqrt(x)中,在训练期间每次都需要进行重新计算,这会增加时间消耗。

  1. import mathdef main(): 
  2.     size = 10000for x in range(size): 
  3.         sqrtsqrt_x = sqrt(x) 
  4.         for y in range(size): 
  5.             z = sqrt_x + sqrt(y)main() 

7. 使用 numba.jit

继续遵循上述示例,并在此基础上使用numba.jit。Python函数JIT可以编译为机器代码用以执行,这能大大提高了代码执行速度。

  1. import numba@numba.jit 
  2. def computeSum(size: float) -> int: 
  3.     sum = 0 
  4.     for i in range(size): 
  5.         sum += i 
  6.     return sumdef main(): 
  7.     size = 10000 
  8.     for _ in range(size): 
  9.         sum = computeSum(size)main() 

8. 代码优化原则

上文已经介绍了许多加速Python代码的技术。在编写代码的过程中,我们需要了解代码优化的一些基本原理,这可是“实用知识”。

第一个基本原则就是不要过早优化代码。

许多人一开始编写代码时就致力于性能优化,“加快正确程序的速度要比确保快速程序的正确运作容易得多。”优化代码的前提是确保代码可以正常工作。过早的优化可能会忽略对总体性能指标的掌握,并且在获得总体结果之前不要颠倒顺序。

第二个基本原则是权衡优化代码的成本。

优化代码是有代价的,想要解决所有性能问题几乎不可能。通常面临的选择是时间换空间或空间换时间,还需要考虑开发成本。

第三个原则是不要优化无关紧要的部分。

如果优化代码的每个部分后,这些变更会让代码变得难以阅读和理解。如果代码运行缓慢,首先必须找到代码运行缓慢的位置(通常是内部循环),重点优化代码运行缓慢的地方。对于其他位置,时间的损失影响很小。

优化代码,让你的Python开足马力,快去实践一下吧!

 

责任编辑:赵宁宁 来源: 今日头条
相关推荐

2013-03-25 09:41:20

PythonCython

2019-03-25 21:18:41

数据科学家大数据技能

2020-07-23 14:15:42

Cython的Python代码

2020-06-15 14:43:16

Python开发工具

2009-06-29 10:34:49

网站加速Page SpeedGoogle

2017-10-18 09:49:57

ERP信息化CIO

2020-06-22 15:41:20

IF函数Excel用法

2022-05-29 08:54:44

Edge浏览器

2018-03-19 08:30:02

编程开发技能

2021-07-05 09:40:57

工具Node开源

2021-03-18 07:52:42

代码性能技巧开发

2023-06-08 11:23:56

数字化转型企业

2020-05-25 18:42:52

Windows 10Windows操作系统

2019-10-17 10:30:34

Python脚本语言设计

2021-04-08 09:47:09

云计算

2021-05-24 09:24:24

SaaS公有云云计算

2018-08-14 08:14:27

安卓Google特性

2011-01-13 14:38:00

JavascriptCSSWeb

2019-10-17 09:57:08

Python设计电脑

2022-08-01 08:12:14

位运算代码性能
点赞
收藏

51CTO技术栈公众号