Python 錯誤處理
錯誤處理
在程式執行的過程中,如果發生了錯誤,可以事先約定返回一個錯誤程式碼,這樣,就可以知道是否有錯,以及出錯的原因。在作業系統提供的呼叫中,返回錯誤碼非常常見。比如開啟檔案的函式open()
,成功時返回檔案描述符(就是一個整數),出錯時返回-1
。
用錯誤碼來表示是否出錯十分不便,因為函式本身應該返回的正常結果和錯誤碼混在一起,造成呼叫者必須用大量的程式碼來判斷是否出錯:
def foo():
r = some_function()
if r==(-1):
return (-1)
# do something
return r
def bar():
r = foo()
if r==(-1):
print('Error')
else:
pass
一旦出錯,還要一級一級上報,直到某個函式可以處理該錯誤(比如,給使用者輸出一個錯誤資訊)。
所以高階語言通常都內建了一套try...except...finally...
的錯誤處理機制,Python
也不例外。
try
讓我們用一個例子來看看try
的機制:
try:
print('try...')
r = 10 / 0
print('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
類派生的,常見的錯誤型別和繼承關係看這裡:
使用try...except
捕獲錯誤還有一個巨大的好處,就是可以跨越多層呼叫,比如函式main()
呼叫foo()
,foo()
呼叫bar()
,結果bar()
出錯了,這時,只要main()
捕獲到了,就可以處理:
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
print('Error:', e)
finally:
print('finally...')
也就是說,不需要在每個可能出錯的地方去捕獲錯誤,只要在合適的層次去捕獲錯誤就可以了。這樣一來,就大大減少了寫try...except...finally
的麻煩。
呼叫棧
如果錯誤沒有被捕獲,它就會一直往上拋,最後被Python直譯器捕獲,列印一個錯誤資訊,然後程式退出。來看看err.py
:
# err.py:
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
bar('0')
main()
執行,結果如下:
$ python3 err.py
Traceback (most recent call last):
File "err.py", line 11, in <module>
main()
File "err.py", line 9, in main
bar('0')
File "err.py", line 6, in bar
return foo(s) * 2
File "err.py", line 3, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
出錯並不可怕,可怕的是不知道哪裡出錯了。解讀錯誤資訊是定位錯誤的關鍵。我們從上往下可以看到整個錯誤的呼叫函式鏈:
錯誤資訊第1行:
Traceback (most recent call last):
告訴我們這是錯誤的跟蹤資訊。
第2~3行:
File "err.py", line 11, in <module>
main()
呼叫`main()`出錯了,在程式碼檔案`err.py`的第11行程式碼,但原因是第9行:
File "err.py", line 9, in main
bar('0')
呼叫bar('0')
出錯了,在程式碼檔案err.py
的第9行程式碼,但原因是第6行:
File "err.py", line 6, in bar
return foo(s) * 2
原因是return foo(s) * 2
這個語句出錯了,但這還不是最終原因,繼續往下看:
File "err.py", line 3, in foo
return 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
模組可以非常容易地記錄錯誤資訊:
# err_logging.py
import logging
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
logging.exception(e)
main()
print('END')
同樣是出錯,但程式列印完錯誤資訊後會繼續執行,並正常退出:
$ python3 err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
File "err_logging.py", line 13, in main
bar('0')
File "err_logging.py", line 9, in bar
return foo(s) * 2
File "err_logging.py", line 6, in foo
return 10 / int(s)
ZeroDivisionError: division by zero
END
通過配置,logging
還可以把錯誤記錄到日誌檔案裡,方便事後排查。
丟擲錯誤
因為錯誤是class
,捕獲一個錯誤就是捕獲到該class
的一個例項。因此,錯誤並不是憑空產生的,而是有意建立並丟擲的。Python的內建函式會丟擲很多型別的錯誤,我們自己編寫的函式也可以丟擲錯誤。
如果要丟擲錯誤,首先根據需要,可以定義一個錯誤的class,選擇好繼承關係,然後,用raise
語句丟擲一個錯誤的例項:
# err_raise.py
class FooError(ValueError):
pass
def foo(s):
n = int(s)
if n==0:
raise FooError('invalid value: %s' % s)
return 10 / n
foo('0')
執行,可以最後跟蹤到我們自己定義的錯誤:
$ python3 err_raise.py
Traceback (most recent call last):
File "err_throw.py", line 11, in <module>
foo('0')
File "err_throw.py", line 8, in foo
raise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0
只有在必要的時候才定義我們自己的錯誤型別。如果可以選擇Python已有的內建的錯誤型別(比如ValueError
,TypeError
),儘量使用Python
內建的錯誤型別。
最後,我們來看另一種錯誤處理的方式:
# err_reraise.py
def foo(s):
n = int(s)
if n==0:
raise ValueError('invalid value: %s' % s)
return 10 / n
def bar():
try:
foo('0')
except ValueError as e:
print('ValueError!')
raise
bar()
在bar()
函式中,我們明明已經捕獲了錯誤,但是,列印一個ValueError
!後,又把錯誤通過raise
語句丟擲去了,這不有病麼?
其實這種錯誤處理方式不但沒病,而且相當常見。捕獲錯誤目的只是記錄一下,便於後續追蹤。但是,由於當前函式不知道應該怎麼處理該錯誤,所以,最恰當的方式是繼續往上拋,讓頂層呼叫者去處理。好比一個員工處理不了一個問題時,就把問題拋給他的老闆,如果他的老闆也處理不了,就一直往上拋,最終會拋給CEO去處理。
raise
語句如果不帶引數,就會把當前錯誤原樣丟擲。此外,在except
中raise
一個Error
,還可以把一種型別的錯誤轉化成另一種型別:
try:
10 / 0
except ZeroDivisionError:
raise ValueError('input error!')
只要是合理的轉換邏輯就可以,但是,決不應該把一個IOError
轉換成毫不相干的ValueError
。
參考原始碼
do_try.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
try:
print('try...')
r = 10 / 0
print('result:', r)
except ZeroDivisionError as e:
print('except:', e)
finally:
print('finally...')
print('END')
err.py
# err.py
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
bar('0')
main()
err_logging.py
# err_logging.py
import logging
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
logging.exception(e)
main()
print('END')
err_raise.py
# err_raise.py
class FooError(ValueError):
pass
def foo(s):
n = int(s)
if n==0:
raise FooError('invalid value: %s' % s)
return 10 / n
foo('0')
err_reraise.py
# err_reraise.py
def foo(s):
n = int(s)
if n==0:
raise ValueError('invalid value: %s' % s)
return 10 / n
def bar():
try:
foo('0')
except ValueError as e:
print('ValueError!')
raise
bar()