九個(gè)技巧，讓你的Python代碼運(yùn)行得更快！
在編程語(yǔ)言的討論中，我們經(jīng)常聽(tīng)到 “Python 太慢了” 的聲音，這往往掩蓋了 Python 的許多優(yōu)點(diǎn)。但事實(shí)上，如果你能以 Pythonic 的方式編寫(xiě)代碼，Python 可以非常快。
細(xì)節(jié)決定成敗。經(jīng)驗(yàn)豐富的 Python 開(kāi)發(fā)者擁有一系列微妙而強(qiáng)大的技巧，這些技巧可以顯著提高代碼的性能。
這些技巧乍一看可能微不足道，但它們可以帶來(lái)效率的大幅提升。讓我們深入探討這 9 種方法，改變你編寫(xiě)和優(yōu)化 Python 代碼的方式。
1. 更快的字符串連接：巧妙選擇 "join()" 或 "+"
如果有很多字符串需要處理，字符串連接就會(huì)成為 Python 程序的瓶頸。
在 Python 中，字符串連接基本上有兩種方式：
- 使用join()函數(shù)將一個(gè)字符串列表合并為一個(gè)
- 使用+或+=符號(hào)將每個(gè)字符串添加到一個(gè)字符串中
那么哪種方式更快呢？
讓我們來(lái)定義 3 個(gè)不同的函數(shù)來(lái)連接相同的字符串：
mylist = ["Yang", "Zhou", "is", "writing"]
# 使用'+'
def concat_plus():
result = ""
for word in mylist:
result += word + " "
return result
# 使用'join()'
def concat_join():
return " ".join(mylist)
# 直接連接字符串，不使用列表
def concat_directly():
return "Yang" + "Zhou" + "is" + "writing"根據(jù)你的第一印象，你認(rèn)為哪個(gè)函數(shù)最快，哪個(gè)最慢？
實(shí)際結(jié)果可能會(huì)讓你驚訝：
import timeit
print(timeit.timeit(concat_plus, number=10000))
# 0.002738415962085128
print(timeit.timeit(concat_join, number=10000))
# 0.0008482920238748193
print(timeit.timeit(concat_directly, number=10000))
# 0.00021425005979835987如上所示，對(duì)于連接一個(gè)字符串列表，join()方法比在 for 循環(huán)中逐個(gè)添加字符串要快。
原因是直接的。一方面，字符串在 Python 中是不可變數(shù)據(jù)，在每次+=操作中都會(huì)創(chuàng)建一個(gè)新的字符串并復(fù)制舊字符串，這在計(jì)算上是昂貴的。
另一方面，.join()方法專門優(yōu)化了字符串的連接。它預(yù)先計(jì)算結(jié)果字符串的大小，然后一次性構(gòu)建它。因此，它避免了在循環(huán)中+=操作的開(kāi)銷，因此它更快。
然而，在我們的測(cè)試中最快的函數(shù)是直接連接字符串字面量。它的高速度是由于：
- Python 解釋器可以在編譯時(shí)優(yōu)化字符串字面量的連接，將它們變成單個(gè)字符串字面量。沒(méi)有循環(huán)迭代或函數(shù)調(diào)用，這使得它是一個(gè)非常高效的操作。
- 由于所有字符串在編譯時(shí)都是已知的，Python 可以非常快速地執(zhí)行此操作，比循環(huán)中的運(yùn)行時(shí)連接或甚至優(yōu)化的.join()方法都要快得多。
總之，如果你需要連接一個(gè)字符串列表，請(qǐng)選擇join()而不是+=。如果你想直接連接字符串，只需使用+即可。
2. 更快的列表創(chuàng)建：使用"[]"而不是"list()"
創(chuàng)建列表不是什么大不了的事。有兩種常見(jiàn)的方式：
- 使用list()函數(shù)
- 直接使用[]
讓我們使用一個(gè)簡(jiǎn)單的代碼片段來(lái)測(cè)試它們的性能：
import timeit
print(timeit.timeit('[]', number=10 ** 7))
# 0.1368238340364769
print(timeit.timeit(list, number=10 ** 7))
# 0.2958830420393497如結(jié)果所示，執(zhí)行l(wèi)ist()函數(shù)比直接使用[]要慢。
這是因?yàn)閇]是字面量語(yǔ)法，而list()是一個(gè)構(gòu)造函數(shù)調(diào)用。調(diào)用函數(shù)無(wú)疑需要額外的時(shí)間。
同樣的邏輯，當(dāng)創(chuàng)建字典時(shí)，我們也應(yīng)該利用{}而不是dict()。
3. 更快的成員測(cè)試：使用集合而不是列表
成員檢查操作的性能在很大程度上取決于底層數(shù)據(jù)結(jié)構(gòu)：
import timeit
large_dataset = range(100000)
search_element = 2077
large_list = list(large_dataset)
large_set = set(large_dataset)
def list_membership_test():
return search_element in large_list
def set_membership_test():
return search_element in large_set
print(timeit.timeit(list_membership_test, number=1000))
# 0.01112208398990333
print(timeit.timeit(set_membership_test, number=1000))
# 3.27499583363533e-05如上述代碼所示，集合中的成員測(cè)試比列表中的要快得多。
為什么會(huì)這樣？
- 在 Python 列表中，成員測(cè)試（element in list）是通過(guò)遍歷每個(gè)元素直到找到所需元素或到達(dá)列表末尾來(lái)完成的。因此，此操作的時(shí)間復(fù)雜度為 O(n)。
- Python 中的集合是作為哈希表實(shí)現(xiàn)的。當(dāng)檢查成員資格（element in set）時(shí)，Python 使用哈希機(jī)制，其平均時(shí)間復(fù)雜度為 O(1)。
這里的要點(diǎn)是在編寫(xiě)程序時(shí)要仔細(xì)考慮底層數(shù)據(jù)結(jié)構(gòu)。利用正確的數(shù)據(jù)結(jié)構(gòu)可以顯著加快我們的代碼速度。
4. 更快的數(shù)據(jù)生成：使用推導(dǎo)式而不是 for 循環(huán)
Python 中有四種類型的推導(dǎo)式：列表、字典、集合和生成器。它們不僅為創(chuàng)建相對(duì)數(shù)據(jù)結(jié)構(gòu)提供了更簡(jiǎn)潔的語(yǔ)法，而且比使用 for 循環(huán)有更好的性能，因?yàn)樗鼈冊(cè)?Python 的 C 實(shí)現(xiàn)中進(jìn)行了優(yōu)化。
import timeit
def generate_squares_for_loop():
squares = []
for i in range(1000):
squares.append(i * i)
return squares
def generate_squares_comprehension():
return [i * i for i in range(1000)]
print(timeit.timeit(generate_squares_for_loop, number=10000))
# 0.2797503340989351
print(timeit.timeit(generate_squares_comprehension, number=10000))
# 0.2364629579242319上述代碼是列表推導(dǎo)式和 for 循環(huán)之間的簡(jiǎn)單速度比較。如結(jié)果所示，列表推導(dǎo)式更快。
5. 更快的循環(huán)：優(yōu)先使用局部變量
在 Python 中，訪問(wèn)局部變量比訪問(wèn)全局變量或?qū)ο蟮膶傩砸臁?/p>
這里有一個(gè)實(shí)例來(lái)證明這一點(diǎn)：
import timeit
class Example:
def __init__(self):
self.value = 0
obj = Example()
def test_dot_notation():
for _ in range(1000):
obj.value += 1
def test_local_variable():
value = obj.value
for _ in range(1000):
value += 1
obj.value = value
print(timeit.timeit(test_dot_notation, number=1000))
# 0.036605041939765215
print(timeit.timeit(test_local_variable, number=1000))
# 0.024470250005833805這就是 Python 的工作方式。直觀地說(shuō)，當(dāng)一個(gè)函數(shù)被編譯時(shí)，里面的局部變量是已知的，但其他外部變量需要時(shí)間來(lái)檢索。
這是一個(gè)小問(wèn)題，但我們可以利用它來(lái)優(yōu)化我們?cè)谔幚泶罅繑?shù)據(jù)時(shí)的代碼。
6. 更快的執(zhí)行：優(yōu)先使用內(nèi)置模塊和庫(kù)
當(dāng)工程師們說(shuō) Python 時(shí)，他們通常指的是 CPython。因?yàn)?CPython 是 Python 語(yǔ)言的默認(rèn)和最廣泛使用的實(shí)現(xiàn)。
鑒于其大多數(shù)內(nèi)置模塊和庫(kù)都是用 C 語(yǔ)言編寫(xiě)的，C 是一種更快的低級(jí)語(yǔ)言，我們應(yīng)該利用內(nèi)置的武器庫(kù)，避免重新發(fā)明輪子。
import timeit
import random
from collections import Counter
def count_frequency_custom(lst):
frequency = {}
for item in lst:
if item in frequency:
frequency[item] += 1
else:
frequency[item] = 1
return frequency
def count_frequency_builtin(lst):
return Counter(lst)
large_list = [random.randint(0, 100) for _ in range(1000)]
print(timeit.timeit(lambda: count_frequency_custom(large_list), number=100))
# 0.005160166998393834
print(timeit.timeit(lambda: count_frequency_builtin(large_list), number=100))
# 0.002444291952997446上述程序比較了兩種計(jì)算列表中元素頻率的方法。我們可以看到，利用內(nèi)置的Counter來(lái)自collections模塊更快、更整潔、更好。
7. 更快的函數(shù)調(diào)用：利用緩存裝飾器進(jìn)行簡(jiǎn)單的記憶化
緩存是一種常用的技術(shù)，用于避免重復(fù)計(jì)算并加速程序。
幸運(yùn)的是，在大多數(shù)情況下，我們不需要編寫(xiě)自己的緩存處理代碼，因?yàn)?Python 為此目的提供了一個(gè)現(xiàn)成的裝飾器——@functools.cache。
例如，以下代碼將執(zhí)行兩個(gè)斐波那契數(shù)生成函數(shù)，一個(gè)有緩存裝飾器，另一個(gè)沒(méi)有：
import timeit
import functools
def fibonacci(n):
if n in (0, 1):
return n
return fibonacci(n - 1) + fibonacci(n - 2)
@functools.cache
def fibonacci_cached(n):
if n in (0, 1):
return n
return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)
# 測(cè)試每個(gè)函數(shù)的執(zhí)行時(shí)間
print(timeit.timeit(lambda: fibonacci(30), number=1))
# 0.09499712497927248
print(timeit.timeit(lambda: fibonacci_cached(30), number=1))
# 6.458023563027382e-06結(jié)果證明了functools.cache裝飾器使我們的代碼更快。
基本的fibonacci函數(shù)效率低下，因?yàn)樵诘玫絝ibonacci(30)的結(jié)果過(guò)程中，它多次重新計(jì)算相同的斐波那契數(shù)。
緩存版本要快得多，因?yàn)樗彺媪讼惹坝?jì)算的結(jié)果。因此，它只計(jì)算一次每個(gè)斐波那契數(shù)，后續(xù)具有相同參數(shù)的調(diào)用從緩存中檢索。
僅僅添加一個(gè)內(nèi)置裝飾器就可以帶來(lái)如此大的改進(jìn)，這就是 Pythonic 的意思。??
8. 更快的無(wú)限循環(huán)：優(yōu)先選擇 "while 1" 而不是 "while True"
要?jiǎng)?chuàng)建一個(gè)無(wú)限 while 循環(huán)，我們可以使用while True或while 1。
它們性能的差異通常可以忽略不計(jì)。但有趣的是，while 1稍微快一點(diǎn)。
這是因?yàn)?是字面量，但True是一個(gè)需要在 Python 的全局作用域中查找的全局名稱，因此需要一個(gè)微小的開(kāi)銷。
讓我們也在代碼片段中檢查這兩種方式的實(shí)際比較：
import timeit
def loop_with_true():
i = 0
while True:
if i >= 1000:
break
i += 1
def loop_with_one():
i = 0
while 1:
if i >= 1000:
break
i += 1
print(timeit.timeit(loop_with_true, number=10000))
# 0.1733035419601947
print(timeit.timeit(loop_with_one, number=10000))
# 0.16412191605195403如我們所見(jiàn)，while 1確實(shí)稍微快一點(diǎn)。
然而，現(xiàn)代 Python 解釋器（如 CPython）高度優(yōu)化，這種差異通常可以忽略不計(jì)。更不用說(shuō)while True比while 1更易讀。
9. 更快的啟動(dòng)：智能導(dǎo)入 Python 模塊
在 Python 腳本的頂部導(dǎo)入所有模塊似乎是自然而然的事情。
實(shí)際上，我們不必這么做。
此外，如果一個(gè)模塊太大，按需導(dǎo)入它是一個(gè)更好的主意。
def my_function():
import heavy_module
# 函數(shù)的其余部分如上述代碼，heavy_module在函數(shù)內(nèi)部導(dǎo)入。這是一種“懶加載”的思想，即導(dǎo)入被推遲到my_function被調(diào)用時(shí)。
這種方法的好處是，如果my_function在腳本執(zhí)行過(guò)程中從未被調(diào)用，那么heavy_module就永遠(yuǎn)不會(huì)被加載，節(jié)省了資源并減少了腳本的啟動(dòng)時(shí)間。
