在shell腳本中，常用if來判斷程序的某個部分是否可能會出錯，並在if的分支中做出對應的處理，從而讓程序更具健壯性。if判斷是異常處理的一種方式，所有語言都通用。對於特性完整的編程語言來說，都有專門的異常處理機制，有些語言用起來可能會很復雜，要求一堆堆的，有些語言則非常簡潔，用起來非常通暢。
入門示例
異常處理：try/except
對於索引查找的操作，在索引越界搜索的時候會報錯。例如：
>>> s="long"
>>> s[4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
所報的錯誤是IndexError。如果將索引查找放在一個函數里：
>>> def fetcher(obj,index):
... return obj[index]
那么調用函數的時候，如果里面的索引越界了，異常將匯報到函數調用者。
>>> fetcher(s,3)
'g'
>>> fetcher(s,4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in fetcher
IndexError: string index out of range
可以使用try/except來捕獲異常。作為入門示例，下面是簡單版的格式：
try:
statement1
...
statementN
except <ERRORTYPE>:
...statementS...
例如，try中是要監視正確執行與否的語句，ERRORTYPE是要監視的錯誤類型。
- 只要try中的任何一條語句拋出了錯誤，try中該異常語句后面的語句都不會再執行；
- 如果拋出的錯誤正好是except所監視的錯誤類型，就會執行statementS部分的語句；
- 如果異常正好被except捕獲(匹配)到了，程序在執行完statementS后會繼續執行下去，如果沒有捕獲到，程序將終止；
- 換句話說，except捕獲到錯誤后，相當於處理了這個錯誤，程序不會因為已經被處理過的錯誤而停止
例如捕獲上面的函數調用：
def fetcher(obj, index):
return obj[index]
s = "long"
try:
print(fetcher(s, 3) * 4)
print(fetcher(s, 4) * 4)
except IndexError:
print("something wrong")
print("after Exception, Continue")
輸出結果：
gggg
something wrong
after Exception, Continue
因為上面的fetcher(s, 4)會拋出異常，且正好匹配except監視的異常類型，所以輸出something wrong，異常被處理之后，程序繼續執行，即try/except后面的print()。
異常處理：try/finally
finally是try之后一定會執行的語句段落。可以結合except一起使用。
try:
statement1
...
statementN
finally:
...statementF...
try:
statement1
...
statementN
except <ERRORTYPE>:
...statementS...
finally:
...statementF...
不論try中的語句是否出現異常，不論except是否捕獲到對應的異常，finally都會執行：
- 如果異常沒有被捕獲，則在執行finally之后程序退出
- 如果異常被except捕獲，則執行完except的語句之后執行finally的語句，然后程序繼續運行下去
一般來說，finally中都會用來做程序善后清理工作。
例如：
def fetcher(obj, index):
return obj[index]
s = "long"
try:
print(fetcher(s, 3) * 4)
print(fetcher(s, 4) * 4)
except IndexError:
print("something wrong")
finally:
print("in finally")
print("after Exception, Continue")
輸出：
gggg
something wrong
in finally
after Exception, Continue
如果把except那段代碼刪掉，得到的結果將是：
gggg
in finally # 輸出了finally的內容
Traceback (most recent call last):
File "g:/pycode/list.py", line 8, in <module>
print(fetcher(s, 4) * 4)
File "g:/pycode/list.py", line 2, in fetcher
return obj[index]
IndexError: string index out of range
產生異常：raise和assert
使用raise或assert可以主動生成異常情況。其中raise可以直接拋出某個異常，assert需要通過布爾值來判斷，然后再拋出給定的錯誤。
例如，在函數里做個沒什么用的的判斷，用來演示raise：
def fetcher(obj, index):
if index >= len(obj):
raise IndexError
return obj[index]
這和直接索引越界是以一樣的。上面raise拋出的異常IndexError是一個內置異常，可以直接引用這些內置異常。稍后會演示如何自定義自己的異常。
拋出異常后，就可以按照前面介紹的try來處理異常。
assert是一種斷言，在計算機語言中表示：如果斷言條件為真就跳過，如果為假就拋出異常信息。它可以自定義異常信息。
例如:
def fetcher(obj, index):
assert index < len(obj), "one exception"
return obj[index]
很多時候會直接在assert中使用False、True的布爾值進行程序的調試。
assert True, "assert not hit"
assert False, "assert hit"
自定義異常
python中的異常是通過類來定義的，而且所有的異常類都繼承自Exception類，而Exception又繼承自BaseException(這個類不能直接作為其它異常類的父類)。所以自定義異常的時候，也要繼承Exception，當然，繼承某個中間異常類也可以。
例如，定義索引越界的異常類，注意這個類中直接pass，但因為繼承了Exception，它仍然會有異常信息。
class MyIndexError(Exception):
pass
例如，判斷字母是否是大寫，如果是，就拋異常：
def fetcher(obj,index):
if index >= len(obj):
raise MyIndexError
return obj[index]
測試一下：
s = "long"
print(fetcher(s, 3) * 4)
print(fetcher(s, 4) * 4)
結果：
gggg
Traceback (most recent call last):
File "g:/pycode/list.py", line 12, in <module>
print(fetcher(s, 4) * 4)
File "g:/pycode/list.py", line 6, in fetcher
raise MyIndexError
__main__.MyIndexError
需要注意，因為異常類都繼承字Exception，except監視Exception異常的時候，也會匹配其它的異常。更標准地說，監視異常父類，也會捕獲到這個類的子類異常。
如何看拋出的異常
看異常信息是最基本的能力。例如，下面的這段代碼會報除0錯誤：
def a(x, y):
return x/y
def b(x):
print(a(x, 0))
b(1)
執行時，報錯信息如下：
Traceback (most recent call last):
File "g:/pycode/list.py", line 7, in <module>
b(1)
File "g:/pycode/list.py", line 5, in b
print(a(x, 0))
File "g:/pycode/list.py", line 2, in a
return x/y
ZeroDivisionError: division by zero
這個堆棧跟蹤信息中已經明確說明了(most recent call last)，說明最近產生異常的調用在最上面，也就是第7行。上面的整個過程是這樣的：第7行出錯，它是因為第5行的代碼引起的，而第5行之所以錯是第2行的源代碼引起的。
所以，從最底部可以看到最終是因為什么而拋出異常，從最頂部可以看到是執行到哪一句出錯。
深入異常處理
try/except/else/finally
try:
<statements>
except <name1>: # 捕獲到名為name1的異常
<statements>
except (name2, name3): # 捕獲到name2或name3任一異常
<statements>
except <name4> as <data>: # 捕獲name4異常，並獲取異常的示例
<statements>
except: # 以上異常都不匹配時
<statements>
else: # 沒有產生異常時
<statements>
finally: # 一定會執行的
<statements>
注意，當拋出的異常無法被匹配時，將歸類於空的except:，但這是很危險的行為，因為很多時候的異常是必然的，比如某些退出操作、內存不足、Ctrl+C等等，而這些都會被捕獲。與之大致等價的是捕獲異常類的"偽"祖先類Exception，即except Exception:，它和空異常匹配類似，但能解決不少不應該匹配的異常。但使用Exception依然是危險的，能不用盡量不用。
如果一個異常既能被name1匹配，又能被name2匹配，則先匹配到的處理這個異常。
通過as關鍵字可以將except捕獲到的異常對象賦值給data變量。用法稍后會解釋，現在需要知道的是，在python 3.x中，變量data只在當前的except塊范圍內有效，出了范圍就會被回收。如果想要保留異常對象，可以將data賦值給一個變量。例如下面的b在出了try范圍都有效，但是a在這個except之后就無效了。
except Exception as a:
print(a)
b=a
通過else分句可以知道，這段try代碼中沒有出現任何異常。否則就不會執行到else分句。
raise
raise用於手動觸發一個異常。而每一種異常都是一個異常類，所以觸發實際上是觸發一個異常類的實例對象。
raise <instance> # 直接觸發一個異常類的對象
raise <class> # 構建此處所給類的一個異常對象並觸發
raise # 觸發最近觸發的異常
raise <2> from <1> # 將<1>的異常附加在<2>上
其中第二種形式，raise會根據給定類不傳遞任何參數地自動構建一個異常對象，並觸發這個異常對象。第三種直接觸發最近觸發的異常對象，這在傳播異常的時候很有用。
例如，下面兩種方式實際上是等價的，只不過第一種方式傳遞的是類，raise會隱式地自動創建這個異常類的實例對象。
raise IndexError
raise IndexError()
可以為異常類構建實例時指定點參數信息，這些參數會保存到名為args的元組。例如：
try:
raise IndexError("something wrong")
except Exception as E:
print(E.args)
輸出：
('something wrong',)
不僅如此，只要是異常類或異常對象，不管它們的存在形式如何，都可以放在raise中。例如：
err = IndexErro()
raise err
errs = [IndexError, TypeError]
raise errs[0]
對於第三種raise形式，它主要用來傳播異常，一般用在except代碼段中。例如：
try:
raise IndexError("aaaaa")
except IndexError:
print("something wrong")
raise
因為異常被except捕獲后，就表示這個異常已經處理過了，程序會跳轉到finally或整個try塊的尾部繼續執行下去。但是如果不想讓程序繼續執行，而是僅僅只是想知道發生了這個異常，並做一番處理，然后繼續向上觸發異常。這就是異常傳播。
因為實際觸發的異常都是類的實例對象，所以它有屬性。而且，可以通過在except中使用as來將對象賦值給變量：
try:
1/0
except Exception as a:
print(a)
變量a在出了except的范圍就失效，所以可以將它保留給一個不會失效的變量：
try:
1/0
except Exception as a:
print(a)
b=a
print(b)
如果在一個except中觸發了另一個異常，會造成異常鏈：
try:
1/0
except Exception as E:
raise TypeError('Bad')
將會報告兩個異常，並提示處理異常E的時候，觸發了另一個異常TypeError。
Traceback (most recent call last):
File "g:/pycode/list.py", 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 "g:/pycode/list.py", line 4, in <module>
raise TypeError('Bad')
TypeError: Bad
使用from關鍵字，可以讓關系更加明確。
try:
1/0
except Exception as E:
raise TypeError('Bad') from E
下面是錯誤報告：
Traceback (most recent call last):
File "g:/pycode/list.py", line 2, in <module>
1/0
ZeroDivisionError: division by zero
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "g:/pycode/list.py", line 4, in <module>
raise TypeError('Bad') from E
TypeError: Bad
實際上，使用from關鍵字的時候，會將E的異常對象附加到TypeError的__cause__屬性上。
但無論如何，這里都觸發了多個異常。在python 3.3版本，可以使用from None的方式來掩蓋異常的來源，也就是禁止輸出異常E，停止異常鏈：
try:
1/0
except Exception as E:
raise TypeError('Bad') from None
錯誤報告如下：
Traceback (most recent call last):
File "g:/pycode/list.py", line 4, in <module>
raise TypeError('Bad') from None
TypeError: Bad
可見，異常信息中少了很多內容。
assert
assert斷言常用於調試。用法如下：
assert test, data
它實際上等價於是條件判斷的raise。它等價於下面的方式：
if __debug__:
if not test:
raise AssertionError(data)
如果條件test的測試為真，就跳過，否則就拋出異常。這個異常是通過AssertionError類構造的，構造異常對象的參數是data。data會放進名為args的元組屬性中。
try:
assert False,"something wrong"
except Exception as E:
print(E.args)
同樣，assert產生的是名為AssertionError的異常，如果不捕獲這個AssertionError異常，程序將會終止。
除了調試，assert還偶爾用來判斷必要的條件，不滿足條件就異常，以便讓程序更加健壯。例如：
def f(x):
assert x >= 0, "x must great or equal than 0"
return x ** 2
print(f(2))
print(f(0))
print(f(-2)) # 觸發AssertionError異常
需要注意的是，寫assert的測試條件時，測試結果為假才觸發異常。所以，應該以if not true的角度去考慮條件，或者以unless的角度考慮。或者說，后面觸發的異常信息，和測試條件應該是正相關的，例如示例中異常信息的說法是x必須大於等於0，和測試條件x >= 0是正相關的。
assert還常用於父類方法的某些方法中，這些方法要求子類必須重寫父類的方法。於是：
class cls:
...
def f(self):
assert False, "you must override method: f"
此外，assert不應該用來觸發那些python早已經定義好的異常。例如索引越界、類型錯誤等等。這些python已經定義好的異常，我們再去用AssertionError觸發，這是完全多余的。例如：
def f(obj,index):
assert index > len(obj), "IndexError"
return obj[index]
sys.exc_info()
該函數用來收集正在處理的異常的信息。
它返回一個包含3個值的元組(type, value, traceback)，它們是當前正在處理的異常的信息。如果沒有正在處理的異常，則返回3個None組成的元組。
其中:
- type表示正在處理的異常類
- value表示正在處理的異常實例
- traceback表示一個棧空間的回調對象(參考官方手冊traceback object)
看一個示例即可知道。
class General(Exception):pass
def raise0():
x = General()
raise x
try:
raise0()
except Exception:
import sys
print(sys.exc_info())
執行結果：
(<class '__main__.General'>, General(), <traceback object at 0x0388F2B0>)
結果很明顯，第一個返回值是異常類General，第二個返回值是拋出的異常類的實例對象，第三個返回值是traceback對象。
實際上，當需要獲取當前處理的異常類時，還可以通過異常對象的__class__來獲取，因為異常對象可以在except/as中賦值給變量：
class General(Exception):pass
def raise0():
x = General()
raise x
try:
raise0()
except Exception as E:
import sys
print(sys.exc_info()[0])
print(E.__class__)
它們的的結果是完全一樣的：
<class '__main__.General'>
<class '__main__.General'>
什么時候要獲取異常類的信息？當except所監視的異常類比較大范圍，同時又想知道具體的異常類。比如，except:或except Exception:這兩種監視的異常范圍都非常大，前者會監視BaseException，也就是python的所有異常，后者監視的是Exception，也就是python的所有普通的異常。正因為監視范圍太大，導致不知道具體是拋出的是哪個異常。
區分異常和錯誤
錯誤都是異常，但異常並不一定都是錯誤。
很常見的，文件結尾的EOF在各種語言中它都定義為異常，是異常就能被觸發捕獲，但在邏輯上卻不認為它是錯誤。
除此之外，還有操作系統的異常，比如sys.exit()引發的SystemeExit異常，ctrl+c引發的的中斷異常KeyboardInterrupt都屬於異常，但它們和普通的異常不一樣。而且python中的普通異常都繼承字Exception類，但SystemExit卻並非它的子類，而是BaseException的子類。所以能通過空的except:捕獲到它，卻不能通過except Exception:來捕獲。
異常類的繼承
所有異常類都繼承自Exception，要編寫自定義的異常時，要么直接繼承該類，要么繼承該類的某個子類。
例如，下面定義三個異常類，General類繼承Exception，另外兩個繼承General類，表示這兩個是特定的、更具體的異常類。
class General(Exception):pass
class Specific1(General): pass
class Specific2(General): pass
def raise0():
x = General()
raise x
def raise1():
x = Specific1()
raise x
def raise2():
x = Specific2()
raise x
測試下：
for func in (raise0, raise1, raise2):
try:
func()
except General as E:
import sys
print("caught: ", E.__class__)
執行結果：
caught: <class '__main__.General'>
caught: <class '__main__.Specific1'>
caught: <class '__main__.Specific2'>
前面說過，except監視父類異常的時候，也會捕獲該類的子類異常。正如這里監視的是Gereral類，但觸發了Specific子類異常也會被捕獲。
異常類的嵌套
這是非常常見的陷阱。有兩種異常嵌套的方式：try的嵌套；代碼塊的異常嵌套(比如函數嵌套)。無論是哪種嵌套模式，異常都只在最近(或者說是最內層)的代碼塊中被處理，但是finally塊是所有try都會執行的。
第一種try的嵌套模式：
try:
try:
(1)
except xxx:
(2)
finally:
(3)
except yyy:
...
finally:
(4)
如果在(1)處拋出了異常，無論yyy是否匹配這個異常，只要xxx能匹配這個異常，就會執行(2)。但(3)、(4)這兩個finally都會執行。
第二種代碼塊嵌套，常見的是函數調用的嵌套，這種情況可能會比較隱式。例如：
def action2():
print(1 + [])
def action1():
try:
action2()
except TypeError:
print('inner try')
try:
action1()
except TypeError:
print('outer try')
執行結果：
inner try
上面的action2()會拋出一個TypeError的異常。在action1()中用了try包圍action2()的調用，於是action2()的異常匯報給action1()層，然后被捕獲。
但是在最外面，使用try包圍action1()的調用，看上去異常也會被捕獲，但實際上並不會，因為在action2()中就已經通過except處理好了異常，而處理過的異常將不再是異常，不會再觸發外層的異常，所以上面不會輸出"outer try"。
except應該捕獲哪些異常
在考慮異常捕獲的時候，需要注意幾點：
- except監視的范圍別太大了
- except監視的范圍別太小了
- 有些異常本就該讓它中斷程序的運行，不要去捕獲它
第三點很容易理解，有些異常會導致程序無法進行后續的運行，改中斷還是得中斷。
對於第一點，可能常用的大范圍異常監視就是下面兩種方式：
except:
except Exception:
這兩種方式監視的范圍都太大了，比如有些不想處理的異常也會被它們監視到。更糟糕的可能是本該匯報給上層的異常，結果卻被這種大范圍捕獲了。例如：
def func():
try:
...
except:
...
try:
func()
except IndexErro:
...
本來是想在外層的try中明確捕獲func觸發的IndexError異常的，但是func()內卻使用了空的except:，使得異常直接在這里被處理，外層的try永遠也捕獲不到任何該函數的異常。
關於第二點，不應該監視范圍太小的異常。范圍小，意味着監視的異常太過具體，太過細致，這種監視方式雖然精確，但卻不利於維護。例如E1異常類有2個子異常類E2、E3，在代碼中監視了E2、E3，但如果未來又添加了一個E1的子異常類E4，那么又得去改代碼讓它監視E4。如果代碼是寫給自己用的倒無所謂，但如果像通用模塊一樣交給別人用的，這意味着讓別的模塊使用者也去改代碼。
自定義異常類
在前面設計異常類的時候，總是使用pass跳過類代碼體。但卻仍然能使用這個類作為異常類，因為它繼承了Exception，在Exception中有相關代碼可以輸出異常信息。
前面說過，在構造異常類的時候可以傳遞參數，它們會放進異常實例對象的args屬性中：
try:
raise IndexError("something wrong")
except Exception as E:
print(E.args)
try:
assert False,"something wrong too"
except Exception as E:
print(E.args)
I = IndexError('text')
print(I.args)
對於用戶自定義的類，也一樣如此：
class MyError(Exception):pass
try:
raise MyError('something wrong')
except MyError as E:
print(E.args)
不僅如此，雖然異常實例對象是一個對象，但如果直接輸出實例對象，那么得到的結果將是給定的異常信息，只不過它不在元組中。
I = IndexError("index wrong")
print(I) # 輸出"index wrong"
很容易想到，這是因為Exception類中重寫了__str__或者__repr__中的某一個或兩個都重寫了。
自定義異常輸出
於是，自定義異常類的時候，也可以重寫這兩個中的一個，從而可以定制屬於自己的異常類的輸出信息。一般來說只重寫__str__，因為Exception中也是重寫該類，且它的優先級高於__repr__。
例如下面自定義的異常類。當然，這個示例的效果非常簡陋，但已足夠說明問題。
class MyError(Exception):
def __str__(self):
return 'output this message for something wrong'
try:
raise MyError("hahhaha")
except MyError as E:
print(E)
輸出結果：
output this message for something wrong
提供構造方法
自定義異常類的時候，可以重寫構造方法__init__()，這樣raise異常的時候，可以指定構造的數據。而且更進一步的，還可以重寫__str__來自定義異常輸出。
例如，格式化文件的程序中定義一個異常類，用來提示解析到哪個文件的哪一行出錯。
class MyError(Exception):
def __init__(self,line,file):
self.line = line
self.file = file
def __str__(self):
return "format failed: %s at %s" % (self.file, self.line)
def format():
...
raise MyError(42, "a.json")
...
try:
format()
except MyError as E:
print(E)
提供異常類的其它方法
異常類既然是類，說明它可以像普通類一樣拿來應用。比如添加其它類方法。
例如，可以將異常信息寫入到文件中。只需提供一個向文件寫入的方法，並在except的語句塊中調用這個方法即可。
class MyError(Exception):
def __init__(self, line, file):
self.line = line
self.file = file
def logerr(self):
with open('Error.log', 'a') as logfile:
print(self, file=logfile)
def __str__(self):
return "format failed: %s at %s" % (self.file, self.line)
def format():
raise MyError(42, "a.json")
try:
format()
except MyError as E:
E.logerr()