錯誤處理

try...except...finally...

try:
    print('try...')      #  try except finally 簡單套路
    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')

調用堆棧

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

# err.py:
def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    bar('0')

main()

執(zhí)行鲜锚，結果如下：

$ 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行：

............省略.就是上游污染下游都污染蔬捷，都PM爆表，系統把所有污染地區(qū)都展示出來榔袋，你順著往上游去周拐，就能摸到污染源.............

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

  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時出錯播急，至此，找到錯誤源頭售睹。

記錄錯誤 logging

如果不捕獲錯誤旅择，自然可以讓Python解釋器來打印出錯誤堆棧，但程序也被結束了侣姆。既然我們能捕獲錯誤生真，就可以把錯誤堆棧打印出來沉噩，然后分析錯誤原因，同時柱蟀，讓程序繼續(xù)執(zhí)行下去川蒙。

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')

同樣是出錯，但程序打印完錯誤信息后會繼續(xù)執(zhí)行长已，并正常退出：

$ 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的一個實例。因此胞四，錯誤并不是憑空產生的恬汁，而是有意創(chuàng)建并拋出的。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')

執(zhí)行独郎，可以最后跟蹤到我們自己定義的錯誤：

$ 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語句拋出去了星压，這不有病么践剂？

其實這種錯誤處理方式不但沒病，而且相當常見娜膘。捕獲錯誤目的只是記錄一下逊脯，便于后續(xù)追蹤。但是竣贪，由于當前函數不知道應該怎么處理該錯誤军洼，所以巩螃，最恰當的方式是繼續(xù)往上拋，讓頂層調用者去處理匕争。好比一個員工處理不了一個問題時避乏，就把問題拋給他的老板，如果他的老板也處理不了甘桑，就一直往上拋拍皮，最終會拋給CEO去處理。

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

調試

斷言

凡是用print()來輔助查看的地方爹橱，都可以用斷言（assert）來替代：

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

def main():
    foo('0')

assert的意思是，表達式n != 0應該是True女阀，否則宅荤，根據程序運行的邏輯，后面的代碼肯定會出錯浸策。

如果斷言失敗冯键，assert語句本身就會拋出AssertionError：

$ python3 err.py
Traceback (most recent call last):
  ...
AssertionError: n is zero!

logging

把print()替換為logging是第3種方式，和assert比庸汗，logging不會拋出錯誤惫确，而且可以輸出到文件：

import logging

s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

logging.info()就可以輸出一段文本。運行蚯舱，發(fā)現除了ZeroDivisionError改化，沒有任何信息。怎么回事枉昏？

別急陈肛，在import logging之后添加一行配置再試試：

import logging
logging.basicConfig(level=logging.INFO)

看到輸出了：

$ python3 err.py
INFO:root:n = 0
Traceback (most recent call last):
  File "err.py", line 8, in <module>
    print(10 / n)
ZeroDivisionError: division by zero

這就是logging的好處，它允許你指定記錄信息的級別兄裂，有debug句旱，info，warning晰奖，error等幾個級別谈撒，當我們指定level=INFO時，logging.debug就不起作用了匾南。同理啃匿，指定level=WARNING后，debug和info就不起作用了。這樣一來溯乒，你可以放心地輸出不同級別的信息夹厌，也不用刪除，最后統一控制輸出哪個級別的信息橙数。

logging的另一個好處是通過簡單的配置尊流，一條語句可以同時輸出到不同的地方，比如console和文件灯帮。

pdb pdb.set_trace() IDE 暫略

單元測試

“測試驅動開發(fā)”（TDD：Test-Driven Development）
單元測試是用來對一個模塊崖技、一個函數或者一個類來進行正確性檢驗的測試工作。

我們來編寫一個Dict類钟哥，這個類的行為和dict一致迎献，但是可以通過屬性來訪問，用起來就像下面這樣：

>>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d.a
1

為了編寫單元測試腻贰，我們需要引入Python自帶的unittest模塊吁恍，編寫mydict_test.py如下：

import unittest

from mydict import Dict

class TestDict(unittest.TestCase):

    def test_init(self):
        d = Dict(a=1, b='test')
        self.assertEqual(d.a, 1)
        self.assertEqual(d.b, 'test')
        self.assertTrue(isinstance(d, dict))

    def test_key(self):
        d = Dict()
        d['key'] = 'value'
        self.assertEqual(d.key, 'value')

    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)
        self.assertEqual(d['key'], 'value')

    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']

    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty

編寫單元測試時，我們需要編寫一個測試類播演，從unittest.TestCase繼承冀瓦。

以test開頭的方法就是測試方法，不以test開頭的方法不被認為是測試方法写烤，測試的時候不會被執(zhí)行翼闽。

對每一類測試都需要編寫一個test_xxx()方法。由于unittest.TestCase提供了很多內置的條件判斷洲炊，我們只需要調用這些方法就可以斷言輸出是否是我們所期望的感局。最常用的斷言就是
assertEqual()：

self.assertEqual(abs(-1), 1) # 斷言函數返回的結果與1相等

另一種重要的斷言就是期待拋出指定類型的Error，比如通過d['empty']訪問不存在的key時暂衡，斷言會拋出KeyError：

with self.assertRaises(KeyError):
    value = d['empty']

而通過d.empty訪問不存在的key時询微，我們期待拋出AttributeError：

with self.assertRaises(AttributeError):
    value = d.empty

運行單元測試

一旦編寫好單元測試，我們就可以運行單元測試狂巢。最簡單的運行方式是在mydict_test.py的最后加上兩行代碼：

if __name__ == '__main__':
    unittest.main()

這樣就可以把mydict_test.py當做正常的python腳本運行：

$ python3 mydict_test.py

另一種方法是在命令行通過參數-m unittest直接運行單元測試：

$ python3 -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s

OK

這是推薦的做法撑毛，因為這樣可以一次批量運行很多單元測試，并且唧领，有很多工具可以自動來運行這些單元測試藻雌。

setUp與tearDown

可以在單元測試中編寫兩個特殊的setUp()和tearDown()方法。這兩個方法會分別在每調用一個測試方法的前后分別被執(zhí)行疹吃。

setUp()和tearDown()方法有什么用呢？設想你的測試需要啟動一個數據庫西雀，這時萨驶，就可以在setUp()方法中連接數據庫，在tearDown()方法中關閉數據庫艇肴，這樣腔呜，不必在每個測試方法中重復相同的代碼：

class TestDict(unittest.TestCase):

    def setUp(self):
        print('setUp...')

    def tearDown(self):
        print('tearDown...')

可以再次運行測試看看每個測試方法調用前后是否會打印出setUp...和tearDown...叁温。

文檔測試

如果你經常閱讀Python的官方文檔，可以看到很多文檔都有示例代碼核畴。比如re模塊就帶了很多示例代碼：

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

可以把這些示例代碼在Python的交互式環(huán)境下輸入并執(zhí)行膝但，結果與文檔中的示例代碼顯示的一致。

這些代碼與其他說明可以寫在注釋中谤草，然后跟束，由一些工具來自動生成文檔。既然這些代碼本身就可以粘貼出來直接運行丑孩，那么冀宴，可不可以自動執(zhí)行寫在注釋中的這些代碼呢？

答案是肯定的温学。

當我們編寫注釋時略贮，如果寫上這樣的注釋：

def abs(n):
    '''
    Function to get absolute value of number.

    Example:

    >>> abs(1)
    1
    >>> abs(-1)
    1
    >>> abs(0)
    0
    '''
    return n if n >= 0 else (-n)

無疑更明確地告訴函數的調用者該函數的期望輸入和輸出。

并且仗岖，Python內置的“文檔測試”（doctest）模塊可以直接提取注釋中的代碼并執(zhí)行測試逃延。