15 種方法優(yōu)化你的 Python 代碼性能
在編程的世界里，優(yōu)化代碼性能是一個(gè)永恒的話(huà)題。Python 作為一種高級(jí)編程語(yǔ)言，以其簡(jiǎn)潔易讀著稱(chēng)，但在處理大量數(shù)據(jù)或需要高性能的場(chǎng)景下，代碼性能的優(yōu)化就顯得尤為重要。本文將介紹十五種優(yōu)化 Python 代碼性能的方法，并配以詳細(xì)的代碼示例，幫助你寫(xiě)出更高效的代碼。
1. 使用內(nèi)置函數(shù)
Python 的內(nèi)置函數(shù)通常是用 C 語(yǔ)言實(shí)現(xiàn)的，速度比純 Python 代碼快很多。盡量使用內(nèi)置函數(shù)可以提高代碼性能。
# 使用內(nèi)置 sum 函數(shù)
numbers = [1, 2, 3, 4, 5]
total = sum(numbers) # 推薦
# 使用循環(huán)
total = 0
for number in numbers:
total += number # 不推薦，性能較差
print(total) # 輸出: 152. 使用生成器表達(dá)式代替列表推導(dǎo)式
生成器表達(dá)式比列表推導(dǎo)式更節(jié)省內(nèi)存，因?yàn)樗粫?huì)一次性生成整個(gè)列表，而是按需生成元素。
# 使用列表推導(dǎo)式
squares = [x**2 for x in range(10)] # 內(nèi)存占用較大
# 使用生成器表達(dá)式
squares_gen = (x**2 for x in range(10)) # 內(nèi)存占用較小
print(list(squares_gen)) # 輸出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]3. 使用 join 方法拼接字符串
使用 + 操作符拼接大量字符串時(shí)，每次拼接都會(huì)創(chuàng)建一個(gè)新的字符串對(duì)象，導(dǎo)致效率低下。使用 join 方法可以顯著提高性能。
import time
big_list_of_strings = ["word"] * 1000000
# 使用 + 操作符拼接
start_time = time.time()
result = ""
for word in big_list_of_strings:
result += word
print("使用 + 操作符耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較長(zhǎng)
# 使用 join 方法拼接
start_time = time.time()
result = "".join(big_list_of_strings)
print("使用 join 方法耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較短4. 使用局部變量
訪(fǎng)問(wèn)局部變量比訪(fǎng)問(wèn)全局變量快，因?yàn)榫植孔兞吭诤瘮?shù)的棧幀中，而全局變量在全局命名空間中。
# 使用全局變量
x = 10
def use_global():
for _ in range(1000000):
y = x # 訪(fǎng)問(wèn)全局變量
# 使用局部變量
def use_local():
x = 10
for _ in range(1000000):
y = x # 訪(fǎng)問(wèn)局部變量
import time
start_time = time.time()
use_global()
print("使用全局變量耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較長(zhǎng)
start_time = time.time()
use_local()
print("使用局部變量耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較短5. 避免不必要的抽象
過(guò)度抽象會(huì)增加函數(shù)調(diào)用的開(kāi)銷(xiāo)，有時(shí)直接編寫(xiě)具體代碼反而更高效。
# 過(guò)度抽象
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)
# 直接編寫(xiě)具體代碼
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ù)耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較長(zhǎng)
start_time = time.time()
for _ in range(1000000):
compute_direct(a, b, 'add')
print("使用具體代碼耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較短6. 使用 if __name__ == "__main__":
將主程序邏輯放在 if __name__ == "__main__": 塊中，可以避免在模塊被導(dǎo)入時(shí)執(zhí)行不必要的代碼。
# main.py
def main():
print("Hello, World!")
if __name__ == "__main__":
main()
# 當(dāng)運(yùn)行 main.py 時(shí)，會(huì)輸出 "Hello, World!"
# 當(dāng)其他模塊導(dǎo)入 main.py 時(shí)，不會(huì)執(zhí)行 main() 函數(shù)7. 使用 try-except 塊處理異常
異常處理會(huì)減慢代碼速度，但合理使用 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("不使用異常處理耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較長(zhǎng)
start_time = time.time()
for _ in range(1000000):
divide_with_exception(a, b)
print("使用異常處理耗時(shí):", time.time() - start_time) # 輸出耗時(shí)較短（但注意異常處理開(kāi)銷(xiāo)）8. 使用 collections.defaultdict
collections.defaultdict 可以在字典中訪(fǎng)問(wèn)不存在的鍵時(shí)自動(dòng)提供一個(gè)默認(rèn)值，避免了頻繁的鍵存在性檢查。
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ù)時(shí)非常高效。
import itertools
# 使用 itertools.chain 合并多個(gè)迭代器
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ù)結(jié)果
functools.lru_cache 可以緩存函數(shù)的返回值，避免重復(fù)計(jì)算，提高性能。
import functools
@functools.lru_cache(maxsize=None)
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
# 第一次調(diào)用會(huì)計(jì)算
print(fibonacci(10)) # 輸出: 55
# 第二次調(diào)用會(huì)直接返回緩存結(jié)果
print(fibonacci(10)) # 輸出: 55，但速度更快11. 使用 numpy 進(jìn)行數(shù)值計(jì)算
numpy 是一個(gè)用于科學(xué)計(jì)算的庫(kù)，其內(nèi)部實(shí)現(xiàn)了高效的數(shù)組操作，比純 Python 代碼快很多。
import numpy as np
# 使用純 Python 計(jì)算數(shù)組和
arr = [1, 2, 3, 4, 5]
total = sum(arr)
# 使用 numpy 計(jì)算數(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í)行多個(gè)進(jìn)程，充分利用多核 CPU 的計(jì)算能力。
from multiprocessing import Pool
def square(x):
return x ** 2
if __name__ == "__main__":
with Pool(4) as pool: # 創(chuàng)建包含 4 個(gè)進(jìn)程的池
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 進(jìn)行異步編程
asyncio 是 Python 3.4 引入的異步 I/O 框架，可以提高網(wǎng)絡(luò)請(qǐng)求、文件讀寫(xiě)等 I/O 密集型任務(wù)的性能。
import asyncio
async def fetch_data(url):
# 模擬網(wǎng)絡(luò)請(qǐng)求
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)
# 運(yùn)行異步主程序
asyncio.run(main())
# 輸出: ['Data from http://example.com/1', 'Data from http://example.com/2', 'Data from http://example.com/3']14. 使用 memoryview 減少內(nèi)存復(fù)制
memoryview 對(duì)象允許你創(chuàng)建對(duì)同一內(nèi)存塊的多個(gè)視圖，從而減少內(nèi)存復(fù)制，提高性能。
import numpy as np
# 創(chuàng)建一個(gè) numpy 數(shù)組
arr = np.array([1, 2, 3, 4, 5])
# 創(chuàng)建一個(gè) memoryview 對(duì)象
mv = memoryview(arr)
# 修改 memoryview 對(duì)象會(huì)影響原數(shù)組
mv[0] = 10
print(arr) # 輸出: [10 2 3 4 5]15. 使用 JIT 編譯（如 numba）
numba 是一個(gè)開(kāi)源庫(kù)，可以將 Python 代碼即時(shí)編譯成機(jī)器碼，從而提高性能。
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]實(shí)戰(zhàn)案例：優(yōu)化圖像處理代碼
假設(shè)我們需要對(duì)一個(gè)大型圖像數(shù)據(jù)集進(jìn)行簡(jiǎn)單的灰度轉(zhuǎn)換處理。原始代碼使用純 Python 實(shí)現(xiàn)，性能較差。我們可以使用上述優(yōu)化技巧來(lái)提高性能。
原始代碼
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
# 假設(shè)我們有一個(gè)包含大量圖像路徑的列表
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 進(jìn)行高效的數(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: # 假設(shè)有 4 個(gè) CPU 核心
gray_images = pool.map(convert_to_grayscale, image_paths)
# 可以進(jìn)一步處理 gray_images，例如保存到磁盤(pán)或進(jìn)行其他分析
for i, gray_image in enumerate(gray_images):
cv2.imwrite(f"gray_{image_paths[i]}", gray_image)在這個(gè)案例中，通過(guò)使用 multiprocessing 模塊并行處理圖像，我們充分利用了多核 CPU 的計(jì)算能力，顯著提高了圖像處理的效率。同時(shí)，使用 cv2 和 numpy 進(jìn)行圖像讀取和轉(zhuǎn)換操作，也保證了代碼的高效性。
總結(jié)
本文介紹了十五種優(yōu)化 Python 代碼性能的方法，包括使用內(nèi)置函數(shù)、生成器表達(dá)式、join 方法拼接字符串、局部變量、if name == "main": 塊、try-except 塊、collections.defaultdict、itertools 模塊、functools.lru_cache、numpy、multiprocessing 模塊、asyncio、memoryview 和 JIT 編譯（如 numba）。
通過(guò)實(shí)際應(yīng)用這些技巧，你可以顯著提高 Python 代碼的性能，特別是在處理大量數(shù)據(jù)或需要高性能的場(chǎng)景下。同時(shí)，本文還通過(guò)一個(gè)實(shí)戰(zhàn)案例展示了如何結(jié)合多種優(yōu)化技巧來(lái)提高圖像處理代碼的效率。
