15 種方法優化你的 Python 代碼性能
作者：手把手PythonAI編程
本文將介紹十五種優化 Python 代碼性能的方法，并配以詳細的代碼示例，幫助你寫出更高效的代碼。
在編程的世界里，優化代碼性能是一個永恒的話題。Python 作為一種高級編程語言，以其簡潔易讀著稱，但在處理大量數據或需要高性能的場景下，代碼性能的優化就顯得尤為重要。本文將介紹十五種優化 Python 代碼性能的方法，并配以詳細的代碼示例，幫助你寫出更高效的代碼。
1. 使用內置函數
Python 的內置函數通常是用 C 語言實現的，速度比純 Python 代碼快很多。盡量使用內置函數可以提高代碼性能。
# 使用內置 sum 函數
numbers = [1, 2, 3, 4, 5]
total = sum(numbers) # 推薦
# 使用循環
total = 0
for number in numbers:
total += number # 不推薦，性能較差
print(total) # 輸出: 152. 使用生成器表達式代替列表推導式
生成器表達式比列表推導式更節省內存，因為它不會一次性生成整個列表，而是按需生成元素。
# 使用列表推導式
squares = [x**2 for x in range(10)] # 內存占用較大
# 使用生成器表達式
squares_gen = (x**2 for x in range(10)) # 內存占用較小
print(list(squares_gen)) # 輸出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]3. 使用 join 方法拼接字符串
使用 + 操作符拼接大量字符串時，每次拼接都會創建一個新的字符串對象，導致效率低下。使用 join 方法可以顯著提高性能。
import time
big_list_of_strings = ["word"] * 1000000
# 使用 + 操作符拼接
start_time = time.time()
result = ""
for word in big_list_of_strings:
result += word
print("使用 + 操作符耗時:", time.time() - start_time) # 輸出耗時較長
# 使用 join 方法拼接
start_time = time.time()
result = "".join(big_list_of_strings)
print("使用 join 方法耗時:", time.time() - start_time) # 輸出耗時較短4. 使用局部變量
訪問局部變量比訪問全局變量快，因為局部變量在函數的棧幀中，而全局變量在全局命名空間中。
# 使用全局變量
x = 10
def use_global():
for _ in range(1000000):
y = x # 訪問全局變量
# 使用局部變量
def use_local():
x = 10
for _ in range(1000000):
y = x # 訪問局部變量
import time
start_time = time.time()
use_global()
print("使用全局變量耗時:", time.time() - start_time) # 輸出耗時較長
start_time = time.time()
use_local()
print("使用局部變量耗時:", time.time() - start_time) # 輸出耗時較短5. 避免不必要的抽象
過度抽象會增加函數調用的開銷，有時直接編寫具體代碼反而更高效。
# 過度抽象
def add(a, b):
return a + b
def multiply(a, b):
return a * b
def compute(a, b, operation):
if operation == 'add':
return add(a, b)
elif operation == 'multiply':
return multiply(a, b)
# 直接編寫具體代碼
def compute_direct(a, b, operation):
if operation == 'add':
return a + b
elif operation == 'multiply':
return a * b
import time
a, b = 10, 20
start_time = time.time()
for _ in range(1000000):
compute(a, b, 'add')
print("使用抽象函數耗時:", time.time() - start_time) # 輸出耗時較長
start_time = time.time()
for _ in range(1000000):
compute_direct(a, b, 'add')
print("使用具體代碼耗時:", time.time() - start_time) # 輸出耗時較短6. 使用 if __name__ == "__main__":
將主程序邏輯放在 if __name__ == "__main__": 塊中，可以避免在模塊被導入時執行不必要的代碼。
# main.py
def main():
print("Hello, World!")
if __name__ == "__main__":
main()
# 當運行 main.py 時，會輸出 "Hello, World!"
# 當其他模塊導入 main.py 時，不會執行 main() 函數7. 使用 try-except 塊處理異常
異常處理會減慢代碼速度，但合理使用 try-except 塊可以避免不必要的檢查，提高性能。
# 不使用異常處理
def divide(a, b):
if b == 0:
return "Error: Division by zero"
return a / b
# 使用異常處理
def divide_with_exception(a, b):
try:
return a / b
except ZeroDivisionError:
return "Error: Division by zero"
import time
a, b = 10, 0
start_time = time.time()
for _ in range(1000000):
divide(a, b)
print("不使用異常處理耗時:", time.time() - start_time) # 輸出耗時較長
start_time = time.time()
for _ in range(1000000):
divide_with_exception(a, b)
print("使用異常處理耗時:", time.time() - start_time) # 輸出耗時較短（但注意異常處理開銷）8. 使用 collections.defaultdict
collections.defaultdict 可以在字典中訪問不存在的鍵時自動提供一個默認值，避免了頻繁的鍵存在性檢查。
from collections import defaultdict
# 使用普通字典
d = {}
for word in ["apple", "banana", "apple", "orange"]:
if word in d:
d[word] += 1
else:
d[word] = 1
# 使用 defaultdict
d_default = defaultdict(int)
for word in ["apple", "banana", "apple", "orange"]:
d_default[word] += 1
print(d) # 輸出: {'apple': 2, 'banana': 1, 'orange': 1}
print(d_default) # 輸出: defaultdict(<class 'int'>, {'apple': 2, 'banana': 1, 'orange': 1})9. 使用 itertools 模塊
itertools 模塊提供了許多用于創建迭代器的函數，這些函數在處理大量數據時非常高效。
import itertools
# 使用 itertools.chain 合并多個迭代器
iter1 = [1, 2, 3]
iter2 = [4, 5, 6]
merged_iter = itertools.chain(iter1, iter2)
print(list(merged_iter)) # 輸出: [1, 2, 3, 4, 5, 6]
# 使用 itertools.islice 獲取迭代器的切片
iter3 = range(10)
sliced_iter = itertools.islice(iter3, 2, 5)
print(list(sliced_iter)) # 輸出: [2, 3, 4]10. 使用 functools.lru_cache 緩存函數結果
functools.lru_cache 可以緩存函數的返回值，避免重復計算，提高性能。
import functools
@functools.lru_cache(maxsize=None)
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
# 第一次調用會計算
print(fibonacci(10)) # 輸出: 55
# 第二次調用會直接返回緩存結果
print(fibonacci(10)) # 輸出: 55，但速度更快11. 使用 numpy 進行數值計算
numpy 是一個用于科學計算的庫，其內部實現了高效的數組操作，比純 Python 代碼快很多。
import numpy as np
# 使用純 Python 計算數組和
arr = [1, 2, 3, 4, 5]
total = sum(arr)
# 使用 numpy 計算數組和
arr_np = np.array([1, 2, 3, 4, 5])
total_np = np.sum(arr_np)
print(total) # 輸出: 15
print(total_np) # 輸出: 1512. 使用 multiprocessing 模塊并行處理
multiprocessing 模塊允許你并行執行多個進程，充分利用多核 CPU 的計算能力。
from multiprocessing import Pool
def square(x):
return x ** 2
if __name__ == "__main__":
with Pool(4) as pool: # 創建包含 4 個進程的池
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squared_numbers = pool.map(square, numbers)
print(squared_numbers) # 輸出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]13. 使用 asyncio 進行異步編程
asyncio 是 Python 3.4 引入的異步 I/O 框架，可以提高網絡請求、文件讀寫等 I/O 密集型任務的性能。
import asyncio
async def fetch_data(url):
# 模擬網絡請求
await asyncio.sleep(1)
return f"Data from {url}"
async def main():
urls = ["http://example.com/1", "http://example.com/2", "http://example.com/3"]
tasks = [fetch_data(url) for url in urls]
results = await asyncio.gather(*tasks)
print(results)
# 運行異步主程序
asyncio.run(main())
# 輸出: ['Data from http://example.com/1', 'Data from http://example.com/2', 'Data from http://example.com/3']14. 使用 memoryview 減少內存復制
memoryview 對象允許你創建對同一內存塊的多個視圖，從而減少內存復制，提高性能。
import numpy as np
# 創建一個 numpy 數組
arr = np.array([1, 2, 3, 4, 5])
# 創建一個 memoryview 對象
mv = memoryview(arr)
# 修改 memoryview 對象會影響原數組
mv[0] = 10
print(arr) # 輸出: [10 2 3 4 5]15. 使用 JIT 編譯（如 numba）
numba 是一個開源庫，可以將 Python 代碼即時編譯成機器碼，從而提高性能。
import numba
@numba.jit(nopython=True)
def vectorized_sum(a, b):
return a + b
import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 4, 3, 2, 1])
# 使用 JIT 編譯的函數
result = vectorized_sum(a, b)
print(result) # 輸出: [ 6 6 6 6 6]實戰案例：優化圖像處理代碼
假設我們需要對一個大型圖像數據集進行簡單的灰度轉換處理。原始代碼使用純 Python 實現，性能較差。我們可以使用上述優化技巧來提高性能。
原始代碼
import cv2
import numpy as np
def convert_to_grayscale(image_path):
image = cv2.imread(image_path)
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
return gray_image
# 假設我們有一個包含大量圖像路徑的列表
image_paths = ["image1.jpg", "image2.jpg", "image3.jpg"]
gray_images = [convert_to_grayscale(path) for path in image_paths]優化后的代碼
(1) 使用 multiprocessing 模塊并行處理圖像。
(2) 使用 numpy 進行高效的數組操作。
from multiprocessing import Pool
import cv2
import numpy as np
def convert_to_grayscale(image_path):
image = cv2.imread(image_path)
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
return gray_image
if __name__ == "__main__":
image_paths = ["image1.jpg", "image2.jpg", "image3.jpg"]
with Pool(4) as pool: # 假設有 4 個 CPU 核心
gray_images = pool.map(convert_to_grayscale, image_paths)
# 可以進一步處理 gray_images，例如保存到磁盤或進行其他分析
for i, gray_image in enumerate(gray_images):
cv2.imwrite(f"gray_{image_paths[i]}", gray_image)在這個案例中，通過使用 multiprocessing 模塊并行處理圖像，我們充分利用了多核 CPU 的計算能力，顯著提高了圖像處理的效率。同時，使用 cv2 和 numpy 進行圖像讀取和轉換操作，也保證了代碼的高效性。
總結
本文介紹了十五種優化 Python 代碼性能的方法，包括使用內置函數、生成器表達式、join 方法拼接字符串、局部變量、if name == "main": 塊、try-except 塊、collections.defaultdict、itertools 模塊、functools.lru_cache、numpy、multiprocessing 模塊、asyncio、memoryview 和 JIT 編譯（如 numba）。
通過實際應用這些技巧，你可以顯著提高 Python 代碼的性能，特別是在處理大量數據或需要高性能的場景下。同時，本文還通過一個實戰案例展示了如何結合多種優化技巧來提高圖像處理代碼的效率。
責任編輯：趙寧寧
來源：
手把手PythonAI編程
