9 个让你的 Python 代码更快的小技巧

刘玉霞

哈喽大家好，我是咸鱼
我们经常听到 “Python 太慢了”，“Python 性能不行”这样的观点。但是，只要掌握一些编程技巧，就能大幅提升 Python 的运行速度。
今天就让我们一起来看下让 Python 性能更高的 9 个小技巧
原文链接：
https://medium.com/techtofreedom/9-fabulous-python-tricks-that-make-your-code-more-elegant-bf01a6294908
字符串拼接的技巧

如果有大量字符串等待处理，字符串连接将成为 Python 的瓶颈。
一般来讲，Python 中有两种字符串拼接方式：

• 使用该 join() 函数将字符串列表合并为一个字符串
  
• 使用 + or += 符号将每个字符串加成一个
  

那么哪种方式更快呢？我们一起来看一下

1. mylist = ["Yang", "Zhou", "is", "writing"]
4. # Using '+'
5. def concat_plus():
6.     result = ""
7.     for word in mylist:
8.         result += word + " "
9.     return result
12. # Using 'join()'
13. def concat_join():
14.     return " ".join(mylist)
17. # Directly concatenation without the list
18. def concat_directly():
19.     return "Yang" + "Zhou" + "is" + "writing"

复制代码

1. import timeit
3. print(timeit.timeit(concat_plus, number=10000))
4. # 0.002738415962085128
5. print(timeit.timeit(concat_join, number=10000))
6. # 0.0008482920238748193
7. print(timeit.timeit(concat_directly, number=10000))
8. # 0.00021425005979835987

复制代码

如上所示，对于拼接字符串列表， join() 方法比在 for 循环中逐个添加字符串更快。
原因很简单。一方面，字符串是 Python 中的不可变数据，每个 += 操作都会导致创建一个新字符串并复制旧字符串，这会导致非常大的开销。
另一方面，.join() 方法是专门为连接字符串序列而优化的。它预先计算结果字符串的大小，然后一次性构建它。因此，它避免了与循环中 += 操作相关的开销，因此速度更快。
但是，我们发现最快其实是直接用 + 拼接字符串，这是因为：

• Python 解释器可以在编译时优化字符串的连接，将它们转换为单个字符串。因为没有循环迭代或函数调用，所以它是一个非常高效的操作。
  
• 由于所有字符串在编译时都是已知的，因此 Python 可以非常快速地执行此操作，比循环中的运行时连接甚至优化 .join() 方法快得多。
  

总之，如果需要拼接字符串列表，请选择 join() ；如果直接拼接字符串，只需使用 + 即可。
创建列表的技巧

Python 中创建列表的两种常见方法是：

• 使用函数 list()
  
• [] 直接使用
  

我们来看下这两种方法的性能

1. import timeit
3. print(timeit.timeit('[]', number=10 ** 7))
4. # 0.1368238340364769
5. print(timeit.timeit(list, number=10 ** 7))
6. # 0.2958830420393497

复制代码

结果表明，执行 list() 函数比直接使用 [] 要慢。
这是因为 是 [] 字面语法( literal syntax )，而 list() 是构造函数调用。毫无疑问，调用函数需要额外的时间。
同理，在创建字典时，我们也应该利用 {} 而不是 dict()
成员关系测试的技巧

成员关系测试的性能很大程度上取决于底层数据结构

1. import timeit
3. large_dataset = range(100000)
4. search_element = 2077
6. large_list = list(large_dataset)
7. large_set = set(large_dataset)
10. def list_membership_test():
11.     return search_element in large_list
14. def set_membership_test():
15.     return search_element in large_set
18. print(timeit.timeit(list_membership_test, number=1000))
19. # 0.01112208398990333
20. print(timeit.timeit(set_membership_test, number=1000))
21. # 3.27499583363533e-05

复制代码

如上面的代码所示，集合中的成员关系测试比列表中的成员关系测试要快得多。
这是为什么呢？

• 在 Python 列表中，成员关系测试 （ element in list ） 是通过遍历每个元素来完成的，直到找到所需的元素或到达列表的末尾。因此，此操作的时间复杂度为 O（n）。
  
• Python 中的集合是作为哈希表实现的。在检查成员资格 （ element in set ） 时，Python 使用哈希机制，其时间复杂度平均为 O（1）。
  

这里的技巧重点是在编写程序时仔细考虑底层数据结构。利用正确的数据结构可以显著加快我们的代码速度。
使用推导式而不是 for 循环

Python 中有四种类型的推导式：列表、字典、集合和生成器。它们不仅为创建相对数据结构提供了更简洁的语法，而且比使用 for 循环具有更好的性能。
因为它们在 Python 的 C 实现中进行了优化。

1. import timeit
4. def generate_squares_for_loop():
5.     squares = []
6.     for i in range(1000):
7.         squares.append(i * i)
8.     return squares
11. def generate_squares_comprehension():
12.     return [i * i for i in range(1000)]
15. print(timeit.timeit(generate_squares_for_loop, number=10000))
16. # 0.2797503340989351
17. print(timeit.timeit(generate_squares_comprehension, number=10000))
18. # 0.2364629579242319

复制代码

上面的代码是列表推导式和 for 循环之间的简单速度比较。如结果所示，列表推导式速度更快。
访问局部变量速度更快

在 Python 中，访问局部变量比访问全局变量或对象的属性更快。

1. import timeit
4. class Example:
5.     def __init__(self):
6.         self.value = 0
9. obj = Example()
12. def test_dot_notation():
13.     for _ in range(1000):
14.         obj.value += 1
17. def test_local_variable():
18.     value = obj.value
19.     for _ in range(1000):
20.         value += 1
21.     obj.value = value
24. print(timeit.timeit(test_dot_notation, number=1000))
25. # 0.036605041939765215
26. print(timeit.timeit(test_local_variable, number=1000))
27. # 0.024470250005833805

复制代码

原理也很简单：当编译一个函数时，它内部的局部变量是已知的，但其他外部变量需要时间来检索。
优先考虑内置模块和库

当我们讨论 Python 的时候，通常指的是 CPython，因为 CPython 是 Python 语言的默认和使用最广泛的实现。
考虑到它的大多数内置模块和库都是用C语言编写的，C语言是一种更快、更低级的语言，我们应该利用它的内置库，避免重复造轮子。

1. import timeit
2. import random
3. from collections import Counter
6. def count_frequency_custom(lst):
7.     frequency = {}
8.     for item in lst:
9.         if item in frequency:
10.             frequency[item] += 1
11.         else:
12.             frequency[item] = 1
13.     return frequency
16. def count_frequency_builtin(lst):
17.     return Counter(lst)
20. large_list = [random.randint(0, 100) for _ in range(1000)]
22. print(timeit.timeit(lambda: count_frequency_custom(large_list), number=100))
23. # 0.005160166998393834
24. print(timeit.timeit(lambda: count_frequency_builtin(large_list), number=100))
25. # 0.002444291952997446

复制代码

上面的程序比较了计算列表中元素频率的两种方法。正如我们所看到的，利用 collections 模块的内置计数器比我们自己编写 for 循环更快、更简洁、更好。
使用缓存装饰器

缓存是避免重复计算和提高程序速度的常用技术。
幸运的是，在大多数情况下，我们不需要编写自己的缓存处理代码，因为 Python 提供了一个开箱即用的装饰器 — @functools.cache 。
例如，以下代码将执行两个斐波那契数生成函数，一个具有缓存装饰器，但另一个没有：

1. import timeit
2. import functools
5. def fibonacci(n):
6.     if n in (0, 1):
7.         return n
8.     return fibonacci(n - 1) + fibonacci(n - 2)
11. @functools.cache
12. def fibonacci_cached(n):
13.     if n in (0, 1):
14.         return n
15.     return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)
18. # Test the execution time of each function
19. print(timeit.timeit(lambda: fibonacci(30), number=1))
20. # 0.09499712497927248
21. print(timeit.timeit(lambda: fibonacci_cached(30), number=1))
22. # 6.458023563027382e-06

复制代码

可以看到 functools.cache  装饰器如何使我们的代码运行得更快。
缓存版本的速度明显更快，因为它缓存了先前计算的结果。因此，它只计算每个斐波那契数一次，并从缓存中检索具有相同参数的后续调用
while 1 VS while True

如果要创建无限 while 循环，我们可以使用 while True or while 1 .
它们的性能差异通常可以忽略不计。但有趣的是， while 1 稍微快一点。
这是因为是 1 字面量，但 True 是一个全局名称，需要在 Python 的全局作用域中查找。所以 1 的开销很小。

1. import timeit
4. def loop_with_true():
5.     i = 0
6.     while True:
7.         if i >= 1000:
8.             break
9.         i += 1
12. def loop_with_one():
13.     i = 0
14.     while 1:
15.         if i >= 1000:
16.             break
17.         i += 1
20. print(timeit.timeit(loop_with_true, number=10000))
21. # 0.1733035419601947
22. print(timeit.timeit(loop_with_one, number=10000))
23. # 0.16412191605195403

复制代码

正如我们所看到的，确实 while 1 稍微快一些。
然而，现代 Python 解释器(如 CPython )是高度优化的，这种差异通常是微不足道的。所以我们不需要担心这个可以忽略不计的差异。更不用说 while True 比 while 1 可读性更好。
按需导入 Python 模块

在 Python 脚本开头导入所有模块似乎是每个人都会这么做的操作，事实上我们没有必要导入全部的模块。如果模块太大，则根据需要导入它是一个更好的主意。

1. def my_function():
2.     import heavy_module
3.     # rest of the function

复制代码

如上面的代码所示，heavy_module 在函数中导入。这是一种“延迟加载”的思想：只有 my_function 被调用的时候该模块才会被导入。
这种方法的好处是，如果 my_function 在脚本执行期间从未调用过，则 heavy_module 永远不会加载，从而节省资源并减少脚本的启动时间。

来源:https://www.cnblogs.com/edisonfish/p/17952909
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！