15个Python运行速度优化技巧分享
更新时间：2025年02月06日 10:45:03 作者：victor66
这篇文章主要为大家详细介绍了15个Python运行速度优化技巧,文中的示例代码讲解详细,具有一定的借鉴价值,有需要的小伙伴可以参考一下
1. 使用内置函数和库
Python自带了很多高效的内置函数和库，它们通常比你自己写的代码要快得多。尽量使用这些现成的工具，而不是自己重新发明轮子。
示例：
# 不推荐：手动计算列表元素之和
def sum_list_manual(lst):
total = 0
for num in lst:
total += num
return total
# 推荐：使用内置sum函数
def sum_list_builtin(lst):
return sum(lst)
# 测试
numbers = [1, 2, 3, 4, 5]
print(sum_list_manual(numbers)) # 输出: 15
print(sum_list_builtin(numbers)) # 输出: 15
2. 使用列表推导式代替循环
列表推导式不仅更简洁，而且执行速度也更快。
示例：
# 不推荐：使用for循环创建平方数列表
squares_loop = []
for i in range(10):
squares_loop.append(i ** 2)
# 推荐：使用列表推导式
squares_comprehension = [i ** 2 for i in range(10)]
print(squares_loop) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(squares_comprehension) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
3. 使用生成器表达式节省内存
当你处理大数据集时，生成器表达式可以节省大量内存，因为它只在需要时生成数据。
示例：
# 不推荐：使用列表存储所有平方数 squares_list = [i ** 2 for i in range(1000000)] # 推荐：使用生成器表达式 squares_generator = (i ** 2 for i in range(1000000)) # 计算总和 print(sum(squares_list)) # 需要大量内存 print(sum(squares_generator)) # 内存使用较少
4. 使用set进行成员检查
集合（set）的数据结构查找元素的时间复杂度是O(1)，而列表（list）是O(n)。因此，如果需要频繁进行成员检查，使用set会更快。
示例：
# 不推荐：使用列表进行成员检查
my_list = list(range(1000000))
if 999999 in my_list:
print("Found!")
# 推荐：使用集合进行成员检查
my_set = set(range(1000000))
if 999999 in my_set:
print("Found!")
5. 使用字典代替多重条件判断
当有多个条件判断时，可以考虑使用字典来简化代码，并提高效率。
示例：
# 不推荐：使用多重if-else
def get_grade(score):
if score >= 90:
return 'A'
elif score >= 80:
return 'B'
elif score >= 70:
return 'C'
else:
return 'D'
# 推荐：使用字典映射
grade_mapping = {
(90, 100): 'A',
(80, 89): 'B',
(70, 79): 'C',
(0, 69): 'D'
}
def get_grade_dict(score):
for key, value in grade_mapping.items():
if key[0] <= score <= key[1]:
return value
print(get_grade(85)) # 输出: B
print(get_grade_dict(85)) # 输出: B
6. 使用局部变量提高性能
局部变量的访问速度比全局变量快。因此，在循环中尽量使用局部变量。
示例：
# 不推荐：使用全局变量
global_var = 10
def increment_global():
global global_var
for _ in range(1000000):
global_var += 1
# 推荐：使用局部变量
def increment_local():
local_var = 10
for _ in range(1000000):
local_var += 1
increment_global() # 较慢
increment_local() # 较快
7. 使用functools.lru_cache缓存结果
对于耗时的函数调用，可以使用functools.lru_cache来缓存结果，避免重复计算。
示例：
import functools
# 不推荐：每次调用都重新计算
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
# 推荐：使用缓存
@functools.lru_cache(maxsize=None)
def fibonacci_cached(n):
if n <= 1:
return n
return fibonacci_cached(n-1) + fibonacci_cached(n-2)
print(fibonacci(30)) # 较慢
print(fibonacci_cached(30)) # 较快
8. 使用numpy处理数值计算
numpy是一个专门用于科学计算的库，它提供了高效的数组操作功能。
示例：
import numpy as np
# 不推荐：使用纯Python列表进行矩阵乘法
matrix_a = [[1, 2], [3, 4]]
matrix_b = [[5, 6], [7, 8]]
result = [[0, 0], [0, 0]]
for i in range(len(matrix_a)):
for j in range(len(matrix_b[0])):
for k in range(len(matrix_b)):
result[i][j] += matrix_a[i][k] * matrix_b[k][j]
# 推荐：使用numpy进行矩阵乘法
matrix_a_np = np.array(matrix_a)
matrix_b_np = np.array(matrix_b)
result_np = np.dot(matrix_a_np, matrix_b_np)
print(result) # 输出: [[19, 22], [43, 50]]
print(result_np) # 输出: [[19 22] [43 50]]
9. 使用pandas处理数据
pandas是一个强大的数据分析库，特别适合处理表格数据。
示例：
import pandas as pd
# 不推荐：使用纯Python字典和列表处理数据
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
ages = [age for age in data['Age'] if age > 30]
# 推荐：使用pandas处理数据
df = pd.DataFrame(data)
filtered_df = df[df['Age'] > 30]
print(ages) # 输出: [35]
print(filtered_df) # 输出: Name Age
# 2 Charlie 35
10. 使用multiprocessing进行并行处理
如果你的任务是可以并行化的，那么使用multiprocessing模块可以显著提高性能。
示例：
import multiprocessing
def square(x):
return x ** 2
# 不推荐：串行处理
results_serial = [square(i) for i in range(10)]
# 推荐：并行处理
pool = multiprocessing.Pool()
results_parallel = pool.map(square, range(10))
pool.close()
pool.join()
print(results_serial) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(results_parallel) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
11. 使用asyncio进行异步编程
对于I/O密集型任务，使用asyncio可以提高程序的响应速度。
示例：
import asyncio
async def fetch_data():
await asyncio.sleep(1)
return "Data fetched"
# 不推荐：同步等待
def sync_fetch():
import time
time.sleep(1)
return "Data fetched"
# 推荐：异步等待
async def main():
result = await fetch_data()
print(result)
asyncio.run(main()) # 输出: Data fetched
12. 使用cython编译Python代码
cython可以将Python代码编译成C代码，从而提高执行速度。
示例：
# 不推荐：纯Python代码
def slow_function(n):
return sum(i * i for i in range(n))
# 推荐：使用Cython编译
# 在文件slow_function.pyx中定义
def fast_function(int n):
cdef int i, result = 0
for i in range(n):
result += i * i
return result
# 编译并导入
from distutils.core import setup
from Cython.Build import cythonize
setup(ext_modules=cythonize("slow_function.pyx"))
from slow_function import fast_function
print(slow_function(1000000)) # 较慢
print(fast_function(1000000)) # 较快
13. 使用numba加速数值计算
numba可以通过即时编译技术加速数值计算。
示例：
import numba
@numba.jit
def fast_sum(a, b):
return a + b
# 不推荐：纯Python加法
def slow_sum(a, b):
return a + b
print(slow_sum(10, 20)) # 输出: 30
print(fast_sum(10, 20)) # 输出: 30
14. 使用cProfile进行性能分析
在优化代码之前，先使用cProfile找出瓶颈所在。
示例：
import cProfile
def profile_me():
total = 0
for i in range(1000000):
total += i
return total
cProfile.run('profile_me()')
15. 使用line_profiler进行逐行分析
line_profiler可以帮助你找到具体哪一行代码最耗时。
示例：
# 安装line_profiler
# pip install line_profiler
@profile
def function_to_profile():
a = 2
b = 3
c = a + b
return c
function_to_profile()
实战案例：优化图像处理算法
假设你需要编写一个图像处理程序，将一张图片转换为灰度图。我们来看一下如何应用上述技巧来优化这个过程。
原始代码：
from PIL import Image
def to_grayscale(image_path):
image = Image.open(image_path)
width, height = image.size
grayscale_image = Image.new('L', (width, height))
for x in range(width):
for y in range(height):
r, g, b = image.getpixel((x, y))
gray = int(0.299 * r + 0.587 * g + 0.114 * b)
grayscale_image.putpixel((x, y), gray)
grayscale_image.save('grayscale.jpg')
to_grayscale('input.jpg')
优化后的代码：
import numpy as np
from PIL import Image
def to_grayscale_optimized(image_path):
image = Image.open(image_path).convert('RGB')
image_array = np.array(image)
grayscale_array = np.dot(image_array[..., :3], [0.299, 0.587, 0.114]).astype(np.uint8)
grayscale_image = Image.fromarray(grayscale_array, 'L')
grayscale_image.save('grayscale.jpg')
to_grayscale_optimized('input.jpg')
在这个实战案例中，我们使用了numpy来进行高效的数组操作，避免了显式的双重循环，从而大大提高了程序的运行速度。
总结
本文介绍了15个让Python程序飞速运行的技巧，包括使用内置函数和库、列表推导式、生成器表达式、集合成员检查、字典映射、局部变量、缓存结果、numpy和pandas库、并行和异步处理、cython和numba编译、性能分析工具等。通过这些技巧，你可以写出更高效、更优雅的Python代码。
到此这篇关于15个Python运行速度优化技巧分享的文章就介绍到这了,更多相关Python优化技巧内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
Python中的偏函数是来自函数式编程的一个强大工具,它的主要目标是减少函数调用的复杂性,本文将详细介绍偏函数的具体使用,需要的小伙伴可以了解下2023-12-12
这篇文章主要介绍了Kmeans和kmeans++算法,讲解了Kmeans算法的缺点和kmeans++算法的实现思路,以及Python和matlab中实现的Kmeans++算法,需要的朋友可以参考下2014-04-04
python中isalpha () 和 isdigit ()的区别小结
本文主要介绍了python中isalpha () 和 isdigit ()的区别小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2026-04-04
这篇文章主要为大家介绍了langchain中LLM模型使用详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪2023-08-08
这篇文章主要介绍了解决keras加入lambda层时shape的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-06-06
本文主要介绍了Python operator模块的使用详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧<BR>2023-06-06
DataFrame的单元格可以存放数值、字符串等，本文主要介绍了pandas 给dataframe添加列名的两种方法，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-06-06
Python django使用多进程连接mysql错误的解决方法
这篇文章主要介绍了Python django使用多进程连接mysql错误的解决方法，详细的介绍了解决方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2018-10-10
详解Python NumPy如何使用argsort方法进行排序
NumPy提供了各种功能强大的数组操作方法,其中之一就是argsort方法,本文将详细介绍argsort方法的使用,以及如何在实际项目中充分利用它进行排序操作,希望对大家有所帮助2024-03-03
今天，我想了下，现在把查找PHP WEBSHELL木马思路发出来，需要的朋友可以参考下。2011-04-04
最新评论