?

python基礎——錯誤處理

　　

　　在程序運行的過程中，如果發生了錯誤，可以事先約定返回一個錯誤代碼，這樣，就可以知道是否有錯，以及出錯的原因。在操作系統提供的調用中，返回錯誤碼非常常見。比如打開文件的函數open()，成功時返回文件描述符（就是一個整數），出錯時返回-1。

　　用錯誤碼來表示是否出錯十分不便，因為函數本身應該返回的正常結果和錯誤碼混在一起，造成調用者必須用大量的代碼來判斷是否出錯：

def foo():r = some_function()if r==(-1):return (-1)# do somethingreturn rdef bar():r = foo()if r==(-1):print('Error')else:pass

　　一旦出錯，還要一級一級上報，直到某個函數可以處理該錯誤（比如，給用戶輸出一個錯誤信息）。

　　所以高級語言通常都內置了一套try...except...finally...的錯誤處理機制，Python也不例外。

try

　　讓我們用一個例子來看看try的機制：

try:print('try...')r = 10 / 0print('result:', r) except ZeroDivisionError as e:print('except:', e) finally:print('finally...') print('END')

　　當我們認為某些代碼可能會出錯時，就可以用try來運行這段代碼，如果執行出錯，則后續代碼不會繼續執行，而是直接跳轉至錯誤處理代碼，即except語句塊，執行完except后，如果有finally語句塊，則執行finally語句塊，至此，執行完畢。

　　上面的代碼在計算10 / 0時會產生一個除法運算錯誤：

try... except: division by zero finally... END

　　從輸出可以看到，當錯誤發生時，后續語句print('result:', r)不會被執行，except由于捕獲到ZeroDivisionError，因此被執行。最后，finally語句被執行。然后，程序繼續按照流程往下走。

　　如果把除數0改成2，則執行結果如下：

try... result: 5 finally... END

　　由于沒有錯誤發生，所以except語句塊不會被執行，但是finally如果有，則一定會被執行（可以沒有finally語句）。

　　你還可以猜測，錯誤應該有很多種類，如果發生了不同類型的錯誤，應該由不同的except語句塊處理。沒錯，可以有多個except來捕獲不同類型的錯誤：

try:print('try...')r = 10 / int('a')print('result:', r) except ValueError as e:print('ValueError:', e) except ZeroDivisionError as e:print('ZeroDivisionError:', e) finally:print('finally...') print('END')

　　int()函數可能會拋出ValueError，所以我們用一個except捕獲ValueError，用另一個except捕獲ZeroDivisionError。

　　此外，如果沒有錯誤發生，可以在except語句塊后面加一個else，當沒有錯誤發生時，會自動執行else語句：

try:print('try...')r = 10 / int('2')print('result:', r) except ValueError as e:print('ValueError:', e) except ZeroDivisionError as e:print('ZeroDivisionError:', e) else:print('no error!') finally:print('finally...') print('END')

　　Python的錯誤其實也是class，所有的錯誤類型都繼承自BaseException，所以在使用except時需要注意的是，它不但捕獲該類型的錯誤，還把其子類也“一網打盡”。比如：

try:foo() except ValueError as e:print('ValueError') except UnicodeError as e:print('UnicodeError')

　　第二個except永遠也捕獲不到UnicodeError，因為UnicodeError是ValueError的子類，如果有，也被第一個except給捕獲了。

　　Python所有的錯誤都是從BaseException類派生的，常見的錯誤類型和繼承關系看這里：

　　https://docs.python.org/3/library/exceptions.html#exception-hierarchy

?

　　使用try...except捕獲錯誤還有一個巨大的好處，就是可以跨越多層調用，比如函數main()調用bar()，bar()調用foo()，結果foo()出錯了，這時，只要main()捕獲到了，就可以處理：

def foo(s):return 10 / int(s)def bar(s):return foo(s) * 2def main():try:bar('0')except Exception as e:print('Error:', e)finally:print('finally...')

　　也就是說，不需要在每個可能出錯的地方去捕獲錯誤，只要在合適的層次去捕獲錯誤就可以了。這樣一來，就大大減少了寫try...except...finally的麻煩。

?

調用堆棧

　　如果錯誤沒有被捕獲，它就會一直往上拋，最后被Python解釋器捕獲，打印一個錯誤信息，然后程序退出。來看看error.py：

def foo(s):return 10 / int(s)def bar(s):return foo(s) * 2def main():bar('0')main()

　　執行，結果如下：

　　

　　

　　出錯并不可怕，可怕的是不知道哪里出錯了。解讀錯誤信息是定位錯誤的關鍵。我們從上往下可以看到整個錯誤的調用函數鏈：

　　錯誤信息第1行：

Traceback (most recent call last):

　　告訴我們這是錯誤的跟蹤信息。

　　第2~3行：

File "error.py", line 16, in <module>main()

　　調用main()出錯了，在代碼文件error.py的第16行代碼，但原因是第14行：

File "error.py", line 14, in mainbar('0')

　　調用bar('0')出錯了，在代碼文件error.py的第14行代碼，但原因是第11行：

File "error.py", line 11, in barreturn foo(s) * 2

　　原因是return foo(s) * 2這個語句出錯了，但這還不是最終原因，繼續往下看：

File "error.py", line 8, in fooreturn 10 / int(s)

　　原因是return 10 / int(s)這個語句出錯了，這是錯誤產生的源頭，因為下面打印了：　

ZeroDivisionError: integer division or modulo by zero

　　根據錯誤類型ZeroDivisionError，我們判斷，int(s)本身并沒有出錯，但是int(s)返回0，在計算10 / 0時出錯，至此，找到錯誤源頭。

?

記錄錯誤

　　如果不捕獲錯誤，自然可以讓Python解釋器來打印出錯誤堆棧，但程序也被結束了。既然我們能捕獲錯誤，就可以把錯誤堆棧打印出來，然后分析錯誤原因，同時，讓程序繼續執行下去。

　　Python內置的logging模塊可以非常容易地記錄錯誤信息：

import loggingdef foo(s):return 10 / int(s)def bar(s):return foo(s) * 2def main():try:bar('0')except Exception as e:logging.exception(e)main() print('END')

　　同樣是出錯，但程序打印完錯誤信息后會繼續執行，并正常退出：

　　　

?

　　通過配置，logging還可以把錯誤記錄到日志文件里，方便事后排查。

?

拋出錯誤

　　因為錯誤是class，捕獲一個錯誤就是捕獲到該class的一個實例。因此，錯誤并不是憑空產生的，而是有意創建并拋出的。Python的內置函數會拋出很多類型的錯誤，我們自己編寫的函數也可以拋出錯誤。

　　如果要拋出錯誤，首先根據需要，可以定義一個錯誤的class，選擇好繼承關系，然后，用raise語句拋出一個錯誤的實例：

class FooError(ValueError):passdef foo(s):n = int(s)if n==0:raise FooError('invalid value: %s' % s)return 10 / nfoo('0')

　　執行，可以最后跟蹤到我們自己定義的錯誤：

　 ?　　

　　

　　只有在必要的時候才定義我們自己的錯誤類型。如果可以選擇Python已有的內置的錯誤類型（比如ValueError，TypeError），盡量使用Python內置的錯誤類型。

　　最后，我們來看另一種錯誤處理的方式：

def foo(s):n = int(s)if n==0:raise ValueError('invalid value: %s' % s)return 10 / ndef bar():try:foo('0')except ValueError as e:print('ValueError!')raisebar()

　　

　　在bar()函數中，我們明明已經捕獲了錯誤，但是，打印一個ValueError!后，又把錯誤通過raise語句拋出去了，這不有病么？

　　其實這種錯誤處理方式不但沒病，而且相當常見。捕獲錯誤目的只是記錄一下，便于后續追蹤。但是，由于當前函數不知道應該怎么處理該錯誤，所以，最恰當的方式是繼續往上拋，讓頂層調用者去處理。好比一個員工處理不了一個問題時，就把問題拋給他的老板，如果他的老板也處理不了，就一直往上拋，最終會拋給CEO去處理。

　　raise語句如果不帶參數，就會把當前錯誤原樣拋出。此外，在except中raise一個Error，還可以把一種類型的錯誤轉化成另一種類型：

try:10 / 0 except ZeroDivisionError:raise ValueError('input error!')

　　只要是合理的轉換邏輯就可以，但是，決不應該把一個IOError轉換成毫不相干的ValueError。

?

小結

　　Python內置的try...except...finally用來處理錯誤十分方便。出錯時，會分析錯誤信息并定位錯誤發生的代碼位置才是最關鍵的。

　　程序也可以主動拋出錯誤，讓調用者來處理相應的錯誤。但是，應該在文檔中寫清楚可能會拋出哪些錯誤，以及錯誤產生的原因。

?

參考源碼：

　 ?do_try.py:

1 #python 錯誤處理 示例 2 #錯誤處理機制：try...except...finally... 3 #2016-8-31 09:16:08 4 #MengmengCoding 5 # -*- coding: utf-8 -*- 6 7 8 try: 9 print('try...') 10 r=10/0 #當執行出錯，try塊中后續代碼不執行 11 print('result:',r) 12 except ZeroDivisionError as e: #捕獲錯誤類型 13 print('except:',e) #捕獲后如何處理 14 15 finally: #無論捕獲到錯誤與否，finally始終執行 16 print('finally...') 17 18 print('END') 19 20 #輸出： 21 ''' 22 try... 23 except: division by zero 24 finally... 25 END 26 ''' View Code

　　

　　error.py:

1 #python 錯誤處理 示例 2 #如果錯誤沒有被捕獲，它就會一直往上拋，最后被Python解釋器捕獲，打印一個錯誤信息，然后程序退出 3 #2016-8-31 09:32:11 4 #MengmengCoding 5 # -*- coding: utf-8 -*- 6 7 def foo(s): 8 return 10/int(s) 9 10 def bar(s): 11 return foo(s)*2 12 13 def main(): 14 bar('0') 15 16 main() 17 #執行后結果如下： 18 ''' 19 Traceback (most recent call last): 20 File "error.py", line 16, in <module> 21 main() 22 File "error.py", line 14, in main 23 bar('0') 24 File "error.py", line 11, in bar 25 return foo(s)*2 26 File "error.py", line 8, in foo 27 return 10/int(s) 28 ZeroDivisionError: division by zero 29 ''' 30 #從上往下可以看到整個錯誤的調用函數鏈 31 #并最終找到錯誤源頭 View Code

?

　　error.logging.py:

1 #python 錯誤處理 示例 2 #記錄錯誤：使用logging模塊記錄錯誤信息 3 #2016-8-31 09:37:55 4 #MengmengCoding 5 # -*- coding: utf-8 -*- 6 7 import logging 8 9 def foo(s): 10 return 10 /int(s) 11 12 def bar(s): 13 return foo(s)*2 14 15 def main(): 16 try: 17 bar('0') 18 except Exception as e: 19 logging.exception(e) 20 21 main() 22 print('END') 23 24 #執行后結果如下： 25 ''' 26 ERROR:root:division by zero 27 Traceback (most recent call last): 28 File "error_logging.py", line 17, in main 29 bar('0') 30 File "error_logging.py", line 13, in bar 31 return foo(s)*2 32 File "error_logging.py", line 10, in foo 33 return 10 /int(s) 34 ZeroDivisionError: division by zero 35 END 36 37 ''' View Code

?

　　error_raise.py:

1 #python 錯誤處理 示例 2 #拋出錯誤：自己定義一個錯誤的class，選擇好繼承關系，然后，用raise語句拋出一個錯誤的實例 3 #2016-8-31 09:51:24 4 #MengmengCoding 5 # -*- coding: utf-8 -*- 6 7 class FooError(ValueError): 8 pass 9 10 def foo(s): 11 n=int(s) 12 if n==0: 13 raise FooError('invalid value: %s' %s) 14 15 return 10 /n 16 17 foo('0') 18 19 #執行結果如下： 20 ''' 21 Traceback (most recent call last): 22 File "error_raise.py", line 17, in <module> 23 foo('0') 24 File "error_raise.py", line 13, in foo 25 raise FooError('invalid value: %s' %s) 26 __main__.FooError: invalid value: 0 27 ''' View Code

?

　　error_reraise.py:

1 #python 錯誤處理 示例 2 #在except中raise一個Error，可以把一種類型的錯誤轉化成另一種類型 3 #2016-8-31 10:03:16 4 #MengmengCoding 5 # -*- coding: utf-8 -*- 6 7 def foo(s): 8 n=int(s) 9 if n==0: 10 print('here is in foo!') 11 raise ValueError('invalid value: %s' %s) 12 return 10/n 13 14 def bar(): 15 try: 16 foo('0') 17 except ValueError as e: 18 print('ValueError!') #捕獲錯誤，打印一個ValueError! 19 print('here is in bar!') 20 raise #把錯誤通過raise語句往上拋，給上層調用者去處理 21 22 bar() View Code

?

轉載于:https://www.cnblogs.com/codingmengmeng/p/5824995.html

總結

以上是生活随笔為你收集整理的python基础——错误处理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。