異常處理(3)

一、異常基礎
try/except：捕捉由程式碼中的異常並恢復，匹配except裡面的錯誤，並自行except中定義的程式碼，後繼續執行程式（發生異常後，由except捕捉到異常後，不會中斷程式，繼續執行try語句後面的程式）
try/finally: 無論異常是否發生，都執行清理行為 （發生異常時程式會中斷程式，只不過會執行finally後的程式碼）
raise: 手動在程式碼中接觸發異常。
assert: 有條件地在程式程式碼中觸發異常。
with/as 在Python2.6和後續版本中實現環境管理器。
使用者定義的異常要寫成類的例項，而不是字串、。
finally可以和except和else分句出現在相同的try語句內、
1、異常的角色
錯誤處理
事件通知
特殊情況處理：有時發生很罕見的情況，很難調整程式碼去處理。通常會在異常處理器中處理這些罕見的情況，從而省去編寫應對特殊情況的程式碼
終止行為
非常規控制流程

>>> x='diege
>>> def fetcher(obj,index):
...     return obj[index]
...
>>> fetcher(x,4)
'e'
>>> fetcher(x,5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in fetcher
IndexError: string index out of range
>>> try:
...     fetcher(x,5)        #嘗試抓取第5個字元
... except IndexError:      #如果發生異常【指出引發的異常名稱】
...     print fetcher(x,-1)  #那就抓取最後一個字元
...
e
>>> def catcher():
...     try:
...             fetcher(x,5)
...     except IndexError:
...             print fetcher(x,-1)
...     print "continuing"
...
>>> catcher()    
e
continuing
 

可以看到從異常中恢復並繼續執行。
try/finally: 無論異常是否發生，都執行清理行為（發生異常時程式也會終端，只不過會執行finally後的程式碼）

>>> try:
...     fetcher(x,4)
... finally:
...     print 'after fetch'
...
'e'
after fetch

沒有發生異常的情況,也執行finally語句中的程式碼
發生異常的情況下

>>> try:
...     fetcher(x,5)      
... finally:              
...     print 'after fetch'
...
after fetch
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in fetcher
IndexError: string index out of range
 

發生異常的情況下，也執行了finally語句中的程式碼
實際應用鎮南關，try/except的組合可用於捕捉異常並從中恢復，而try/finally的組合則很方便，可以確保無論try程式碼塊內的
程式碼是否發生異常，終止行為一定會執行。如，try/except來捕捉第三方庫匯入的程式碼所引發的錯誤，然後以try/finally來確保
關閉檔案，或者終止伺服器連線等呼叫。
可以在同一個try語句內混合except和finally分句:finally一定回執行，無論是否有異常引發，而且不也不關異常是否被except分句捕捉到
2、try/except/else語句
try的完整形式：try/多個except/else語句
else是可選的
try首行底下的程式碼塊代表此語句的主要動作：試著執行的程式程式碼。except分句定義try程式碼塊內引發的異常處理器，而else分句（如果有）則是提供沒有發生異常時候要執行的處理器。
*如果try程式碼塊語句執行時發生了異常，Python就跳回try，執行第一個符合引發的異常的except分句下面的語句。當except程式碼執行後（除非 except程式碼塊引發另一異常），控制全就會到整個try語句後繼續執行。
*如果異常發生在try程式碼塊內，沒有符合的except分句，異常就會向上傳遞到程式的之前進入try中，或者到這個程序的頂層（使用Python終止這個程式並列印預設的錯誤訊息）
*如果try首行底下執行的語句沒有發生異常，Python就會執行else行下的語句（如果有的話），控制權會在整個try語句下繼續。
也就是說except分句會捕捉try程式碼塊執行時所有發生的任何異常，而else分句只在try程式碼執行沒有發生異常時才執行，finally分句無法釋放發生異常都執行。
3、try語句分句形式
分句形式            說明
except:                捕捉所有（其他）異常型別
except name:        只捕捉特定的異常
except name,value:    捕捉所有的異常和其額外的資料（或例項）
except (name1,name2) 捕捉任何列出的異常
except (name1,name2),value: 捕捉任何列出的異常，並取得其額外資料
else:                如果沒有引發異常，就執行
finally:            總是會執行此程式碼塊，無論是否發生異常
except:用在想不到異常情況，在except:前面可以定義可以想到的異常：except name1: except name2:
3、try/else分句

        try:
                customer=getargv[1]
        except IndexError:
                print "please give argv as customer!"
        else:
                scene=PizzaShop()
                scene.order(customer)
                print '...'

如把else:語句的內容放到try:中，也能執行。模擬出else分句。不過這可能造成不正確的異常分類。如果“沒有異常發生”這個行為觸發了
IndexError，就會視為try程式碼塊的失敗，因此錯誤地觸發try底下的異常處理器。改為明確的else分句，讓邏輯封明確。保證except處理器
只會因為包裝在try中程式碼真正的失敗而執行，而不是為else中的情況行為失敗而執行。
4、try/finally分句
python先執行try: 下的程式碼塊：
如果try程式碼塊執行時沒有異常發生，Python會跳至finally程式碼塊。然後整個try語句後繼續執行下去。
如果try程式碼塊執行時有發生異常，Python依然會回來執行finally程式碼塊，但是接著會把異常向上傳遞到較高的try語句或頂層的預設處理器。程式不會在try語句繼續執行。

        try:
                Uppercase(open('/etc/rc.conf'),output).process()
        finally:
                open('/etc/rc.conf').close

5、統一try/except/finally分句

try:
    main-action:
except Exception1:
    hander1
except Exception2:
    hander2
...
else:
    else-block
finally:
    finally-block

這語句中main-action程式碼會先執行。如果該程式程式碼（main-action）引發異常，那麼except程式碼塊都會逐一測試，尋找與丟擲的異常相符的語句。如果引發異常的是Exception1則會執行hander1程式碼塊，如果引發異常的是Exception2，則會執行hander2程式碼塊。以此類推。如果沒有
引發異常，將會執行else-block程式碼塊。
無論前面發生什麼，當main-action程式碼塊完成時。finally-block都會執行。
6、通過巢狀合併except和finally

try:
    try:
        main-action:
    except Exception1:
        hander1
    except Exception2:
        hander2
    ...
    else:
        else-block
finally:
    finally-block

和5的效果一樣
7、raise語句
要故意觸發異常，可以使用raise語句。raise語句組成是： raise關鍵字，後面跟著要引發的異常名稱（選用），以及一個可選的額外的資料項，後可隨著異常傳遞
raise <name>
raise <name>,<data>
raise
注意：<name>需要預先定義好，不然會由未定義錯誤。
第二種形式隨著異常傳遞額外的資料項，在raise語句中，資料是列在異常名稱的後面的；在try語句中，取得該資料是通過引入一個進行接收
它的變數實現的。例如，如果try引入一個exceptname,X:語句，則變數X就會被賦值為raise內所列出的額外的資料項,如果沒有定義預設接受到
的就是特殊物件None。一旦被程式中任意的except分句捕捉，異常就死了（也就是說，不會傳遞給另一個try），除非又被另一個raise語句或
錯誤所引發。現在使用者定義的異常應該是類例項物件。
8、assert語句
assert可以有條件地在程式程式碼中觸發異常，可以認為是有條件的raise.
牢記：assert幾乎都是用來收集使用者定義的約束條件，而不是捕捉內在的程式設計錯誤。因為Python會自動收集程式的設計錯誤，通常咩有必要寫assert去捕捉超出索引值，型別不匹配以及除數為0之類的事。
引發的異常為:AssertionError。如果沒有被try捕捉到，就會終止程式。
該語句形式:
assert  <test>,<data>
例項

>>> def f(x):
...     assert x>0,'x must be great zerot'
...     return x**2
...
>>> f(2)    
4
>>> f(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f
AssertionError: x must be great zerot

二、with/as環境管理
python2.6引入新的異常相關的語句：with及其可選的as分句。這個語句的設計是為了和環境管理器物件（支援新的方法協議)一起工作。
簡而言之， with/as語句的設計作為常見try/finally用法模式的替代方案。就像try/finally語句， with/as語句也用於定義必須執行的
終止或“清理"行為,無論步驟中是否發生異常。和try/finally不同的是，with語句支援更豐富的基於物件的協議，可以程式碼塊定義支援進入
和離開動作。
with語句基本格式：
with expression [as variable]:
    with block
在這裡expression要返回一個物件，從而支援環境管理協議。如果選用as分句存在時，此物件也可返回一個值，賦值給變數名variable.
注意：variable並非賦值為expression的結果，expression的結果是支援環境協議的物件,而variable則是賦值為其他的東西（？？)
然後,expression返回的物件可在with-block開始前，先自行啟動程式，並且在該程式碼塊完成後，執行終止程式程式碼，無論程式碼塊是否引發異常
有些內建的Python物件已得到強化，支援環境管理協議，因此可以用於with語句。例如，檔案物件有環境管理器，可在with程式碼塊後自動關閉
檔案，無法是否引發異常。
>>> with open('/etc/rc.conf') as myfile:
...     for line in myfile:
...             line=line.upper()
...             print line
在這裡，對open的呼叫，會返回一個簡單檔案物件，賦值給變數名myfile。我們可以用一般的檔案工具使用myfile:就此而言，檔案迭代器會在
for迴圈內逐行讀取。
然後，此物件也支援with語句所使用的環境協議。在這個with語句執行後。環境管理機制保證由myfile所引用的檔案物件自動關閉。即時處理
該檔案時，for迴圈引發了異常。
環境管理器是有寫高階的機制。還不是Python的正式組成部分。就較為簡單的用途來說,try/finally語句可對終止活動提供足夠的支援。

三、異常物件
基於類的異常可以建立各種異常類，有附加狀態資訊，而且支援繼承。儘量都適用類異常。類異常有如下特點；
* 提供型別分類，對今後的修改有更好的支援：以後增加新異常時，通常不需要在try語句中進行修改。
* 同了儲存在try處理器中所使用的環境資訊的合理地點：這樣的話，可以擁有狀態資訊，以及可呼叫的方法，並且可通過例項進行讀取。
* 允許異常參與繼承層次，從而可獲得共同的行為。例如，繼承的顯示方法可提供通用的錯誤訊息外觀。
所有內建異常都類組織成繼承樹。
Python2.5版本 字串異常會產生'deprecation‘（不建議使用）’警告。python3.0將不再支援字串異常。
1、基於字串的異常

>>> myexc="My exception string"
>>> try:
...     raise myexc
... except myexc:
...     print "caught"
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: exceptions must be old-style classes or derived from BaseException, not str

Python 2.7版本已經不在支援了
2、基於類的異常

>>> class General:pass
>>> class Spec1(General):pass 
>>> class Spec2(General):pass
>>> def raiseer0():
...     X=General()
...     raise X
>>> def raiseer1():
...     X=Spec1()      
...     raise X
>>> def raiseer2():
...     X=Spec2()  
...     raise X
>>> for func in (raiseer0,raiseer1,raiseer2):
...     try:
...             func()
...     except General:#使用異常的超類General，這樣子類也捕捉到，可以在未來增加函式異常（在子類裡)，而不影響程式。
...             import sys
...             print 'caught:',sys.exc_info()[0]
...
caught:__main__.General
caught:__main__.Spec1
caught:__main__.Spec2

在try語句中，捕捉其超類就會捕捉這個類，以及類樹中超類下的所有子類：超類會變成異常分類的名稱，而子類會變成該分類中特定的
異常型別。
Python2.5以後版本將每個異常都寫成類（必須),從異常樹頂層繼承Exception（非必須）。
sys.exc_info() 一種抓取最近發生異常的常用方式。
對基於類的異常而言，其結果中第一個元素就是引發異常類，而第二個是實際引發的例項。
注意：目前Python的說明檔案指出，使用者定義的異常最好繼承自Exception內建的異常（但不是必須要求）。
class General(Exception):pass
就大型多層次的異常而言，在一個except分句使用類捕捉分類，會比列出一個分類中每個成員更簡單。新增子類擴充套件異常層次，。也不會破壞
先有的程式碼。
如果不用類，在excpet中就會是excpet (General,Spec1,Spec2)： 這樣捕捉字串類。
基本原則是：在異常處理器中，通常來說具體要優於一般。
3、內建Exception類
Python把內建異常組織成層次，來支援各種捕捉模式
Exception：    異常的頂層根超類
StandardError:    所有內建錯誤異常的超類
ArithmeticError:    所有數值錯誤的超類
OverflowError:    識別特定的數值錯誤的子類
可以在Python庫手冊或exceptionsn模組的幫助文字中查閱。
>>> import exceptions
>>> help(exceptions)  
BaseException
            Exception
                StandardError
                    ArithmeticError
                        FloatingPointError
                        OverflowError
                        ZeroDivisionError
                    AssertionError
4、定義異常文字
對基於類的異常而言，其結果中第一個元素就是引發異常類，而第二個是實際引發的例項。
>>> raise MyBad():
>>> raise MyBad()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.MyBad: <__main__.MyBad instance at 0x2850d26c>
這樣的顯示不友好。改進顯示，可以在類中定義__repr__或__str__顯示字串過載方法，從而返回異常達到想要預設處理器顯示字串。
>>> class MyBad():                        
...     def __repr__(self):               
...             return "Sorry--my mistake!"
...
>>> raise MyBad()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.MyBad: Sorry--my mistake
這樣把顯示類的例項改為了我們定義的文字。
注意：如果繼承自內建異常類，錯誤測試會有細微的改變，構造方法引數會自動儲存並顯示在訊息中。【同樣也可以把繼承的過載】
>>> class MyBad(Exception):pass
... >>> raise MyBad()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.MyBad
>>> raise MyBad('the','bright','side','of')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.MyBad: ('the', 'bright', 'side', 'of')
5、傳送額外資料和例項行為
把環境資訊附加在基於類的異常的辦法是：在引發的例項物件中填寫例項的屬性，通常是在類的構造器方法中。在異常處理器中，是列出
要賦值為引發的例項的變數，然後通過這個變數名來讀取附加的轉改資訊，並且呼叫任何基礎的類方法。【很強大的功能】

>>> class FormatError:
...     def __init__(self,line,file):
...             self.line=line
...             self.file=file
>>> def parser():
...     raise FormatError(42,file='diege.txt') #手動定義異常，基於類的異常，類建構函式傳遞兩個資料。
...
>>> try:
...     parser()
... except FormatError,X: #定義接受異常(類的例項-異常引發時產生的例項)傳遞過來資料的變數。
...     print 'Error at',X.file,X.line #顯示例項傳遞過來的資料
...
Error at diege.txt 42

字串的格式為【已過時】
raise formatError,{'file':'diege.txt','line':43}
except FormatError,X:
    print 'Error at',X['file'],X['line']
6、raise的一般形式
raise string #基於字串的異常，已過時
raise string,data #基於字串的異常，已過時
raise instance    #最常用的模式，直接接一個例項：raise FormatError(42,file='diege.txt')
raise class,instance
raise
為了和內建異常為字串的的舊版相容，也可以
raise class #same as :raise class()
raise class,arg # same as :raise class(arg)
raise clase(arg1,arg2,...) #same as:raise class(arg1,arg2...)
這些都相當於raise class(arg)，等效於raise instance形式
>>> def parse():
...     raise FormatError,(42,'diege.txt')

四、異常的設計
1、巢狀異常處理器
把內部的try寫成函式來巢狀

>>> def action2():
...     print 1+[]
>>> def action1():
...     try:
...             action2()
...     except TypeError:
...             print "inner try"
>>> try:
...     action1()
... except TypeError:
...     print "outer try"
...
inner try
使用語法巢狀
>>> try:
...     try:
...             action2()
...     except TypeError:
...             print "inner try"  
... except TypeError:
...     print "outer try"
...
inner try

巢狀的finally語句會因一個異常全部啟動。

>>> try:   
...     try:
...             raise IndexError
...     finally:            
...             print "diege"
... finally:     
...     print "DIEGE"
...
diege
DIEGE
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
IndexError

2、異常的習慣使用者
1）異常不總是錯誤
在Python中，所有的錯誤都是異常。但並非所有的異常都是錯誤。

>>> while 1:
...     try:
...             line=raw_input()
...     except EOFError:
...             break
...     else:
...             print "print ...process nex line here.."

raw_input()在檔案末尾引發內建的EOFError
2)函式訊號條件和raise
使用者定義的異常也可以引發非錯誤的情況。
用於任何無法返回警示值以表明成功或失敗的函式。

class Failure(Exception):pass
def searcher():
    if ...success...;
        return ...founditem...
    else:
        raise Failure()
try:
    item=searcher()
except Failure:
    ...report...
else:
    ...use item here...

Python核心是動態型別和多型，通常更傾向於是用異常來發出這類情況的訊號，而不是警示性的返回值。
3)在try外進行除錯
空的except分句會捕捉任何程式執行時所引發的而未被捕捉到的異常。要取得發生的實際異常，可以從內建的
sys模組取出sys.exc_info函式的呼叫結果。這會返回一個元組，而元組之前兩個元素會自動包含當前異常的名稱，
以及相關的額外資料（如果有）。就基於類的異常而言，這兩個元素分別對應的是異常的類以及引發類的例項。
4)執行程序中的測試
5)關於sys.exc_info
sys.exc_info結果是獲得最近引發的異常更好的方式。如果沒有處理器正在處理，就返回包含了三個None值的元組。
否則，將會返回（type,value和traceback)
*type是正在處理的異常的異常型別（一個基於類的異常的類物件）
*value是異常引數（它的關聯值或raise的第二個引數，如果異常型別為類物件，就一定是類例項）
*traceback是一個traceback物件，代表異常最初發生時所呼叫的堆疊。
2、與異常有關的技巧
大致來說，Python的異常在使用上都很簡單。異常背後真正的技巧在於確定except分句要具體或多通用，以及try語句中要包括多少程式碼。
1）應該包裝什麼？
try語句中要包括多少程式碼。
簡要原則
*經常會失敗的運算一般都應該包裝在try語句內。例如：和系統狀態銜接的運算（檔案開啟，套接字呼叫等等）就是try的主要候選者。
*儘管這樣，上一條規則有寫特例：在簡單的指令碼中，你會希望這類運算失敗時終止程式，而不是被捕捉或被忽略。如果是一個重大的錯誤，
更應如此。Python的錯誤會產生有用的錯誤資訊，而且這通常就是所期望的最好的結果。
*應該try/finally中實現終止動作，從而保證它們的執行。這個語句形式可執行程式碼，無論異常是否發生。
*偶爾，把對大型函式的呼叫包裝在單個try語句內，而不是讓函式本身零散著放入若干try的語句中。這樣會更方便。這樣的話，函式中的異常
就會往上傳遞到呼叫周圍的try，而你也可以減少函式中的程式碼量。
2）捕捉太多：避免空except語句
如果使用空except語句,可能攔截到異常巢狀結構中較高層的try處理器所期待的事件這類程式碼可能會捕捉無關的系統異常。如記憶體錯誤，一
程式錯誤，迭代停止以及系統推出等等，都會在Python中引發異常。這裡異常通常是不應該攔截的。
3）捕捉太少：使用基於類的分類
3、核心語言總結
1)Python工具集
一般而言，Python提供了一個有層次的工具集。
內建工具：
像字串，列表和字典這些內建型別，會讓編寫程式更為迅速。
Python擴充套件：
就更重要的任務來說，可以編寫自己的函式，模組以及類來擴充套件Python
已編譯的擴充套件：
Python的工具箱型別。
分類        例子
物件型別    列表，字典，檔案和字串
函式        len，range,apply,open
異常        IdexError,KeyError
模組        os,TKinter,pickle,re
屬性        __dict__,__name__,__class__
外部工具    NumPY,SWIG,Jython,IronPython
2)大型專案的開放工具
PyDoc
PyChecker 檢查
PyUnit  測試
doctest  測試
IDE 圖形介面
配置工具 profile是標準塊模組，為python實現原始碼配置工具。
偵錯程式：原始碼偵錯程式模組，稱為pdb, 類似C的命令列偵錯程式gdb

>>> import pdb
>>> pdb.run("main()") #下面就可以在互動模式下執行程式碼除錯命令
> <string>(1)<module>()
(Pdb) action1
<function action1 at 0x28495bc4>
(Pdb) action1()
inner try

釋出選擇：Python程式常見打包工具。py2exe,PyInstaller以及freeze都可以打包位元組碼以及Python虛擬機器
優化選項：Psyco系統提供了實時的編譯器，可以把Python位元組碼翻譯成二進位制碼。
對大型醒目的提示