Python 是一種指令碼語言,相比 C/C++ 這樣的編譯語言,在效率和效能方面存在一些不足。但是,有很多時候,Python 的效率並沒有想象中的那麼誇張。本文對一些 Python 程式碼加速執行的技巧進行整理。
0. 程式碼最佳化原則
本文會介紹不少的 Python 程式碼加速執行的技巧。在深入程式碼最佳化細節之前,需要了解一些程式碼最佳化基本原則。
第一個基本原則是不要過早最佳化。很多人一開始寫程式碼就奔著效能最佳化的目標,“讓正確的程式更快要比讓快速的程式正確容易得多”。因此,最佳化的前提是程式碼能正常工作。過早地進行最佳化可能會忽視對總體效能指標的把握,在得到全域性結果前不要主次顛倒。
第二個基本原則是權衡最佳化的代價。最佳化是有代價的,想解決所有效能的問題是幾乎不可能的。通常面臨的選擇是時間換空間或空間換時間。另外,開發代價也需要考慮。
第三個原則是不要最佳化那些無關緊要的部分。如果對程式碼的每一部分都去最佳化,這些修改會使程式碼難以閱讀和理解。如果你的程式碼執行速度很慢,首先要找到程式碼執行慢的位置,通常是內部迴圈,專注於執行慢的地方進行最佳化。在其他地方,一點時間上的損失沒有什麼影響。
1. 避免全域性變數
# 不推薦寫法。程式碼耗時:26。8秒
import math
size = 10000
for x in range(size):
for y in range(size):
z = math。sqrt(x) + math。sqrt(y)
許多程式設計師剛開始會用 Python 語言寫一些簡單的指令碼,當編寫指令碼時,通常習慣了直接將其寫為全域性變數,例如上面的程式碼。但是,由於全域性變數和區域性變數實現方式不同,定義在全域性範圍內的程式碼執行速度會比定義在函式中的慢不少。透過將指令碼語句放入到函式中,通常可帶來 15% - 30% 的速度提升。
# 推薦寫法。程式碼耗時:20。6秒
import math
def main(): # 定義到函式中,以減少全部變數使用
size = 10000
for x in range(size):
for y in range(size):
z = math。sqrt(x) + math。sqrt(y)
main()
2. 避免.
2.1 避免模組和函式屬性訪問
# 不推薦寫法。程式碼耗時:14。5秒
import math
def computeSqrt(size: int):
result = []
for i in range(size):
result。append(math。sqrt(i))
return result
def main():
size = 10000
for _ in range(size):
result = computeSqrt(size)
main()
每次使用
。
(屬性訪問運算子時)會觸發特定的方法,如
__getattribute__()
和
__getattr__()
,這些方法會進行字典操作,因此會帶來額外的時間開銷。透過
from import
語句,可以消除屬性訪問。
# 第一次最佳化寫法。程式碼耗時:10。9秒
from math import sqrt
def computeSqrt(size: int):
result = []
for i in range(size):
result。append(sqrt(i)) # 避免math。sqrt的使用
return result
def main():
size = 10000
for _ in range(size):
result = computeSqrt(size)
main()
在第 1 節中我們講到,區域性變數的查詢會比全域性變數更快,因此對於頻繁訪問的變數
sqrt
,透過將其改為區域性變數可以加速執行。
# 第二次最佳化寫法。程式碼耗時:9。9秒
import math
def computeSqrt(size: int):
result = []
sqrt = math。sqrt # 賦值給區域性變數
for i in range(size):
result。append(sqrt(i)) # 避免math。sqrt的使用
return result
def main():
size = 10000
for _ in range(size):
result = computeSqrt(size)
main()
除了
math。sqrt
外,
computeSqrt
函式中還有
。
的存在,那就是呼叫
list
的
append
方法。透過將該方法賦值給一個區域性變數,可以徹底消除
computeSqrt
函式中
for
迴圈內部的
。
使用。
# 推薦寫法。程式碼耗時:7。9秒
import math
def computeSqrt(size: int):
result = []
append = result。append
sqrt = math。sqrt # 賦值給區域性變數
for i in range(size):
append(sqrt(i)) # 避免 result。append 和 math。sqrt 的使用
return result
def main():
size = 10000
for _ in range(size):
result = computeSqrt(size)
main()
2.2 避免類內屬性訪問
# 不推薦寫法。程式碼耗時:10。4秒
import math
from typing import List
class DemoClass:
def __init__(self, value: int):
self。_value = value
def computeSqrt(self, size: int) -> List[float]:
result = []
append = result。append
sqrt = math。sqrt
for _ in range(size):
append(sqrt(self。_value))
return result
def main():
size = 10000
for _ in range(size):
demo_instance = DemoClass(size)
result = demo_instance。computeSqrt(size)
main()
避免
。
的原則也適用於類內屬性,訪問
self。_value
的速度會比訪問一個區域性變數更慢一些。透過將需要頻繁訪問的類內屬性賦值給一個區域性變數,可以提升程式碼執行速度。
# 推薦寫法。程式碼耗時:8。0秒
import math
from typing import List
class DemoClass:
def __init__(self, value: int):
self。_value = value
def computeSqrt(self, size: int) -> List[float]:
result = []
append = result。append
sqrt = math。sqrt
value = self。_value
for _ in range(size):
append(sqrt(value)) # 避免 self。_value 的使用
return result
def main():
size = 10000
for _ in range(size):
demo_instance = DemoClass(size)
demo_instance。computeSqrt(size)
main()
3. 避免不必要的抽象
# 不推薦寫法,程式碼耗時:0。55秒
class DemoClass:
def __init__(self, value: int):
self。value = value
@property
def value(self) -> int:
return self。_value
@value。setter
def value(self, x: int):
self。_value = x
def main():
size = 1000000
for i in range(size):
demo_instance = DemoClass(size)
value = demo_instance。value
demo_instance。value = i
main()
任何時候當你使用額外的處理層(比如裝飾器、屬性訪問、描述器)去包裝程式碼時,都會讓程式碼變慢。大部分情況下,需要重新進行審視使用屬性訪問器的定義是否有必要,使用
getter/setter
函式對屬性進行訪問通常是 C/C++ 程式設計師遺留下來的程式碼風格。如果真的沒有必要,就使用簡單屬性。
# 推薦寫法,程式碼耗時:0。33秒
class DemoClass:
def __init__(self, value: int):
self。value = value # 避免不必要的屬性訪問器
def main():
size = 1000000
for i in range(size):
demo_instance = DemoClass(size)
value = demo_instance。value
demo_instance。value = i
main()
4. 避免資料複製
4.1 避免無意義的資料複製
# 不推薦寫法,程式碼耗時:6。5秒
def main():
size = 10000
for _ in range(size):
value = range(size)
value_list = [x for x in value]
square_list = [x * x for x in value_list]
main()
上面的程式碼中
value_list
完全沒有必要,這會建立不必要的資料結構或複製。
# 推薦寫法,程式碼耗時:4。8秒
def main():
size = 10000
for _ in range(size):
value = range(size)
square_list = [x * x for x in value] # 避免無意義的複製
main()
另外一種情況是對 Python 的資料共享機制過於偏執,並沒有很好地理解或信任 Python 的記憶體模型,濫用
copy。deepcopy()
之類的函式。通常在這些程式碼中是可以去掉複製操作的。
4.2 交換值時不使用中間變數
# 不推薦寫法,程式碼耗時:0。07秒
def main():
size = 1000000
for _ in range(size):
a = 3
b = 5
temp = a
a = b
b = temp
main()
上面的程式碼在交換值時建立了一個臨時變數
temp
,如果不借助中間變數,程式碼更為簡潔、且執行速度更快。
# 推薦寫法,程式碼耗時:0。06秒
def main():
size = 1000000
for _ in range(size):
a = 3
b = 5
a, b = b, a # 不借助中間變數
main()
4.3 字串拼接用join而不是+
# 不推薦寫法,程式碼耗時:2。6秒
import string
from typing import List
def concatString(string_list: List[str]) -> str:
result = ‘’
for str_i in string_list:
result += str_i
return result
def main():
string_list = list(string。ascii_letters * 100)
for _ in range(10000):
result = concatString(string_list)
main()
當使用
a + b
拼接字串時,由於 Python 中字串是不可變物件,其會申請一塊記憶體空間,將
a
和
b
分別複製到該新申請的記憶體空間中。因此,如果要拼接 n 個字串,會產生 n-1 箇中間結果,每產生一箇中間結果都需要申請和複製一次記憶體,嚴重影響執行效率。而使用
join()
拼接字串時,會首先計算出需要申請的總的記憶體空間,然後一次性地申請所需記憶體,並將每個字串元素複製到該記憶體中去。
# 推薦寫法,程式碼耗時:0。3秒
import string
from typing import List
def concatString(string_list: List[str]) -> str:
return ‘’。join(string_list) # 使用 join 而不是 +
def main():
string_list = list(string。ascii_letters * 100)
for _ in range(10000):
result = concatString(string_list)
main()
5. 利用if條件的短路特性
# 不推薦寫法,程式碼耗時:0。05秒
from typing import List
def concatString(string_list: List[str]) -> str:
abbreviations = {‘cf。’, ‘e。g。’, ‘ex。’, ‘etc。’, ‘flg。’, ‘i。e。’, ‘Mr。’, ‘vs。’}
abbr_count = 0
result = ‘’
for str_i in string_list:
if str_i in abbreviations:
result += str_i
return result
def main():
for _ in range(10000):
string_list = [‘Mr。’, ‘Hat’, ‘is’, ‘Chasing’, ‘the’, ‘black’, ‘cat’, ‘。’]
result = concatString(string_list)
main()
if
條件的短路特性是指對
if a and b
這樣的語句, 當
a
為
False
時將直接返回,不再計算
b
;對於
if a or b
這樣的語句,當
a
為
True
時將直接返回,不再計算
b
。因此, 為了節約執行時間,對於
or
語句,應該將值為
True
可能性比較高的變數寫在
or
前,而
and
應該推後。
# 推薦寫法,程式碼耗時:0。03秒
from typing import List
def concatString(string_list: List[str]) -> str:
abbreviations = {‘cf。’, ‘e。g。’, ‘ex。’, ‘etc。’, ‘flg。’, ‘i。e。’, ‘Mr。’, ‘vs。’}
abbr_count = 0
result = ‘’
for str_i in string_list:
if str_i[-1] == ‘。’ and str_i in abbreviations: # 利用 if 條件的短路特性
result += str_i
return result
def main():
for _ in range(10000):
string_list = [‘Mr。’, ‘Hat’, ‘is’, ‘Chasing’, ‘the’, ‘black’, ‘cat’, ‘。’]
result = concatString(string_list)
main()
6. 迴圈最佳化
6.1 用for迴圈代替while迴圈
# 不推薦寫法。程式碼耗時:6。7秒
def computeSum(size: int) -> int:
sum_ = 0
i = 0
while i < size:
sum_ += i
i += 1
return sum_
def main():
size = 10000
for _ in range(size):
sum_ = computeSum(size)
main()
Python 的
for
迴圈比
while
迴圈快不少。
# 推薦寫法。程式碼耗時:4。3秒
def computeSum(size: int) -> int:
sum_ = 0
for i in range(size): # for 迴圈代替 while 迴圈
sum_ += i
return sum_
def main():
size = 10000
for _ in range(size):
sum_ = computeSum(size)
main()
6.2 使用隱式for迴圈代替顯式for迴圈
針對上面的例子,更進一步可以用隱式
for
迴圈來替代顯式
for
迴圈
# 推薦寫法。程式碼耗時:1。7秒
def computeSum(size: int) -> int:
return sum(range(size)) # 隱式 for 迴圈代替顯式 for 迴圈
def main():
size = 10000
for _ in range(size):
sum = computeSum(size)
main()
6.3 減少內層for迴圈的計算
# 不推薦寫法。程式碼耗時:12。8秒
import math
def main():
size = 10000
sqrt = math。sqrt
for x in range(size):
for y in range(size):
z = sqrt(x) + sqrt(y)
main()
上面的程式碼中
sqrt(x)
位於內側
for
迴圈, 每次訓練過程中都會重新計算一次,增加了時間開銷。
# 推薦寫法。程式碼耗時:7。0秒
import math
def main():
size = 10000
sqrt = math。sqrt
for x in range(size):
sqrt_x = sqrt(x) # 減少內層 for 迴圈的計算
for y in range(size):
z = sqrt_x + sqrt(y)
main()
7. 使用numba.jit
我們沿用上面介紹過的例子,在此基礎上使用
numba。jit
。
numba
可以將 Python 函式 JIT 編譯為機器碼執行,大大提高程式碼執行速度。關於
numba
的更多資訊見下面的主頁:
http://
numba。pydata。org/numba。
pydata。org
# 推薦寫法。程式碼耗時:0。62秒
import numba
@numba。jit
def computeSum(size: float) -> int:
sum = 0
for i in range(size):
sum += i
return sum
def main():
size = 10000
for _ in range(size):
sum = computeSum(size)
main()
8. 選擇合適的資料結構
Python 內建的資料結構如
str
,
tuple
,
list
,
set
,
dict
底層都是 C 實現的,速度非常快,自己實現新的資料結構想在效能上達到內建的速度幾乎是不可能的。
list
類似於 C++ 中的
std::vector
,是一種動態陣列。其會預分配一定記憶體空間,當預分配的記憶體空間用完,又繼續向其中新增元素時,會申請一塊更大的記憶體空間,然後將原有的所有元素都複製過去,之後銷燬之前的記憶體空間,再插入新元素。
刪除元素時操作類似,當已使用記憶體空間比預分配記憶體空間的一半還少時,會另外申請一塊小記憶體,做一次元素複製,之後銷燬原有大記憶體空間。
因此,如果有頻繁的新增、刪除操作,新增、刪除的元素數量又很多時,list的效率不高。此時,應該考慮使用
collections。deque
。
collections。deque
是雙端佇列,同時具備棧和佇列的特性,能夠在兩端進行 O(1) 複雜度的插入和刪除操作。
list
的查詢操作也非常耗時。當需要在
list
頻繁查詢某些元素,或頻繁有序訪問這些元素時,可以使用
bisect
維護
list
物件有序並在其中進行二分查詢,提升查詢的效率。
另外一個常見需求是查詢極小值或極大值,此時可以使用
heapq
模組將
list
轉化為一個堆,使得獲取最小值的時間複雜度是 O(1)。
下面的網頁給出了常用的 Python 資料結構的各項操作的時間複雜度:
https://
wiki。python。org/moin/Ti
meComplexity
參考資料
David Beazley & Brian K。 Jones。 Python Cookbook, Third edition。 O‘Reilly Media, ISBN: 9781449340377, 2013。
張穎 & 賴勇浩。 編寫高質量程式碼:改善Python程式的91個建議。 機械工業出版社, ISBN: 9787111467045, 2014。
作者:張皓
連結:
https://
zhuanlan。zhihu。com/p/14
3052860