歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

Python 代碼性能優化技巧

簡介: 選擇了腳本語言就要忍受其速度,這句話在某種程度上說明了 python 作為腳本的一個不足之處,那就是執行效率和性能不夠理想,特別是在 performance 較差的機器上,因此有必要進行一定的代碼優化來提高程序的執行效率。如何進行 Python 性能優化,是本文探討的主要問題。本文會涉及常見的代碼優化方法,性能優化工具的使用以及如何診斷代碼的性能瓶頸等內容,希望可以給 Python 開發人員一定的參考。

Python 代碼優化常見技巧

代碼優化能夠讓程序運行更快,它是在不改變程序運行結果的情況下使得程序的運行效率更高,根據 80/20 原則,實現程序的重構、優化、擴展以及文檔相關的事情通常需要消耗 80% 的工作量。優化通常包含兩方面的內容:減小代碼的體積,提高代碼的運行效率。

改進算法,選擇合適的數據結構

一個良好的算法能夠對性能起到關鍵作用,因此性能改進的首要點是對算法的改進。在算法的時間復雜度排序上依次是:

O(1) -> O(lg n) -> O(n lg n) -> O(n^2) -> O(n^3) -> O(n^k) -> O(k^n) -> O(n!)

因此如果能夠在時間復雜度上對算法進行一定的改進,對性能的提高不言而喻。但對具體算法的改進不屬於本文討論的范圍,讀者可以自行參考這方面資料。下面的內容將集中討論數據結構的選擇。

  • 字典 (dictionary) 與列表 (list)

Python 字典中使用了 hash table,因此查找操作的復雜度為 O(1),而 list 實際是個數組,在 list 中,查找需要遍歷整個 list,其復雜度為 O(n),因此對成員的查找訪問等操作字典要比 list 更快。


清單 1. 代碼 dict.py

				
 from time import time 
 t = time() 
 list = ['a','b','is','python','jason','hello','hill','with','phone','test', 
'dfdf','apple','pddf','ind','basic','none','baecr','var','bana','dd','wrd'] 
 #list = dict.fromkeys(list,True) 
 print list 
 filter = [] 
 for i in range (1000000): 
	 for find in ['is','hat','new','list','old','.']: 
		 if find not in list: 
			 filter.append(find) 
 print "total run time:"
 print time()-t 

上述代碼運行大概需要 16.09seconds。如果去掉行 #list = dict.fromkeys(list,True) 的注釋,將 list 轉換為字典之後再運行,時間大約為 8.375 seconds,效率大概提高了一半。因此在需要多數據成員進行頻繁的查找或者訪問的時候,使用 dict 而不是 list 是一個較好的選擇。

  • 集合 (set) 與列表 (list)

set 的 union, intersection,difference 操作要比 list 的迭代要快。因此如果涉及到求 list 交集,並集或者差的問題可以轉換為 set 來操作。


清單 2. 求 list 的交集:

				
 from time import time 
 t = time() 
 lista=[1,2,3,4,5,6,7,8,9,13,34,53,42,44] 
 listb=[2,4,6,9,23] 
 intersection=[] 
 for i in range (1000000): 
	 for a in lista: 
		 for b in listb: 
			 if a == b: 
				 intersection.append(a) 


 print "total run time:"
 print time()-t 

上述程序的運行時間大概為:

 total run time: 
 38.4070000648 


清單 3. 使用 set 求交集
				
 from time import time 
 t = time() 
 lista=[1,2,3,4,5,6,7,8,9,13,34,53,42,44] 
 listb=[2,4,6,9,23] 
 intersection=[] 
 for i in range (1000000): 
	 list(set(lista)&set(listb)) 
 print "total run time:"
 print time()-t 

改為 set 後程序的運行時間縮減為 8.75,提高了 4 倍多,運行時間大大縮短。讀者可以自行使用表 1 其他的操作進行測試。


表 1. set 常見用法
語法 操作 說明 set(list1) | set(list2) union 包含 list1 和 list2 所有數據的新集合 set(list1) & set(list2) intersection 包含 list1 和 list2 中共同元素的新集合 set(list1) - set(list2) difference 在 list1 中出現但不在 list2 中出現的元素的集合

對循環的優化

對循環的優化所遵循的原則是盡量減少循環過程中的計算量,有多重循環的盡量將內層的計算提到上一層。 下面通過實例來對比循環優化後所帶來的性能的提高。程序清單 4 中,如果不進行循環優化,其大概的運行時間約為 132.375。


清單 4. 為進行循環優化前

				
 from time import time 
 t = time() 
 lista = [1,2,3,4,5,6,7,8,9,10] 
 listb =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01] 
 for i in range (1000000): 
	 for a in range(len(lista)): 
		 for b in range(len(listb)): 
			 x=lista[a]+listb[b] 
 print "total run time:"
 print time()-t 

現在進行如下優化,將長度計算提到循環外,range 用 xrange 代替,同時將第三層的計算 lista[a] 提到循環的第二層。


清單 5. 循環優化後

				
 from time import time 
 t = time() 
 lista = [1,2,3,4,5,6,7,8,9,10] 
 listb =[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01] 
 len1=len(lista) 
 len2=len(listb) 
 for i in xrange (1000000): 
	 for a in xrange(len1): 
		 temp=lista[a] 
		 for b in xrange(len2): 
			 x=temp+listb[b] 
 print "total run time:"
 print time()-t 

上述優化後的程序其運行時間縮短為 102.171999931。在清單 4 中 lista[a] 被計算的次數為 1000000*10*10,而在優化後的代碼中被計算的次數為 1000000*10,計算次數大幅度縮短,因此性能有所提升。

充分利用 Lazy if-evaluation 的特性

python 中條件表達式是 lazy evaluation 的,也就是說如果存在條件表達式 if x and y,在 x 為 false 的情況下 y 表達式的值將不再計算。因此可以利用該特性在一定程度上提高程序效率。


清單 6. 利用 Lazy if-evaluation 的特性

				
 from time import time 
 t = time() 
 abbreviations = ['cf.', 'e.g.', 'ex.', 'etc.', 'fig.', 'i.e.', 'Mr.', 'vs.'] 
 for i in range (1000000): 
	 for w in ('Mr.', 'Hat', 'is', 'chasing', 'the', 'black', 'cat', '.'): 
		 if w in abbreviations: 
		 #if w[-1] == '.' and w in abbreviations: 
			 pass 
 print "total run time:"
 print time()-t 

在未進行優化之前程序的運行時間大概為 8.84,如果使用注釋行代替第一個 if,運行的時間大概為 6.17。

字符串的優化

python 中的字符串對象是不可改變的,因此對任何字符串的操作如拼接,修改等都將產生一個新的字符串對象,而不是基於原字符串,因此這種持續的 copy 會在一定程度上影響 python 的性能。對字符串的優化也是改善性能的一個重要的方面,特別是在處理文本較多的情況下。字符串的優化主要集中在以下幾個方面:

  1. 在字符串連接的使用盡量使用 join() 而不是 +:在代碼清單 7 中使用 + 進行字符串連接大概需要 0.125 s,而使用 join 縮短為 0.016s。因此在字符的操作上 join 比 + 要快,因此要盡量使用 join 而不是 +。


清單 7. 使用 join 而不是 + 連接字符串

				
 from time import time 

 t = time() 
 s = ""
 list = ['a','b','b','d','e','f','g','h','i','j','k','l','m','n'] 
 for i in range (10000): 
	 for substr in list: 
		 s+= substr 	
 print "total run time:"
 print time()-t 

同時要避免:

 s = ""
 for x in list: 
    s += func(x) 

而是要使用:

 slist = [func(elt) for elt in somelist] 
 s = "".join(slist) 

  1. 當對字符串可以使用正則表達式或者內置函數來處理的時候,選擇內置函數。如 str.isalpha(),str.isdigit(),str.startswith(('x', 'yz')),str.endswith(('x', 'yz'))
  2. 對字符進行格式化比直接串聯讀取要快,因此要使用

 out = "<html>%s%s%s%s</html>" % (head, prologue, query, tail) 

而避免

 out = "<html>" + head + prologue + query + tail + "</html>"

使用列表解析(list comprehension)和生成器表達式(generator expression)

列表解析要比在循環中重新構建一個新的 list 更為高效,因此我們可以利用這一特性來提高運行的效率。

 from time import time 
 t = time() 
 list = ['a','b','is','python','jason','hello','hill','with','phone','test', 
'dfdf','apple','pddf','ind','basic','none','baecr','var','bana','dd','wrd'] 
 total=[] 
 for i in range (1000000): 
	 for w in list: 
		 total.append(w) 
 print "total run time:"
 print time()-t 

使用列表解析:

 for i in range (1000000): 
	 a = [w for w in list] 

上述代碼直接運行大概需要 17s,而改為使用列表解析後 ,運行時間縮短為 9.29s。將近提高了一半。生成器表達式則是在 2.4 中引入的新內容,語法和列表解析類似,但是在大數據量處理時,生成器表達式的優勢較為明顯,它並不創建一個列表,只是返回一個生成器,因此效率較高。在上述例子上中代碼 a = [w for w in list] 修改為 a = (w for w in list),運行時間進一步減少,縮短約為 2.98s。

其他優化技巧

  1. 如果需要交換兩個變量的值使用 a,b=b,a 而不是借助中間變量 t=a;a=b;b=t;

 >>> from timeit import Timer 
 >>> Timer("t=a;a=b;b=t","a=1;b=2").timeit() 
 0.25154118749729365 
 >>> Timer("a,b=b,a","a=1;b=2").timeit() 
 0.17156677734181258 
 >>> 

  1. 在循環的時候使用 xrange 而不是 range;使用 xrange 可以節省大量的系統內存,因為 xrange() 在序列中每次調用只產生一個整數元素。而 range() 將直接返回完整的元素列表,用於循環時會有不必要的開銷。在 python3 中 xrange 不再存在,裡面 range 提供一個可以遍歷任意長度的范圍的 iterator。
  2. 使用局部變量,避免"global" 關鍵字。python 訪問局部變量會比全局變量要快得多,因 此可以利用這一特性提升性能。
  3. if done is not None 比語句 if done != None 更快,讀者可以自行驗證;
  4. 在耗時較多的循環中,可以把函數的調用改為內聯的方式;
  5. 使用級聯比較 "x < y < z" 而不是 "x < y and y < z";
  6. while 1 要比 while True 更快(當然後者的可讀性更好);
  7. build in 函數通常較快,add(a,b) 要優於 a+b。
Copyright © Linux教程網 All Rights Reserved