15個提升Python程序運行速度的實用技巧
更新時間：2026年01月18日 08:42:00 作者：軟件測試雜談
這篇文章主要為大家詳細介紹了15個提升Python程序運行速度的實用技巧,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
今天我們就來聊聊如何用15個技巧讓Python程序飛速運行。這些技巧不僅能讓代碼跑得更快，還能讓你的編程思維更加嚴謹。
1. 使用內置函數(shù)和庫
Python自帶了很多高效的內置函數(shù)和庫，它們通常比你自己寫的代碼要快得多。盡量使用這些現(xiàn)成的工具，而不是自己重新發(fā)明輪子。
示例：
# 不推薦：手動計算列表元素之和
def sum_list_manual(lst):
total = 0
for num in lst:
total += num
return total
# 推薦：使用內置sum函數(shù)
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. 使用列表推導式代替循環(huán)
列表推導式不僅更簡潔，而且執(zhí)行速度也更快。
示例：
# 不推薦：使用for循環(huán)創(chuàng)建平方數(shù)列表
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. 使用生成器表達式節(jié)省內存
當你處理大數(shù)據(jù)集時，生成器表達式可以節(jié)省大量內存，因為它只在需要時生成數(shù)據(jù)。
示例：
# 不推薦：使用列表存儲所有平方數(shù) 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）的數(shù)據(jù)結構查找元素的時間復雜度是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. 使用局部變量提高性能
局部變量的訪問速度比全局變量快。因此，在循環(huán)中盡量使用局部變量。
示例：
# 不推薦：使用全局變量
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緩存結果
對于耗時的函數(shù)調用，可以使用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處理數(shù)值計算
numpy是一個專門用于科學計算的庫，它提供了高效的數(shù)組操作功能。
示例：
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處理數(shù)據(jù)
pandas是一個強大的數(shù)據(jù)分析庫，特別適合處理表格數(shù)據(jù)。
示例：
import pandas as pd
# 不推薦：使用純Python字典和列表處理數(shù)據(jù)
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
ages = [age for age in data['Age'] if age > 30]
# 推薦：使用pandas處理數(shù)據(jù)
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代碼，從而提高執(zhí)行速度。
示例：
# 不推薦：純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加速數(shù)值計算
numba可以通過即時編譯技術加速數(shù)值計算。
示例：
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進行性能分析
在優(yōu)化代碼之前，先使用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()
實戰(zhàn)案例：優(yōu)化圖像處理算法
假設你需要編寫一個圖像處理程序，將一張圖片轉換為灰度圖。我們來看一下如何應用上述技巧來優(yōu)化這個過程。
原始代碼：
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')
優(yōu)化后的代碼：
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')
在這個實戰(zhàn)案例中，我們使用了numpy來進行高效的數(shù)組操作，避免了顯式的雙重循環(huán)，從而大大提高了程序的運行速度。
總結
本文介紹了15個讓Python程序飛速運行的技巧，包括使用內置函數(shù)和庫、列表推導式、生成器表達式、集合成員檢查、字典映射、局部變量、緩存結果、numpy和pandas庫、并行和異步處理、cython和numba編譯、性能分析工具等。通過這些技巧，你可以寫出更高效、更優(yōu)雅的Python代碼。
到此這篇關于15個提升Python程序運行速度的實用技巧的文章就介紹到這了,更多相關Python優(yōu)化技巧內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
TensorFlow在MAC環(huán)境下的安裝及環(huán)境搭建
小編在論壇中看到很多朋友在尋找TensorFlow的環(huán)境搭建圖文步驟以及安裝的具體流程，在此小編給大家整理了一篇非常詳細的圖文流程，希望能夠幫助到你。2017-11-11
Python將list元素轉存為CSV文件的實現(xiàn)
這篇文章主要介紹了Python將list元素轉存為CSV文件的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-11-11
CoAtNet實戰(zhàn)之對植物幼苗圖像進行分類(pytorch)
谷歌的最新模型CoAtNet做了卷積 + Transformer的融合,在ImageNet-1K數(shù)據(jù)集上取得88.56%的成績。本文主要介紹如何用CoAtNet實現(xiàn)植物幼苗圖像的分類。感興趣的小伙伴可以學習一下2021-12-12
這篇文章主要介紹了jekins配置python腳本定時任務過程圖解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-10-10
基于Python數(shù)據(jù)分析之pandas統(tǒng)計分析
這篇文章主要介紹了基于Python數(shù)據(jù)分析之pandas統(tǒng)計分析，具有很好對參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-03-03
編寫同時兼容Python2.x與Python3.x版本的代碼的幾個示例
這篇文章主要介紹了編寫同時兼容Python2.x與Python3.x版本的代碼的幾個示例,在Python2.7.x的更新中由于采用了某些Python3中的代碼編寫特性、使得在有些原本不同之處編寫兼容性代碼成為可能，需要的朋友可以參考下2015-03-03
今天向大家介紹如何搭建Python開發(fā)環(huán)境, Python可應用于多平臺包括 Linux 和 Mac OS X,文中有非常詳細的圖文介紹,需要的朋友可以參考下2021-05-05
今天小編就為大家分享一篇對pytorch中的梯度更新方法詳解，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-08-08
在?Python?編程里,數(shù)字類型是極為基礎且關鍵的數(shù)據(jù)類型,本文將深入介紹?Python?數(shù)字類型的內置方法,同時輔以詳細的代碼示例,需要的可以了解下2025-04-04
python GUI庫圖形界面開發(fā)之PyQt5窗口控件QWidget詳細使用方法
這篇文章主要介紹了python GUI庫圖形界面開發(fā)之PyQt5窗口控件QWidget詳細使用方法,需要的朋友可以參考下2020-02-02