高級語言通常都內(nèi)置了一套try...except...finally...的錯誤處理機(jī)制，Python也不例外。

1. 錯誤處理

try

讓我們用一個例子來看看try的機(jī)制：

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

當(dāng)我們認(rèn)為某些代碼可能會出錯時粒没，就可以用try來運(yùn)行這段代碼，如果執(zhí)行出錯簇爆，則后續(xù)代碼不會繼續(xù)執(zhí)行癞松，而是直接跳轉(zhuǎn)至錯誤處理代碼，即except語句塊入蛆，執(zhí)行完except后响蓉，如果有finally語句塊，則執(zhí)行finally語句塊哨毁，至此厕妖，執(zhí)行完畢。

上面的代碼在計算10 / 0時會產(chǎn)生一個除法運(yùn)算錯誤：

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

從輸出可以看到挑庶，當(dāng)錯誤發(fā)生時，后續(xù)語句print('result:', r)不會被執(zhí)行软能，except由于捕獲到ZeroDivisionError迎捺，因此被執(zhí)行。最后查排，finally語句被執(zhí)行凳枝。然后，程序繼續(xù)按照流程往下走跋核。

如果把除數(shù)0改成2岖瑰，則執(zhí)行結(jié)果如下：

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

由于沒有錯誤發(fā)生，所以except語句塊不會被執(zhí)行砂代，但是finally如果有蹋订，則一定會被執(zhí)行（可以沒有finally語句）。

你還可以猜測刻伊，錯誤應(yīng)該有很多種類露戒，如果發(fā)生了不同類型的錯誤椒功，應(yīng)該由不同的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()函數(shù)可能會拋出ValueError动漾，所以我們用一個except捕獲ValueError，用另一個except捕獲ZeroDivisionError荠锭。

此外旱眯，如果沒有錯誤發(fā)生，可以在except語句塊后面加一個else证九，當(dāng)沒有錯誤發(fā)生時删豺，會自動執(zhí)行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的錯誤其實(shí)也是class，所有的錯誤類型都繼承自BaseException甫贯，所以在使用except時需要注意的是吼鳞，它不但捕獲該類型的錯誤，還把其子類也“一網(wǎng)打盡”叫搁。比如：

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

第二個except永遠(yuǎn)也捕獲不到UnicodeError赔桌，因?yàn)?code>UnicodeError是ValueError的子類，如果有渴逻，也被第一個except
給捕獲了疾党。
Python所有的錯誤都是從BaseException類派生的，常見的錯誤類型和繼承關(guān)系看這里：
鏈接
使用try...except捕獲錯誤還有一個巨大的好處惨奕，就是可以跨越多層調(diào)用雪位，比如函數(shù)main()調(diào)用foo()，foo()調(diào)用bar()梨撞，結(jié)果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的麻煩。

調(diào)用堆棧

如果錯誤沒有被捕獲查坪，它就會一直往上拋寸宏，最后被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í)行，結(jié)果如下：

$ 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

出錯并不可怕望忆，可怕的是不知道哪里出錯了覆醇。解讀錯誤信息是定位錯誤的關(guān)鍵朵纷。我們從上往下可以看到整個錯誤的調(diào)用函數(shù)鏈：
錯誤信息第1行：

Traceback (most recent call last):

告訴我們這是錯誤的跟蹤信息。
第2~3行：

  File "err.py", line 11, in <module>
    main()

調(diào)用main()出錯了永脓，在代碼文件err.py的第11行代碼袍辞，但原因是第9行：

  File "err.py", line 9, in main
    bar('0')

調(diào)用bar('0')出錯了，在代碼文件err.py的第9行代碼常摧，但原因是第6行：

  File "err.py", line 6, in bar
    return foo(s) * 2

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

  File "err.py", line 3, in foo
    return 10 / int(s)

原因是return 10 / int(s)這個語句出錯了落午，這是錯誤產(chǎn)生的源頭谎懦，因?yàn)橄旅娲蛴×耍?/p>

ZeroDivisionError: integer division or modulo by zero

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

記錄錯誤

如果不捕獲錯誤梳侨，自然可以讓Python解釋器來打印出錯誤堆棧蛉威，但程序也被結(jié)束了。既然我們能捕獲錯誤走哺，就可以把錯誤堆棧打印出來蚯嫌，然后分析錯誤原因，同時丙躏，讓程序繼續(xù)執(zhí)行下去择示。

Python內(nèi)置的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還可以把錯誤記錄到日志文件里，方便事后排查敢朱。

拋出錯誤

因?yàn)殄e誤是class，捕獲一個錯誤就是捕獲到該class的一個實(shí)例摩瞎。因此拴签，錯誤并不是憑空產(chǎn)生的，而是有意創(chuàng)建并拋出的旗们。Python的內(nèi)置函數(shù)會拋出很多類型的錯誤蚓哩，我們自己編寫的函數(shù)也可以拋出錯誤。

如果要拋出錯誤上渴，首先根據(jù)需要岸梨，可以定義一個錯誤的class喜颁，選擇好繼承關(guān)系，然后曹阔，用raise語句拋出一個錯誤的實(shí)例：

# 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已有的內(nèi)置的錯誤類型（比如ValueError赃份，TypeError）寂拆，盡量使用Python內(nèi)置的錯誤類型。
最后抓韩，我們來看另一種錯誤處理的方式：

# 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()函數(shù)中纠永，我們明明已經(jīng)捕獲了錯誤，但是谒拴，打印一個ValueError!后尝江，又把錯誤通過raise語句拋出去了，這不有病么英上？

其實(shí)這種錯誤處理方式不但沒病炭序，而且相當(dāng)常見。捕獲錯誤目的只是記錄一下善延，便于后續(xù)追蹤少态。但是，由于當(dāng)前函數(shù)不知道應(yīng)該怎么處理該錯誤易遣，所以彼妻，最恰當(dāng)?shù)姆绞绞抢^續(xù)往上拋，讓頂層調(diào)用者去處理豆茫。好比一個員工處理不了一個問題時侨歉，就把問題拋給他的老板，如果他的老板也處理不了揩魂，就一直往上拋幽邓，最終會拋給CEO去處理。

raise語句如果不帶參數(shù)火脉，就會把當(dāng)前錯誤原樣拋出牵舵。此外，在except中raise一個`Error倦挂，還可以把一種類型的錯誤轉(zhuǎn)化成另一種類型：

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

只要是合理的轉(zhuǎn)換邏輯就可以畸颅，但是，決不應(yīng)該把一個IOError轉(zhuǎn)換成毫不相干的ValueError方援。

小結(jié)

Python內(nèi)置的try...except...finally用來處理錯誤十分方便没炒。出錯時，會分析錯誤信息并定位錯誤發(fā)生的代碼位置才是最關(guān)鍵的犯戏。

程序也可以主動拋出錯誤送火，讓調(diào)用者來處理相應(yīng)的錯誤拳话。但是，應(yīng)該在文檔中寫清楚可能會拋出哪些錯誤种吸，以及錯誤產(chǎn)生的原因弃衍。

2.調(diào)試

斷言

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

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

def main():
    foo('0')

assert的意思是骨稿，表達(dá)式n != 0應(yīng)該是True笨鸡，否則，根據(jù)程序運(yùn)行的邏輯坦冠，后面的代碼肯定會出錯形耗。
如果斷言失敗一睁，assert語句本身就會拋出AssertionError：

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

程序中如果到處充斥著assert掩浙，和print()相比也好不到哪去走敌。不過唯灵，啟動Python解釋器時可以用-O參數(shù)來關(guān)閉assert：

$ python3 -O err.py
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

關(guān)閉后摘仅，你可以把所有的assert語句當(dāng)成pass來看猾蒂。

logging

把print()替換為logging是第3種方式炕倘，和assert比斋陪，logging不會拋出錯誤侠草，而且可以輸出到文件：

import logging

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

logging.info()就可以輸出一段文本辱挥。運(yùn)行，發(fā)現(xiàn)除了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等幾個級別著隆，當(dāng)我們指定level=INFO時扰楼，logging.debug就不起作用了。同理美浦，指定level=WARNING后弦赖，debug和info就不起作用了。這樣一來抵代，你可以放心地輸出不同級別的信息腾节，也不用刪除忘嫉，最后統(tǒng)一控制輸出哪個級別的信息荤牍。

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

pdb

第4種方式是啟動Python的調(diào)試器pdb劈榨，讓程序以單步方式運(yùn)行，可以隨時查看運(yùn)行狀態(tài)晦嵌。我們先準(zhǔn)備好程序：

# err.pys = '0'n = int(s)print(10 / n)

然后啟動：

$ python3 -m pdb err.py> /Users/michael/Github/learn-python3/samples/debug/err.py(2)<module>()-> s = '0'

以參數(shù)-m pdb
啟動后同辣，pdb定位到下一步要執(zhí)行的代碼-> s = '0'。輸入命令l來查看代碼：

(Pdb) l 1 # err.py 2 -> s = '0' 3 n = int(s) 4 print(10 / n)

輸入命令n可以單步執(zhí)行代碼：

(Pdb) n> /Users/michael/Github/learn-python3/samples/debug/err.py(3)<module>()-> n = int(s)(Pdb) n> /Users/michael/Github/learn-python3/samples/debug/err.py(4)<module>()-> print(10 / n)

任何時候都可以輸入命令p 變量名
來查看變量：

(Pdb) p s'0'
(Pdb) p n0

輸入命令q結(jié)束調(diào)試惭载，退出程序：
(Pdb) q
這種通過pdb在命令行調(diào)試的方法理論上是萬能的旱函，但實(shí)在是太麻煩了，如果有一千行代碼描滔，要運(yùn)行到第999行得敲多少命令啊棒妨。還好，我們還有另一種調(diào)試方法含长。

pdb.set_trace()

這個方法也是用pdb券腔，但是不需要單步執(zhí)行，我們只需要import pdb拘泞，然后纷纫，在可能出錯的地方放一個pdb.set_trace()，就可以設(shè)置一個斷點(diǎn)：

# err.py
import pdb
s = '0'
n = int(s)
pdb.set_trace() # 運(yùn)行到這里會自動暫停
print(10 / n)

運(yùn)行代碼陪腌，程序會自動在pdb.set_trace()暫停并進(jìn)入pdb調(diào)試環(huán)境辱魁，可以用命令p查看變量，或者用命令c繼續(xù)運(yùn)行：

$ python3 err.py 
> /Users/michael/Github/learn-python3/samples/debug/err.py(7)<module>()
-> print(10 / n)
(Pdb) p n
0
(Pdb) c
Traceback (most recent call last):
  File "err.py", line 7, in <module>
    print(10 / n)
ZeroDivisionError: division by zero

這個方式比直接啟動pdb單步調(diào)試效率要高很多偷厦，但也高不到哪去商叹。

小結(jié)

寫程序最痛苦的事情莫過于調(diào)試，程序往往會以你意想不到的流程來運(yùn)行只泼，你期待執(zhí)行的語句其實(shí)根本沒有執(zhí)行剖笙，這時候，就需要調(diào)試了请唱。
雖然用IDE調(diào)試起來比較方便弥咪，但是最后你會發(fā)現(xiàn)，logging才是終極武器十绑。

3.單元測試

單元測試

閱讀: 128979
如果你聽說過“測試驅(qū)動開發(fā)”（TDD：Test-Driven Development）聚至，單元測試就不陌生。

單元測試是用來對一個模塊本橙、一個函數(shù)或者一個類來進(jìn)行正確性檢驗(yàn)的測試工作扳躬。

比如對函數(shù)abs()，我們可以編寫出以下幾個測試用例：
輸入正數(shù)，比如1贷币、1.2击胜、0.99，期待返回值與輸入相同役纹；
輸入負(fù)數(shù)偶摔，比如-1、-1.2促脉、-0.99辰斋，期待返回值與輸入相反；
輸入0瘸味，期待返回0宫仗；
輸入非數(shù)值類型，比如None旁仿、[]锰什、{}，期待拋出TypeError丁逝。
把上面的測試用例放到一個測試模塊里汁胆，就是一個完整的單元測試。
單元測試通過后有什么意義呢霜幼？如果我們對abs()函數(shù)代碼做了修改嫩码，只需要再跑一遍單元測試，如果通過罪既，說明我們的修改不會對abs()函數(shù)原有的行為造成影響铸题，如果測試不通過，說明我們的修改與原有行為不一致琢感，要么修改代碼丢间，要么修改測試。

這種以測試為驅(qū)動的開發(fā)模式最大的好處就是確保一個程序模塊的行為符合我們設(shè)計的測試用例驹针。在將來修改的時候烘挫，可以極大程度地保證該模塊行為仍然是正確的。

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

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

mydict.py代碼如下：

class Dict(dict):

    def __init__(self, **kw):
        super().__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

為了編寫單元測試苛蒲，我們需要引入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開頭的方法不被認(rèn)為是測試方法，測試的時候不會被執(zhí)行嚎货。

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

self.assertEqual(abs(-1), 1) # 斷言函數(shù)返回的結(jié)果與1相等
另一種重要的斷言就是期待拋出指定類型的Error，比如通過d['empty']訪問不存在的key時克懊，斷言會拋出KeyError：

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

而通過d.empty訪問不存在的key時忱辅，我們期待拋出

AttributeError：

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

運(yùn)行單元測試

一旦編寫好單元測試，我們就可以運(yùn)行單元測試谭溉。最簡單的運(yùn)行方式是在mydict_test.py
的最后加上兩行代碼：

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

這樣就可以把mydict_test.py當(dāng)做正常的python腳本運(yùn)行：

$ python3 mydict_test.py

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

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

OK

這是推薦的做法墙懂，因?yàn)檫@樣可以一次批量運(yùn)行很多單元測試，并且扮念，有很多工具可以自動來運(yùn)行這些單元測試损搬。

setUp與tearDown

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

setUp()和tearDown()方法有什么用呢巧勤？設(shè)想你的測試需要啟動一個數(shù)據(jù)庫，這時弄匕，就可以在setUp()方法中連接數(shù)據(jù)庫颅悉，在tearDown()方法中關(guān)閉數(shù)據(jù)庫，這樣迁匠，不必在每個測試方法中重復(fù)相同的代碼：

class TestDict(unittest.TestCase):

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

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

可以再次運(yùn)行測試看看每個測試方法調(diào)用前后是否會打印出setUp...和tearDown...剩瓶。

小結(jié)

單元測試可以有效地測試某個程序模塊的行為，是未來重構(gòu)代碼的信心保證城丧。

單元測試的測試用例要覆蓋常用的輸入組合延曙、邊界條件和異常。

單元測試代碼要非常簡單亡哄，如果測試代碼太復(fù)雜枝缔，那么測試代碼本身就可能有bug。

單元測試通過了并不意味著程序就沒有bug了蚊惯，但是不通過程序肯定有bug魂仍。

4. 文檔測試

如果你經(jīng)常閱讀Python的官方文檔，可以看到很多文檔都有示例代碼拣挪。比如re模塊就帶了很多示例代碼：

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

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

這些代碼與其他說明可以寫在注釋中菠劝，然后赊舶，由一些工具來自動生成文檔。既然這些代碼本身就可以粘貼出來直接運(yùn)行，那么笼平，可不可以自動執(zhí)行寫在注釋中的這些代碼呢园骆？
答案是肯定的。
當(dāng)我們編寫注釋時寓调，如果寫上這樣的注釋：

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)

無疑更明確地告訴函數(shù)的調(diào)用者該函數(shù)的期望輸入和輸出锌唾。

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

doctest嚴(yán)格按照Python交互式命令行的輸入和輸出來判斷測試結(jié)果是否正確晌涕。只有測試異常的時候，可以用...表示中間一大段煩人的輸出痛悯。
讓我們用doctest來測試上次編寫的Dict類：

# mydict2.py
class Dict(dict):
    '''
    Simple dict but also support access as x.y style.

    >>> d1 = Dict()
    >>> d1['x'] = 100
    >>> d1.x
    100
    >>> d1.y = 200
    >>> d1['y']
    200
    >>> d2 = Dict(a=1, b=2, c='3')
    >>> d2.c
    '3'
    >>> d2['empty']
    Traceback (most recent call last):
        ...
    KeyError: 'empty'
    >>> d2.empty
    Traceback (most recent call last):
        ...
    AttributeError: 'Dict' object has no attribute 'empty'
    '''
    def __init__(self, **kw):
        super(Dict, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

if __name__=='__main__':
    import doctest
    doctest.testmod()

運(yùn)行python3 mydict2.py：

$ python3 mydict2.py

什么輸出也沒有余黎。這說明我們編寫的doctest運(yùn)行都是正確的。如果程序有問題载萌，比如把__getattr__()方法注釋掉惧财，再運(yùn)行就會報錯：

$ python3 mydict2.py
**********************************************************************
File "/Users/michael/Github/learn-python3/samples/debug/mydict2.py", line 10, in __main__.Dict
Failed example:
    d1.x
Exception raised:
    Traceback (most recent call last):
      ...
    AttributeError: 'Dict' object has no attribute 'x'
**********************************************************************
File "/Users/michael/Github/learn-python3/samples/debug/mydict2.py", line 16, in __main__.Dict
Failed example:
    d2.c
Exception raised:
    Traceback (most recent call last):
      ...
    AttributeError: 'Dict' object has no attribute 'c'
**********************************************************************
1 items had failures:
   2 of   9 in __main__.Dict
***Test Failed*** 2 failures.