15 種方法優(yōu)化你的 Python 代碼性能
在編程的世界里，優(yōu)化代碼性能是一個永恒的話題。Python 作為一種高級編程語言，以其簡潔易讀著稱，但在處理大量數(shù)據(jù)或需要高性能的場景下，代碼性能的優(yōu)化就顯得尤為重要。本文將介紹十五種優(yōu)化 Python 代碼性能的方法，并配以詳細的代碼示例，幫助你寫出更高效的代碼。
1. 使用內置函數(shù)
Python 的內置函數(shù)通常是用 C 語言實現(xiàn)的，速度比純 Python 代碼快很多。盡量使用內置函數(shù)可以提高代碼性能。
# 使用內置 sum 函數(shù)
numbers = [1, 2, 3, 4, 5]
total = sum(numbers) # 推薦
# 使用循環(huán)
total = 0
for number in numbers:
total += number # 不推薦，性能較差
print(total) # 輸出: 152. 使用生成器表達式代替列表推導式
生成器表達式比列表推導式更節(jié)省內存，因為它不會一次性生成整個列表，而是按需生成元素。
# 使用列表推導式
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 方法拼接字符串
使用 + 操作符拼接大量字符串時，每次拼接都會創(chuàng)建一個新的字符串對象，導致效率低下。使用 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. 使用局部變量
訪問局部變量比訪問全局變量快，因為局部變量在函數(shù)的棧幀中，而全局變量在全局命名空間中。
# 使用全局變量
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. 避免不必要的抽象
過度抽象會增加函數(shù)調用的開銷，有時直接編寫具體代碼反而更高效。
# 過度抽象
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("使用抽象函數(shù)耗時:", 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__": 塊中，可以避免在模塊被導入時執(zhí)行不必要的代碼。
# main.py
def main():
print("Hello, World!")
if __name__ == "__main__":
main()
# 當運行 main.py 時，會輸出 "Hello, World!"
# 當其他模塊導入 main.py 時，不會執(zhí)行 main() 函數(shù)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 模塊提供了許多用于創(chuàng)建迭代器的函數(shù)，這些函數(shù)在處理大量數(shù)據(jù)時非常高效。
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 緩存函數(shù)結果
functools.lru_cache 可以緩存函數(shù)的返回值，避免重復計算，提高性能。
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 進行數(shù)值計算
numpy 是一個用于科學計算的庫，其內部實現(xiàn)了高效的數(shù)組操作，比純 Python 代碼快很多。
import numpy as np
# 使用純 Python 計算數(shù)組和
arr = [1, 2, 3, 4, 5]
total = sum(arr)
# 使用 numpy 計算數(shù)組和
arr_np = np.array([1, 2, 3, 4, 5])
total_np = np.sum(arr_np)
print(total) # 輸出: 15
print(total_np) # 輸出: 1512. 使用 multiprocessing 模塊并行處理
multiprocessing 模塊允許你并行執(zhí)行多個進程，充分利用多核 CPU 的計算能力。
from multiprocessing import Pool
def square(x):
return x ** 2
if __name__ == "__main__":
with Pool(4) as pool: # 創(chuàng)建包含 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 對象允許你創(chuàng)建對同一內存塊的多個視圖，從而減少內存復制，提高性能。
import numpy as np
# 創(chuàng)建一個 numpy 數(shù)組
arr = np.array([1, 2, 3, 4, 5])
# 創(chuàng)建一個 memoryview 對象
mv = memoryview(arr)
# 修改 memoryview 對象會影響原數(shù)組
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 編譯的函數(shù)
result = vectorized_sum(a, b)
print(result) # 輸出: [ 6 6 6 6 6]實戰(zhàn)案例：優(yōu)化圖像處理代碼
假設我們需要對一個大型圖像數(shù)據(jù)集進行簡單的灰度轉換處理。原始代碼使用純 Python 實現(xiàn)，性能較差。我們可以使用上述優(yōu)化技巧來提高性能。
原始代碼
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]優(yōu)化后的代碼
(1) 使用 multiprocessing 模塊并行處理圖像。
(2) 使用 numpy 進行高效的數(shù)組操作。
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 進行圖像讀取和轉換操作，也保證了代碼的高效性。
總結
本文介紹了十五種優(yōu)化 Python 代碼性能的方法，包括使用內置函數(shù)、生成器表達式、join 方法拼接字符串、局部變量、if name == "main": 塊、try-except 塊、collections.defaultdict、itertools 模塊、functools.lru_cache、numpy、multiprocessing 模塊、asyncio、memoryview 和 JIT 編譯（如 numba）。
通過實際應用這些技巧，你可以顯著提高 Python 代碼的性能，特別是在處理大量數(shù)據(jù)或需要高性能的場景下。同時，本文還通過一個實戰(zhàn)案例展示了如何結合多種優(yōu)化技巧來提高圖像處理代碼的效率。
