@[toc]
??編寫計算機程序時，通常能夠區(qū)分正常和異常情況。異常事件可能是錯誤,也可能是通常不會發(fā)生的事情。為處理這些異常事件，Python提供功能強大的異常處理機制。

一、異常是什么

??Python使用異常對象來表示異常狀態(tài)，并在遇到錯誤時引發(fā)異常。異常對象未被處理(或捕獲)時，程序?qū)⒔K止并顯示一條錯誤消息(traceback)。

>>> 1/0
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    1/0
ZeroDivisionError: division by zero

??事實上，每個異常都是某個類(這里是ZeroDivisionError)的實例。你能以各種方式引發(fā)和捕獲這些實例，從而逮住錯誤并采取措施，而不是讓程序失敗

二、讓事情沿你指定的軌道出錯

??正如你看到的，出現(xiàn)問題時，將自動引發(fā)異常。先來看看如何自主地引發(fā)異常，還有如何創(chuàng)建異常，然后再學習如何處理這些異常。

1. raise語句

??Python使用raise語句拋出一個指定異常。要引發(fā)異常，可使用raise語句，并將一個類(必須是Exception的子類)或?qū)嵗鳛閰?shù)。將類作為參數(shù)時，將自動創(chuàng)建一個實例。下面的示例使用的是內(nèi)置異常類Exception：

>>> raise Exception
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    raise Exception
Exception

??這里引發(fā)的是通用異常，并沒有指出出現(xiàn)了什么錯誤。

>>> raise Exception('hyperdrive overload')
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    raise Exception('hyperdrive overload')
Exception: hyperdrive overload

??這里添加了錯誤信息hyperdrive overload。
??在很多內(nèi)置的異常類，表描述了最重要的幾個。
<center>一些內(nèi)置的異常類</center>

2. 自定義的異常類

??我們可以像創(chuàng)建其他類一樣，但務必直接或間接地繼承Exception(這意味著從任何內(nèi)置異常類派生都可以)。因此，自定義異常類的代碼類似于下面這樣：

class SomeCustomException(Exception): pass

??因為錯誤就是類，捕獲一個錯誤就是捕獲一個該類的實例，因此錯誤并不是憑空產(chǎn)生的，而是由一些不合理的部分導致的。Python的內(nèi)置函數(shù)會拋出很多類型的錯誤，我們自己編寫的函數(shù)也可以拋出錯誤。如果要拋出錯誤，那么可以根據(jù)需要定義一個錯誤的類，選擇好繼承關(guān)系，然后用raise語句拋出一個錯誤的實例。
??例如：

class MyError(Exception):
    def __init__(self):
        pass
    def __str__(self):
        return 'this is self define error'
def my_error_test():
    try:
        raise MyError()
    except MyError as e:
        print('exception info:',e)
my_error_test()

??執(zhí)行結(jié)果如下：

exception info:this is self define error

??程序正確地執(zhí)行了自定義的異常。

三、捕獲異常

??異常比較有趣的地方是可對其進行處理，通常稱之為捕獲異常。為此，可使用try/except語句。try/except語句用來檢測try語句中的錯誤，從而讓except語句捕獲異常信息并處理。假設(shè)你創(chuàng)建了一個程序，讓用戶輸入兩個數(shù)，再將它們相除，如下所示：

>>> x = int(input('Enter the first number:'))
>>> y = int(input('Enter the second number'))
>>> print(x / y)

??如果第二個數(shù)字為零的話，就會報錯。為了捕獲這種異常并對錯誤進行處理，可像下面這樣重寫程序。

try:
    x = int(input('Enter the first number：'))
    y = int(input('Enter the second number：'))
    print(x / y)
except ZeroDivisionError:
    print("第二個數(shù)字不能為0")

??try的工作原理是，開始一個try語句后，Python就在當前程序的上下文中做標記，當出現(xiàn)異常時就可以回到做標記的地方。首先執(zhí)行try語句，接下來發(fā)生什么依賴于執(zhí)行時是否出現(xiàn)異常。
??如果try后的語句執(zhí)行時發(fā)生異常，程序就跳回try并執(zhí)行except子句。異常處理完畢，控制流就可以通過整個try語句了(除非在處理異常時又引發(fā)新異常)。
??注意：異常從函數(shù)向外傳播到調(diào)用函數(shù)的地方。如果在這里也沒有被捕獲，異常將向程序的最頂層傳播。這意味著你可使用try/except來捕獲他人所編寫函數(shù)引發(fā)的異常。詳見第4小節(jié)。

1. 不用提供參數(shù)

??捕獲異常后，如果要重新引發(fā)它(即繼續(xù)向上傳播)，可調(diào)用raise且不提供任何參數(shù)(也可顯式地提供捕獲到的異常，參見(4))。

>>> raise
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    raise
RuntimeError: No active exception to reraise

??為說明這很有用，來看一個能夠抑制異常ZeroDivisionError的計算器類。如果啟用了這種功能，計算器將打印一條錯誤消息，而不讓異常繼續(xù)傳播。在與用戶交互的會話中使用這個計算器時，抑制異常很有用；但在程序內(nèi)部使用時，引發(fā)異常是更佳的選擇(此時應關(guān)閉抑制功能)。
??下面來看一個類的代碼：

class MuffledCalculator:
    muffled = False
    def calc(self, expr):
        try:
            return eval(expr)   
        except ZeroDivisionError:
            if self.muffled:
                print('Division by zero is illegal')
            else:
                raise
# eval()將字符串str當成有效的表達式來求值并返回計算結(jié)果

??注意：發(fā)生除零行為時，如果啟用了抑制功能，方法calc將(隱式地)返回None。換而言之，如果啟用了抑制功能，就不應依賴返回值。
??下面的示例演示了這個類的用法(包括啟用和關(guān)閉了抑制功能的情形)：

>>> calculator = MuffledCalculator()
>>> calculator.calc('10/2')
5.0
>>> calculator.calc('10/0') #關(guān)閉了抑制功能
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    calculator.calc('10/0')
  File "<pyshell#15>", line 5, in calc
    return eval(expr)
  File "<string>", line 1, in <module>
ZeroDivisionError: division by zero
>>> calculator.muffled = True   #開啟了抑制功能
>>> calculator.calc('10/0')
Division by zero is illegal

??如你所見，關(guān)閉抑制功能時，捕獲了異常ZeroDivisionError，但繼續(xù)向上傳播它。
??如果無法處理異常，在except子句中使用不帶參數(shù)的raise通常是不錯的選擇，但有時你可能想引發(fā)別的異常。在這種情況下，導致進入except子句的異常將被作為異常上下文存儲起來，并出現(xiàn)在最終的錯誤消息中。

>>> try:
    1/0
except ZeroDivisionError:
    raise ValueError
Traceback (most recent call last):
  File "<pyshell#28>", line 2, in <module>
    1/0
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<pyshell#28>", line 4, in <module>
    raise ValueError

??你可使用raise…from…語句來提供自己的異常上下文，也可使用None來禁用上下文。

>>> try:
    1/0
except ZeroDivisionError:
    raise ValueError from None

Traceback (most recent call last):
  File "<pyshell#30>", line 4, in <module>
    raise ValueError from None
ValueError

2. 多個except子句

??如果你運行前一節(jié)的程序，并在提示時輸入一個非數(shù)字值，將引發(fā)另一種異常。

Enter the first number: 10
Enter the second number: 'Hello'
Traceback (most recent call last):
  File "<pyshell#33>", line 3, in <module>
    y = int(input('Enter the second number'))
ValueError: invalid literal for int() with base 10: "'hello'"

??由于該程序中的except子句只捕獲ZeroDivisionError異常，這種異常將成為漏網(wǎng)之魚，導致程序終止。為同時捕獲這種異常，可在try/except語句中再添加一個except子句。

try:
    x = int(input('Enter the first number:'))
    y = int(input('Enter the second number:'))
    print(x / y)
except ZeroDivisionError:
    print("第二個數(shù)字不能為0")
except ValueError:
    print("這不是一個數(shù)字")

??try語句按照如下方式工作：
??首先，執(zhí)行try子句(在關(guān)鍵字try和關(guān)鍵字except之間的語句)。
??如果沒有發(fā)生異常，忽略except子句，try子句執(zhí)行后結(jié)束。如果在執(zhí)行try子句的過程中發(fā)生異常，try子句余下的部分會被忽略。如果異常的類型和except之后的名稱相符，對應的except子句就會被執(zhí)行。最后執(zhí)行try語句之后的代碼。如果沒有一個異常與任何except匹配，這個異常就會傳遞到上層的try中。一個try語句可能包含多個except子句，分別處理不同的異常，但最多只有一個分支會被執(zhí)行。
??處理程序?qū)⒅会槍?code>try子句中的異常進行處理，而不會處理其他異常語句中的異常。
??注意到異常處理并不會導致代碼混亂，而添加大量的if語句來檢查各種可能的錯誤狀態(tài)將導致代碼的可讀性極差。

3. 一箭雙雕

??如果要使用一個except子句捕獲多種異常，可在一個元組中指定這些異常，如下所示：

try:
    x = int(input('Enter the first number:'))
    y = int(input('Enter the second number:'))
    print(x / y)
except (ZeroDivisionError, TypeError, ValueError, NameError):
    print("你的數(shù)字是偽造的")

??在上述代碼中，如果用戶輸入字符串、其他非數(shù)字值或輸入的第二個數(shù)為零，都將打印同樣的錯誤消息。當然，僅僅打印錯誤消息幫助不大。另一種解決方案是不斷地要求用戶輸入數(shù)字，直到能夠執(zhí)行除法運算為止，(6)將介紹如何這樣做。
??這樣做有什么好處呢？假如我們希望多個except子句輸出同樣的信息，就沒有必要在幾個except子句中重復輸入語句，放到一個異常塊中即可。
??在except子句中，異常兩邊的圓括號很重要。一種常見的錯誤是省略這些括號，這可能導致你不想要的結(jié)果，其中的原因請參閱下一節(jié)。

4. 捕獲對象

??要在except子句中訪問異常對象本身，可使用兩個而不是一個參數(shù)。(請注意，即便是在你捕獲多個異常時，也只向except提供了一個參數(shù)—一個元組。)需要讓程序繼續(xù)運行并記錄錯誤(可能只是向用戶顯示)時，這很有用。如果希望在except子句中訪問異常對象本身，也就是看到一個異常對象真正的異常信息，而不是輸出自己定義的異常信息，可以使用as e的形式，我們稱之為捕捉對象。
??下面的示例程序打印發(fā)生的異常并繼續(xù)運行：

try:
    x = int(input('Enter the first number:'))
    y = int(input('Enter the second number:'))
    print(x / y)
except (ZeroDivisionError, ValueError) as e:
    print(e)
#division by zero
#invalid literal for int() with base 10: "'s'"

??在這個小程序中，except子句也捕獲兩種異常，但由于你同時顯式地捕獲了對象本身，因此可將其打印出來，讓用戶知道發(fā)生了什么情況。(6)將介紹這種技術(shù)的另一種更有用的用途。

5. 一網(wǎng)打盡

??即使程序處理了好幾種異常，還是可能有一些漏網(wǎng)之魚。例如，對于前面執(zhí)行除法運算的程序，如果用戶在提示時不輸入任何內(nèi)容就按回車鍵，將出現(xiàn)一條錯誤消息，還有一些相關(guān)問題出在什么地方的信息(棧跟蹤)，如下所示：

Traceback (most recent call last):
…
invalid literal for int() with base 10: ''

??這種異常未被try/except語句捕獲，因為你沒有預測到這種問題，也沒有采取相應的措施。在這些情況下，與其使用并非要捕獲這些異常的try/except語句將它們隱藏起來，還不如讓程序馬上崩潰，因為這樣你就知道什么地方除了問題。
??然而，如果你就是要使用一段代碼捕獲所有的異常，只需在except語句中不指定任何異常類即可。

try:
    x = int(input('Enter the first number:'))
    y = int(input('Enter the second number:'))
    print(x / y)
except:
    print('Something wrong happened …')

??現(xiàn)在，用戶輸入什么錯誤信息都可以報錯。可以在except子句中忽略所有異常類，從而讓程序輸出自己定義的異常信息。
??但是，像這樣捕獲所有的異常很危險，因為這不僅會隱藏你有心理準備的錯誤，還會隱藏你沒有考慮過的錯誤。這還將捕獲用戶使用Ctrl + C終止執(zhí)行的企圖、調(diào)用函數(shù)sys.exit來終止執(zhí)行的企圖等。在大多數(shù)情況下，更好的選擇是使用except Exception as e并對異常對象進行檢查。這樣做將讓不是從Exception派生而來的為數(shù)不多的異常成為漏網(wǎng)之魚，其中包括SystemExit和KeyboardInterrupt，因為它們是從BaseException(Exception的超類)派生而來的。

6. 萬事大吉時

??在有些情況下，在沒有出現(xiàn)異常時執(zhí)行一個代碼塊很有用。為此，可像條件語句和循環(huán)一樣，給try/except語句添加一個else子句。

try:
    print('A simple tasl')
except:
    print('what? Something went wrong?')
else:
    print('Ah … It went as planned.')

??如果你運行這些代碼，輸出如下：

A simple tasl
Ah … It went as planned.

??通過使用else子句，可實現(xiàn)3.(3)所說的循環(huán)

while True:
    try:
        x = int(input('Enter the first number:'))
        y = int(input('Enter the second number:'))
        value x / y
        print('x / y is ', value)
    except:
        print('Invalid input. Please try again')
    else:
        break

??在這里，僅當沒有引發(fā)異常時，才會跳出循環(huán)。換而言之，只要出現(xiàn)錯誤，程序就會要求用戶提供新的輸入。
??前面說過，一種更佳的替代方案是使用空的except子句來捕獲所有屬于類Exception的異常。你不能完全確定這將捕獲所有的異常，因為try/except語句中的代碼可能使用舊式的字符串異?；蛞l(fā)并非從Exception派生而來的異常。然而，如果使用except Exception as e，就可利用3.(4)節(jié)介紹的技巧在這個小型除法程序中打印更有用的錯誤消息。

while True:
    try:
        x = int(input('Enter the first number:'))
        y = int(input('Enter the second number:'))
        value x / y
        print('x / y is ', value)
    except Exception as e:
        print('Invalid input：', e)
        print('please try again!')
    else:
        break

??如果在try子句執(zhí)行時沒有發(fā)生異常，就會執(zhí)行else語句后面的語句。使用else子句比把所有語句都放在try子句里更好，這樣可以避免一些意想不到而except又沒有捕獲的異常。
??當程序沒有發(fā)生異常時，通過添加一個else子句做一些事情(比如輸出一些信息)很有用，可以幫助我們更好地判斷程序的執(zhí)行情況。

7. 最后

??最后，還有finally子句，可用于在發(fā)生異常時執(zhí)行清理工作。這個子句是與try子句配套的，try/finally語句無論發(fā)生異常與否都將執(zhí)行最后的代碼。

x = None
try:
    x = 1 / 0
finally:
    print('Cleaning up!不管怎么樣我都會先展示在最前面')
    del x

??在上述示例中，finally子句被執(zhí)行了，不管try子句中發(fā)生什么異常，都將執(zhí)行finally子句。為何在try子句之前初始化x呢？因為如果不這樣做，ZeroDivisionError將導致根本沒有機會給它賦值，進而導致在finally子句中對其執(zhí)行del時引發(fā)未捕獲的異常。
??如果運行這個程序，它將在執(zhí)行清理工作后崩潰。
??Cleaning up! 不管怎么樣我都會先展示在最前面

Traceback (most recent call last):
  File "<pyshell#42>", line 2, in <module>
    x = 1 / 0
ZeroDivisionError: division by zero

??雖然使用del來刪除變量是相當愚蠢的清理措施，但finally子句非常適合用于確保文件或網(wǎng)絡(luò)套接字等得以關(guān)閉，這將在第14章介紹。
??也可在一條語句中同時包含try、except、finally和else(或其中的3個)，但要記得else在except之后，finally在except和else之后。

try:
    1/0
except ZeroDivisionError:
    print('Division by zero')
else:
    print('That went well')
finally:
    print('cleaning up.')
#Division by zero
#cleaning up.
finally子句在關(guān)閉文件或數(shù)據(jù)庫連接時非常有用。

8. 補充和總結(jié)

??注意：如果拋出父類異常，在子類不會再獲取。
??如下：

try:
    fun()
except Exception as e:
    raise Exception
except ImportError as e:
    raise ImportError
finally:
    pass

??在上面的例子中，下面的ImportError就不會被拋出，應為ImportError繼承Exception，但是可以把Exception放在后面是可以的

try:
    suite1          #測試語句塊
except exception1:
    suite2          #如果測試語句suite1中發(fā)生exception1異常時執(zhí)行
except (exception2,exception3):
    suite3          #如果測試語句suite1中發(fā)生元組中任意異常時執(zhí)行
except exception4 as reason:    #as把異常的原因賦值給reason
    suite4          #如果測試語句suite1發(fā)生exception4的異常時執(zhí)行
except:
    suite5          #如果測試語句suite1發(fā)生異常在所列出的異常之外時執(zhí)行
else:
    suite5          #如果測試語句塊suite1中沒有發(fā)生異常時執(zhí)行
finally:
    suit6           #不管測試語句suite1中又沒有發(fā)生異常都會執(zhí)行

??所有錯誤類型都繼承自BaseException

四、異常和函數(shù)

??異常和函數(shù)有著天然的聯(lián)系。如果不處理函數(shù)中引發(fā)的異常，它將向上傳播到調(diào)用函數(shù)的地方。如果在那里也未得到處理，異常將繼續(xù)傳播，直至到達主程序(全局作用域)。如果主程序中也沒有異常處理程序，程序?qū)⒔K止并顯示棧跟蹤消息。來看一個示例。

>>> def faulty():
        raise Exception('Something is wrong')
>>> def ignore_exception():
        faulty()
>>> def handle_exception():
        try:
            faulty()
        except:
            print('Exception handled')

>>> ignore_exception()

??結(jié)果如下

Traceback (most recent call last):
  File "C:/Users/MIC/Desktop/test1.py", line 11, in <module>
    ignore_exception()
  File "C:/Users/MIC/Desktop/test1.py", line 4, in ignore_exception
    faulty()
  File "C:/Users/MIC/Desktop/test1.py", line 2, in faulty
    raise Exception('Something is wrong')
Exception: Something is wrong
>>> handle_exception()
Exception handled

??如你所見，faulty中引發(fā)的異常依次從faulty和ignore_exception向外傳播，最終導致顯示一條棧跟蹤消息。調(diào)用handle_exception時，異常最終傳播到handle_exception,并被這里的try/except語句處理。
??注意：異常信息是以堆棧的形式被拋出的，因而是從下往上查看的。所謂堆棧，就是最先被發(fā)現(xiàn)的異常信息最后被輸出，也被稱作先進后出。

五、異常之禪

??異常處理并不是很復雜。如果你知道代碼可能引發(fā)某種異常，且不希望出現(xiàn)這種異常時程序終止并顯示站跟蹤消息，可添加必要的try/except或try/finally語句(或結(jié)合使用)來處理它。
??有時候，可使用條件語句來達成異常處理實現(xiàn)的目標，但這樣編寫出來的代碼可能不那么自然，可讀性也沒那么高。另一方面，有些任務使用if/else完成時看似很自然，但實際上使用try/except來完成要好得多。下面來看兩個示例。
??假設(shè)有一個字典，你要在指定的鍵存在時打印與之相關(guān)聯(lián)的值，否則什么都不做。實現(xiàn)這種功能的代碼可能類似于下面這樣：

def describe_person(person):
    print('Description of', person['name'])
    print('Age:', person['age'])
if 'occupation' in person;
    print('Occupation:', person['occupation'])

??如果你調(diào)用這個函數(shù)，并向它提供一個包含姓名Throatwobbler Mangrove和年齡42的字典，輸出將如下：

Description of Throatwobbler Mangrove
Age: 42

??如果你在這個字典中添加職業(yè)camper，輸出將如下：

Description of Throatwobbler Mangrove
Age: 42
Occupation: camper

??這段代碼很直觀，但效率不高，因為它必須兩次查找'Occupation'鍵：一次檢查這個鍵是否存在(在條件中)，另一次獲取這個鍵關(guān)聯(lián)的值，以便將其打印出來。下面是另一種解決方案：

def describe_person(person):
    print('Description of', person['name'])
    print('Age:', person['age'])
    try:
        print('Occupation:', person['occupation'])
    except KeyError: pass

??在這里，函數(shù)直接假設(shè)存在'Occupation:'鍵。如果這種假設(shè)正確，就能省點事：直接獲取并打印值，而無需檢查這個鍵是否存在。如果這個鍵不存在，將引發(fā)KeyError，而except子句將捕獲這個異常。
??你可能發(fā)現(xiàn)，檢查對象是否包含特定的屬性時，try/except也很有用。例如，要檢查一個對象是否包含屬性write,可使用類似于下面的代碼：

try:
    obj.write
except AttributeError:
    print('The object is not writeable')
else:
    print('The object is writeable')

??在這里，try子句只是訪問屬性write，而沒有使用它來做任何事情。如果引發(fā)了AttributeError異常，說明對象沒有屬性write，否則就說明有這個屬性。這種解決方案可代替7.2.9節(jié)介紹的使用getattr的解決方案，而且更自然。具體使用哪種解決方案，在很大程度上取決于個人喜好。
??在很多情況下，相比于使用if/else，使用try/except語句更自然，也更符合Python的風格。因此你應養(yǎng)成盡可能使用try/except語句的習慣。

六、不那么異常的情況

??如果你只想發(fā)出警告，指出情況偏離了正規(guī)，可使用模塊warnings中的函數(shù)warn。

>>> from warnings import warn
>>> warn("I've got a bad feeling about this.")
Warning (from warnings module):
  File "C:/Users/MIC/Desktop/test1.py", line 1
    def faulty():
UserWarning: I've got a bad feeling about this.

??警告只顯示一次。如果再運行最后一行代碼，什么事情都不會發(fā)生。
??如果其他代碼在使用你的模塊，可使用模塊warning中的函數(shù)filterwarning來抑制你發(fā)出的警告(或特定類型的警告)，并指定要采取的措施，如"error"或"ignore"。

>>> from warnings import filterwarnings
>>> filterwarnings("ignore")
>>> warn("Anyone out there?")
>>> filterwarnings("error")
>>> warn("Something is very wrong!")
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    warn("Something is very wrong!")
UserWarning: Something is very wrong!

??如你所見，引發(fā)的異常為UserWaining。發(fā)出警告時，可指定將引發(fā)的異常(即警告類型)，但必須是Warning的子類。如果將警告轉(zhuǎn)換為錯誤，將使用你指定的異常。另外，還可根據(jù)異常來過濾特定類型的警告。

>>> filterwarnings("error")
>>> warn("This function is really old ...", DeprecationWarning) #指定異常
Traceback (most recent call last):
  File "<pyshell#54>", line 1, in <module>
    warn("This function is really old ...", DeprecationWarning)
DeprecationWarning: This function is really old ...
>>> filterwarnings("ignore", category=DeprecationWarning) #指定過濾掉的異常
>>> warn("Another deprecation warning.", DeprecationWarning)
>>> warn("Something else.")
Traceback (most recent call last):
  File "<pyshell#57>", line 1, in <module>
    warn("Something else.")
UserWarning: Something else.

??除上述基本用途外，模塊warnings還提供了一些高級功能。