怎样才能提高Python运行效率？

python逐渐走入人们的视线，成为热门编程语言，随之而来，加入python培训的准程序员大军也成为社会热点。Python具有许多其他编程语言不具备的优势，譬如能通过极少量代码完成许多 *** 作，以及多进程，能够轻松支持多任务处理。除了多种优势外，python也有不好的地方，运行较慢，下面电脑培训为大家介绍6个窍门，可以帮你提高python的运行效率。

1.在排序时使用键

Python含有许多古老的排序规则，这些规则在你创建定制的排序方法时会占用很多时间，而这些排序方法运行时也会拖延程序实际的运行速度。最佳的排序方法其实是尽可能多地使用键和内置的sort()方法。

2.交叉编译你的应用

开发者有时会忘记计算机其实并不理解用来创建现代应用程序的编程语言。计算机理解的是机器语言。为了运行你的应用，你借助一个应用将你所编的人类可读的代码转换成机器可读的代码。有时，你用一种诸如Python这样的语言编写应用，再以C++这样的语言运行你的应用，这在运行的角度来说，是可行的。关键在于，你想你的应用完成什么事情，而你的主机系统能提供什么样的资源。

3.关键代码使用外部功能包

Python简化了许多编程任务，但是对于一些时间敏感的任务，它的表现经常不尽人意。使用C/C++或机器语言的外部功能包处理时间敏感任务，可以有效提高应用的运行效率。这些功能包往往依附于特定的平台，因此你要根据自己所用的平台选择合适的功能包。简而言之，这个窍门要你牺牲应用的可移植性以换取只有通过对底层主机的直接编程才能获得的运行效率。

4.针对循环的优化

每一种编程语言都强调最优化的循环方案。当使用Python时，你可以借助丰富的技巧让循环程序跑得更快。然而，开发者们经常遗忘的一个技巧是：尽量避免在循环中访问变量的属性。

5.尝试多种编码方法

每次创建应用时都使用同一种编码方法几乎无一例外会导致应用的运行效率不尽人意。可以在程序分析时尝试一些试验性的办法。譬如说，在处理字典中的数据项时，你既可以使用安全的方法，先确保数据项已经存在再进行更新，也可以直接对数据项进行更新，把不存在的数据项作为特例分开处理。

6.使用较新的Python版本

你要保证自己的代码在新版本里还能运行。你需要使用新的函数库才能体验新的Python版本，然后你需要在做出关键性的改动时检查自己的应用。只有当你完成必要的修正之后，你才能体会新版本的不同。

本节对一些 Python 易混淆的 *** 作进行对比。

1.1 有放回随机采样和无放回随机采样

1.2 lambda 函数的参数

1.3 copy 和 deepcopy

复制和变量别名结合在一起时，容易混淆：

对别名的修改会影响原变量，（浅）复制中的元素是原列表中元素的别名，而深层复制是递归地进行复制，对深层复制的修改不影响原变量。

1.4 == 和 is

1.5 判断类型

1.6 字符串搜索

1.7 List 后向索引

这个只是习惯问题，前向索引时下标从0开始，如果反向索引也想从0开始可以使用~。

2.1 读写 CSV 文件

注意，当 CSV 文件过大时会报错：_csv.Error: field larger than field limit (131072)，通过修改上限解决

csv 还可以读以 分割的数据

2.2 迭代器工具

itertools 重新定义了很多迭代器工具，例如子序列工具：

序列排序：

多个序列合并：

2.3 计数器

计数器可以统计一个可迭代对象中每个元素出现的次数。

2.4 带默认值的 Dict

当访问不存在的 Key 时，defaultdict 会将其设置为某个默认值。

2.5 有序 Dict

3.1 输出错误和警告信息

向标准错误输出信息

输出警告信息

控制警告消息的输出

3.2 代码中测试

有时为了调试，我们想在代码中加一些代码，通常是一些 print 语句，可以写为：

一旦调试结束，通过在命令行执行 -O 选项，会忽略这部分代码：

3.3 代码风格检查

使用 pylint 可以进行不少的代码风格和语法检查，能在运行之前发现一些错误

3.4 代码耗时

耗时测试

测试某代码块耗时

代码耗时优化的一些原则

4.1 argmin 和 argmax

argmax同理。

4.2 转置二维列表

4.3 一维列表展开为二维列表

pre{overflow-x: auto}

Python 是世界上使用最广泛的编程语言之一。它是一种解释型高级通用编程语言，具有广泛的用途，几乎可以将其用于所有事物。其以简单的语法、优雅的代码和丰富的第三方库而闻名。python除了有很多优点外，但在速度上还有一个非常大的缺点。

虽然Python代码运行缓慢，但可以通过下面分享的5个小技巧提升Python运行速度！

首先，定义一个计时函数timeshow，通过简单的装饰，可以打印指定函数的运行时间。

这个函数在下面的例子中会被多次使用。

def timeshow(func):     from time import time     def newfunc(*arg, **kw):         t1 = time()         res = func(*arg, **kw)         t2 = time()         print(f"{func.__name__: >10} : {t2-t1:.6f} sec")         return res     return newfunc @timeshow def test_it():     print("hello pytip") test_it() 1. 选择合适的数据结构

使用正确的数据结构对python脚本的运行时间有显着影响。Python 有四种内置的数据结构：

列表 : List

元组 : Tuple

集合 : Set

字典 : Dictionary

但是，大多数开发人员在所有情况下都使用列表。这是不正确的做法，应该根据任务使用合适数据结构。

运行下面的代码，可以看到元组执行简单检索 *** 作的速度比列表快。其中dis模块反汇编了一个函数的字节码，这有利于查看列表和元组之间的区别。

import dis def a():     data = [1, 2, 3, 4, 5,6,7,8,9,10]     x =data[5]     return x def b():     data = (1, 2, 3, 4, 5,6,7,8,9,10)     x =data[5]     return x print("-----:使用列表的机器码:------") dis.dis(a) print("-----:使用元组的机器码:------") dis.dis(b)

运行输出:

-----:使用列表的机器码:------

3 0 LOAD_CONST 1 (1)

2 LOAD_CONST 2 (2)

4 LOAD_CONST 3 (3)

6 LOAD_CONST 4 (4)

8 LOAD_CONST 5 (5)

10 LOAD_CONST 6 (6)

12 LOAD_CONST 7 (7)

14 LOAD_CONST 8 (8)

16 LOAD_CONST 9 (9)

18 LOAD_CONST 10 (10)

20 BUILD_LIST 10

22 STORE_FAST 0 (data)

4 24 LOAD_FAST 0 (data)

26 LOAD_CONST 5 (5)

28 BINARY_SUBSCR

30 STORE_FAST 1 (x)

5 32 LOAD_FAST 1 (x)

34 RETURN_VALUE

-----:使用元组的机器码:------

7 0 LOAD_CONST 1 ((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

2 STORE_FAST 0 (data)

8 4 LOAD_FAST 0 (data)

6 LOAD_CONST 2 (5)

8 BINARY_SUBSCR

10 STORE_FAST 1 (x)

9 12 LOAD_FAST 1 (x)

14 RETURN_VALUE

看下列表的机器码，冗长而多余！

2. 善用强大的内置函数和第三方库

如果你正在使用python并且仍在自己编写一些通用函数(比如加法、减法)，那么是在侮辱python。 Python有大量的库和内置函数来帮助你不用编写这些函数。 如果研究下，那么你会惊奇地发现几乎90%的问题已经有第三方包或内置函数来解决。

可以通过访问官方文档查看所有内置函数。你也可以在wiki python上找到更多使用内置函数的场景。

比如，现在我们想合并列表中的所有单词为一个句子，比较法自己编写和调用库函数的区别:

# ❌ 正常人能想到的方法 @timeshow def f1(list):     s =""     for substring in list:         s += substring     return s # ✅ pythonic 的方法 @timeshow def f2(list):     s = "".join(list)     return s l = ["I", "Love", "Python"] * 1000 # 为了看到差异，我们把这个列表放大了 f1(l) f2(l)

运行输出:

f1 : 0.000227 sec

f2 : 0.000031 sec

3. 少用循环

用 列表推导式 代替循环

用 迭代器 代替循环

用 filter() 代替循环

减少循环次数，精确控制，不浪费CPU

## 返回n以内的可以被7整除的所有数字。 # ❌ 正常人能想到的方法: @timeshow def f_loop(n):      L=[]     for i in range(n):         if i % 7 ==0:             L.append(i)     return L #  ✅ 列表推导式 @timeshow def f_list(n):     L = [i for i in range(n) if i % 7 == 0]     return L # ✅  迭代器 @timeshow def f_iter(n):     L = (i for i in range(n) if i % 7 == 0)     return L # ✅ 过滤器  @timeshow def f_filter(n):     L = filter(lambda x: x % 7 == 0, range(n))     return L # ✅ 精确控制循环次数  @timeshow def f_mind(n):     L = (i*7 for i in range(n//7))     return L n = 1_000_000 f_loop(n) f_list(n) f_iter(n) f_filter(n) f_mind(n)

输出为:

f_loop : 0.083017 sec

f_list : 0.056110 sec

f_iter : 0.000015 sec

f_filter : 0.000003 sec

f_mind : 0.000002 sec

谁快谁慢，一眼便知！

filter 配合 lambda 大法就是屌！！！

4. 避免循环重复计算

如果你有一个迭代器，必须用它的元素做一些耗时计算，比如匹配正则表达式。你应该将正则表达式模式定义在循环之外，因为最好只编译一次模式，而不是在循环的每次迭代中一次又一次地编译它。

只要有可能，就应该尝试在循环外进行尽可能多的运算，比如将函数计算分配给局部变量，然后在函数中使用它。

# ❌ 应改避免的方式： @timeshow def f_more(s):     import re     for i in s:         m = re.search(r'a*[a-z]?c', i) # ✅ 更好的方式： @timeshow def f_less(s):     import re     regex = re.compile(r'a*[a-z]?c')     for i in s:         m = regex.search(i) s = ["abctestabc"] * 1_000 f_more(s) f_less(s)

输出为:

f_more : 0.001068 sec

f_less : 0.000365 sec

5. 少用内存、少用全局变量

内存占用是指程序运行时使用的内存量。为了让Python代码运行得更快，应该减少程序的内存使用量，即尽量减少变量或对象的数量。

Python 访问局部变量比全局变量更有效。在有必要之前，应该始终尝试忽略声明全局变量。一个在程序中定义过的全局变量会一直存在，直到整个程序编译完成，所以它一直占据着内存空间。另一方面，局部变量访问更快，且函数完成后即可回收。因此，使用多个局部变量比使用全局变量会更好。

# ❌ 应该避免的方式： message = "Line1\n" message += "Line2\n" message += "Line3\n" # ✅ 更好的方式： l = ["Line1","Line2","Line3"] message = '\n'.join(l) # ❌ 应该避免的方式： x = 5 y = 6  def add():     return x+y add() # ✅ 更好的方式： def add():     x = 5     y = 6     return x+y add()

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!

---