異常處理和麪向對象編程，是python編程中，比較重要的基礎。在實際生產編程設計和開發中，異常處理和麪向讀象都是必須在設計和開發過程中充分考慮的。
對於python開發和麪向對象這兩部分基礎，用一個python程序進行封裝說明，結果如下：
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
#################
#異常處理
#################
print '''
異常處理是用於處理軟件或信息系統中出現的異常狀況的一種機制，及超出程序正常執行流程的某些特殊條件。
在當前主流的編程語言的錯誤處理機制中，異常處理逐步替代了error code錯誤的處理方式，異常處理分離了接收和處理錯誤代碼。
這個功能理清編程思路，使代碼的可讀性增強，方便維護者閱讀和理解。
'''
print
print '''
異常處理，有稱錯誤處理，提供了程序運行時出現的任何意外或異常情況的方法。
python異常處理使用try,catch,else,finally等關鍵字來嘗試可能未成功的操作，處理失敗及正常情況，在事後清理資源。
python異常捕捉及處理的語法如下：
#可能會發生異常的程序塊
try:
block_try
#第1種except形式
except Exception1:
block_when_exception1_happen
#第2種except形式
except (Exception2, Exception3, Exception4):
block_when_exception2_or_3_or_4_happen
#第3種except形式
except Exception5, variance
block_when_exception5_happen
#第4種except形式
except (Exception6, Exception7),variance
block_when_exception6_or_7_happen
#第5種except形式
except:
blok_for_all_other_exceptions
#當沒有出現異常情況時的處理
else:
block_for_no_exceptions
#無論是否出現異常，最後要做的處理
finally:
block_anyway
'''
print
print '''
異常處理規則分爲四部分：
可能產生異常的代碼，寫在try塊中，try塊中發生異常，則try塊剩餘的代碼被終止；
異常判斷和發生時的代碼，寫在except中，具有有5種形式：
1是一種異常發生時，執行except塊內代碼；2是捕獲多種異常，執行代碼；3是捕獲的異常可以轉換爲變量；4是捕獲多種異常轉換爲變量；5是捕獲任何異常；
每種except捕獲形式，都可以定義多次，系統會逐個檢查，但有一個滿足條件時，執行except塊，其他的不再檢查和執行，類似於多個if-else條件；
else是可選模塊，定義如果沒有發生異常時，需要做的處理；
finally是可選模塊，無論try模塊是否發生異常，都會執行這裏的代碼；
總結一下，try模塊是程序對象，except是異常捕獲提交及應對，else是沒有異常時的處理，finally是最後必定執行的內容，與是否出現異常無關。
'''
print
#簡單異常處理示例
try:
result = 3/0
print "This is never been called"
except:
print "Exception happened"
finally:
print "Process finished!"
#多個except異常捕獲模塊的示例
try:
myList = [4, 6]
print myList[10]
print "This is never been called"
except ZeroDivisionError, e:
print "ZeroDivisionError happened"
print e
except (IndexError, EOFError), e:
print "Exception happened"
print e
except :
print "Unkown exception happened"
else:
print "No exception happened!"
finally:
print "Process finished!"
print
print '''
除了系統預定義的異常，還可以定義自己的特定邏輯異常。
自己定義異常，建立一個繼承系統異常的子類，並且在需要引發該異常時用raise語句拋出該異常。
'''
#自定義異常示例
import sys
class MyError(Exception):
def __str__(self):
return " I'm a self-defined Error! "
def main_except():
try:
print "**********Start of main()**********"
if len(sys.argv) == 1:
raise MyError()
print "**********End of main()**********"
except MyError, e:
print e
main_except()
#################
#面向對象編程
#################
print
print '''
面向讀象編程，與面向過程編程，函數式編程的特點是：
面向過程：根據業務邏輯從上到下寫壘代碼
函數式：將某功能代碼封裝到函數中，日後便無需重複編寫，僅調用函數即可
面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”
面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。
類就是一個模板，模板裏可以包含多個函數，函數裏實現一些功能
對象則是根據模板創建的實例，通過實例對象可以執行類中的函數
面向對象的三大特性是指：封裝、繼承和多態。
'''
print
print '''
面向對象是中程序設計規範，也是一種程序開發方法。python即可支持函數式編程，又可以支持面向對象編程，面向對象編程可以實現函數式編程的功能，函數式編程則不一定。
一般能夠使用面向對象編程，就儘量使用面向對象編程來實現。有的高級函數，如C#和Java只支持面向對象編程，不支持函數式編程。
面向對象，對象是指類的實例，類是創建對象的模板，一個類可以創建多個對象，每個對象都是類類型的一個變量；創建對象的過程，也叫作類的實例化。
面向對象編程中的主要概念有：
類 class：定義了一個事物抽象的特點。類定義了事物的屬性和它可以做到的行爲，一個類中可以有成員函數和成員變量，在面向讀象中，成員函數叫方法，成員變量叫屬性；
對象 object：是類的實例，每個類可以有若干個被實例化的對象。在OS中，熊給讀象分配內存，不會給類分配內存；
繼承 inheritance：是指通過一個已有的類（父類）定義另外一個類（子類），子類共享父類開放的屬性和方法。子類的對象是一個子類的實例，還是父類的一個實例。
封裝性 encapsulation：封裝性是指在定義時，可以將不能或不需要其他類知道的成員定義成私有成員，而只公開需要使用的成員，以達到信息隱藏和簡化的作用。
多態性 polymorphism：是指同一方法作用於不同的讀象，可以有不同的解釋，產生不同的執行結果，在實現上，多態性是孕婦開發者將父對象的變量設置爲對子對象的引用，賦值之後，父對象變量就可以根據當前的賦值給子對象的特性以不同方式運作。
隨着面向對象編程OOP的普及，面向對象涉及OOD也逐漸成熟，形成了以UML爲代表的標準建模語言。
UML是一個支持模型化和軟件系統開發的圖形化語言，爲軟件開發所有階段提供了模型化和可視化支持，包括有需求分析到規格，再到構造和配置的所有階段。
'''
print
print "類和讀象是面向對象編程的基礎，通過在類名後面加小括號可以直接實例化類來獲得讀象變量，使用對象變量可以訪問成員函數和成員變量。在構造函數中不能有返回值。"
#定義一個類
class MyClass(object):
message = "Hello, Developer."
def show(self):
print self.message
print MyClass.message
MyClass.message = "Good Morning!"
print MyClass.message
inst = MyClass()
inst.show()
print
print "構造函數是一種特殊的類成員方法，主要用來在創建對象時，初始化對象，爲對象成員賦初始值。python中構造函數用 __init__命名，爲類添加一個構造方法，實例一個對象。"
#定義類，增加構造函數示例
class MyClass(object):
message = 'Hello, Developer.'
def show(self):
print self.message
def _init__(self):
print "Constructor is called"
inst = MyClass()
inst.show()
#用默認參數的方式，實現多種方式構造對象
class MyClass(object):
message = "Hello, Developer."
def show(self):
print self.message
def __init__(self, name = "unset", color = "black"):
print "Constructor is called with params: ", name, " ", color
inst = MyClass()
inst.show()
inst2 = MyClass("David")
inst2.show()
inst3 = MyClass("Lisa", "Yellow")
inst3.show()
inst4 = MyClass(color = "Green")
inst4.show()
print
print '''
析構函數，是構造函數的反向函數，在銷燬釋放對象時，調用析構函數。析構函數往往做清理善後工作，例如數據庫連接，可以用析構函數是否對數據庫資源的佔用。
python中爲類定義析構函數的方法是在類中定義一個 __del__ 的沒有返回值和參數的函數。
與Java類似，python解釋器的堆中存儲這正在運行程序鎖建立的對象，不需要形式釋放；如果需要顯示銷燬對象，就使用del關鍵字。
'''
#創建類，調用析構函數示例
class MyClass(object):
message = 'Hello, Developer.'
def show(self):
print self.message
def __init__(self, name = 'unset', color = "black"):
print "Constructor is called with params: ", name, " ", color
def __del__(self):
print "Destructor is called!"
inst = MyClass()
inst.show()
inst2 = MyClass("David")
inst2.show()
del inst, inst2
inst3 = MyClass("Lisa", "Yellow")
inst3.show()
del inst3
print
print "類中有共享成員變量，如上面類中的message。如果要定義每個對象自己的成員變量，就要在構造函數中定義self引用的變量，即實例成員變量。"
#實例成員變量示例
class MyClass(object):
message = "Hello, Developer."
def show(self):
print self.message
print "Here is %s in %s!" % (self.name, self.color)
def __init__(self, name = "unset", color = "black"):
print "Constructor is called with params : ", name, " ", color
self.name = name
self.color = color
def __del__(self):
print "Destructor is called for %s!" % self.name
inst2 = MyClass("David")
inst2.show()
print "Color of inst2 is ", inst2.color, "\n"
inst3 = MyClass("Lisa", "Yellow")
inst3.show()
print "Name of inst3 is ", inst3.name, "\n"
del inst2, inst3
print '''
訪問類時，類成員函數與實例綁定，只能通過對象訪問而不能通過類名訪問。
python中支持兩種基於類名訪問成員的函數：靜態函數和類函數，它們的不同點是類函數有一個隱形參數cls可以用來獲取類信息，而靜態函數沒有改參數。
靜態函數使用裝飾器@staticmethod定義，類函數使用 裝飾器@classmethod 定義。
'''
#靜態函數和類函數的代碼示例
class MyClass(object):
message = "Hello, Developer."
def show(self):
print self.message
print "Here is %s in %s !" % (self.name, self.color)
@staticmethod
def printMessage():
print "print Message is called"
print MyClass.message
@classmethod
def createObj(cls, name, color):
print "Object will be created: %s(%s, %s)" % (cls.__name__, name, color)
return cls(name, color)
def __init__(self, name = "unset", color = "black" ):
print "Constructor is called with params: ", name, " ", color
self.name = name
self.color = color
def __del__(self):
print "Destructor is called for %s !" % self.name
MyClass.printMessage()
inst = MyClass.createObj("Toby", "Red")
print inst.message
del inst
print
print '''
封裝性，是面向讀象編程的重要特點，python也提供了不讓外部看到成員吟唱起來的私有成員機制。
但與大多數編程語言用public,private關鍵字表達可見範圍的方法不同，python指定變量名格式的方法定義私有成員,以雙下劃線__開始命名的成員都是是有成員變量。
'''
#封裝，私有成員示例代碼
class MyClass(object):
def __init__(self, name = "unset", color = "black"):
print "Constructor is called with params: ", name, " ", color
self.__name = name
self.__color = color
def __del__(self):
print "Destructor is called for %s!" % self.__name
inst = MyClass("Jojo", "White")
del inst
print '''
繼承，類之間的繼承是面向對象設計的重要方法，通過繼承可以簡化代碼和優化設計模式。
python類在定義時，可以在小括號中指定基類，所有python類都是object類型的子類，語法如下：
class BaseClass(object): #父類定義
block_class
class SubClass(BaseClass): #子類定義
block_class
子類除了具備自己的 block_class 中定義的特性，還從父類繼承了非私有特性。
在子類的析構函數中調用基類的析構函數，是一種比較好的方法，但這樣可能導致父類資源不能如期被釋放。
'''
#繼承，子類繼承父類示例
class Base(object):
def __init__(self):
print "Constructor fo Base is called !"
def __del__(self):
print "Destructor of Base is called !"
def move(self):
print "move called in Base !"
class SubA(Base):
def __init__(self):
print "Constructor of subA is called ! "
def move(self):
print "move called in subA ! "
class SubB(Base):
def __del__(self):
print "Destructor of SubB is called ! "
super(SubB, self).__del__()
instA = SubA()
instA.move()
del instA
print "-----------------------"
instB = SubB()
instB.move()
del instB
print
print "python中允許類的多繼承，也就是一個子類可以有多個基類。"
#一個子類，繼承多個父類示例
class BaseA(object):
def move(self):
print "move called in BaseA ! "
class BaseB(object):
def move(self):
print "move called in BaseB ! "
class BaseC(BaseA):
def move(self):
print "move called in BaseC ! "
class Sub(BaseC, BaseB):
pass
inst = Sub()
inst.move()
該腳本執行結果如下：
# python try.py 異常處理是用於處理軟件或信息系統中出現的異常狀況的一種機制，及超出程序正常執行流程的某些特殊條件。 在當前主流的編程語言的錯誤處理機制中，異常處理逐步替代了error code錯誤的處理方式，異常處理分離了接收和處理錯誤代碼。 這個功能理清編程思路，使代碼的可讀性增強，方便維護者閱讀和理解。 異常處理，有稱錯誤處理，提供了程序運行時出現的任何意外或異常情況的方法。 python異常處理使用try,catch,else,finally等關鍵字來嘗試可能未成功的操作，處理失敗及正常情況，在事後清理資源。 python異常捕捉及處理的語法如下： #可能會發生異常的程序塊 try: block_try #第1種except形式 except Exception1: block_when_exception1_happen #第2種except形式 except (Exception2, Exception3, Exception4): block_when_exception2_or_3_or_4_happen #第3種except形式 except Exception5, variance block_when_exception5_happen #第4種except形式 except (Exception6, Exception7),variance block_when_exception6_or_7_happen #第5種except形式 except: blok_for_all_other_exceptions #當沒有出現異常情況時的處理 else: block_for_no_exceptions #無論是否出現異常，最後要做的處理 finally: block_anyway 異常處理規則分爲四部分： 可能產生異常的代碼，寫在try塊中，try塊中發生異常，則try塊剩餘的代碼被終止； 異常判斷和發生時的代碼，寫在except中，具有有5種形式： 1是一種異常發生時，執行except塊內代碼；2是捕獲多種異常，執行代碼；3是捕獲的異常可以轉換爲變量；4是捕獲多種異常轉換爲變量；5是捕獲任何異常； 每種except捕獲形式，都可以定義多次，系統會逐個檢查，但有一個滿足條件時，執行except塊，其他的不再檢查和執行，類似於多個if-else條件； else是可選模塊，定義如果沒有發生異常時，需要做的處理； finally是可選模塊，無論try模塊是否發生異常，都會執行這裏的代碼； 總結一下，try模塊是程序對象，except是異常捕獲提交及應對，else是沒有異常時的處理，finally是最後必定執行的內容，與是否出現異常無關。 Exception happened Process finished! Exception happened list index out of range Process finished! 除了系統預定義的異常，還可以定義自己的特定邏輯異常。 自己定義異常，建立一個繼承系統異常的子類，並且在需要引發該異常時用raise語句拋出該異常。 **********Start of main()********** I'm a self-defined Error! 面向讀象編程，與面向過程編程，函數式編程的特點是： 面向過程：根據業務邏輯從上到下寫壘代碼 函數式：將某功能代碼封裝到函數中，日後便無需重複編寫，僅調用函數即可 面向對象：對函數進行分類和封裝，讓開發“更快更好更強...” 面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。 類就是一個模板，模板裏可以包含多個函數，函數裏實現一些功能 對象則是根據模板創建的實例，通過實例對象可以執行類中的函數 面向對象的三大特性是指：封裝、繼承和多態。 面向對象是中程序設計規範，也是一種程序開發方法。python即可支持函數式編程，又可以支持面向對象編程，面向對象編程可以實現函數式編程的功能，函數式編程則不一定。 一般能夠使用面向對象編程，就儘量使用面向對象編程來實現。有的高級函數，如C#和Java只支持面向對象編程，不支持函數式編程。 面向對象，對象是指類的實例，類是創建對象的模板，一個類可以創建多個對象，每個對象都是類類型的一個變量；創建對象的過程，也叫作類的實例化。 面向對象編程中的主要概念有： 類 class：定義了一個事物抽象的特點。類定義了事物的屬性和它可以做到的行爲，一個類中可以有成員函數和成員變量，在面向讀象中，成員函數叫方法，成員變量叫屬性； 對象 object：是類的實例，每個類可以有若干個被實例化的對象。在OS中，熊給讀象分配內存，不會給類分配內存； 繼承 inheritance：是指通過一個已有的類（父類）定義另外一個類（子類），子類共享父類開放的屬性和方法。子類的對象是一個子類的實例，還是父類的一個實例。 封裝性 encapsulation：封裝性是指在定義時，可以將不能或不需要其他類知道的成員定義成私有成員，而只公開需要使用的成員，以達到信息隱藏和簡化的作用。 多態性 polymorphism：是指同一方法作用於不同的讀象，可以有不同的解釋，產生不同的執行結果，在實現上，多態性是孕婦開發者將父對象的變量設置爲對子對象的引用，賦值之後，父對象變量就可以根據當前的賦值給子對象的特性以不同方式運作。 隨着面向對象編程OOP的普及，面向對象涉及OOD也逐漸成熟，形成了以UML爲代表的標準建模語言。 UML是一個支持模型化和軟件系統開發的圖形化語言，爲軟件開發所有階段提供了模型化和可視化支持，包括有需求分析到規格，再到構造和配置的所有階段。 類和讀象是面向對象編程的基礎，通過在類名後面加小括號可以直接實例化類來獲得讀象變量，使用對象變量可以訪問成員函數和成員變量。在構造函數中不能有返回值。 Hello, Developer. Good Morning! Good Morning! 構造函數是一種特殊的類成員方法，主要用來在創建對象時，初始化對象，爲對象成員賦初始值。python中構造函數用 __init__命名，爲類添加一個構造方法，實例一個對象。 Hello, Developer. Constructor is called with params: unset black Hello, Developer. Constructor is called with params: David black Hello, Developer. Constructor is called with params: Lisa Yellow Hello, Developer. Constructor is called with params: unset Green Hello, Developer. 析構函數，是構造函數的反向函數，在銷燬釋放對象時，調用析構函數。析構函數往往做清理善後工作，例如數據庫連接，可以用析構函數是否對數據庫資源的佔用。 python中爲類定義析構函數的方法是在類中定義一個 __del__ 的沒有返回值和參數的函數。 與Java類似，python解釋器的堆中存儲這正在運行程序鎖建立的對象，不需要形式釋放；如果需要顯示銷燬對象，就使用del關鍵字。 Constructor is called with params: unset black Hello, Developer. Constructor is called with params: David black Hello, Developer. Destructor is called! Destructor is called! Constructor is called with params: Lisa Yellow Hello, Developer. Destructor is called! 類中有共享成員變量，如上面類中的message。如果要定義每個對象自己的成員變量，就要在構造函數中定義self引用的變量，即實例成員變量。 Constructor is called with params : David black Hello, Developer. Here is David in black! Color of inst2 is black Constructor is called with params : Lisa Yellow Hello, Developer. Here is Lisa in Yellow! Name of inst3 is Lisa Destructor is called for David! Destructor is called for Lisa! 訪問類時，類成員函數與實例綁定，只能通過對象訪問而不能通過類名訪問。 python中支持兩種基於類名訪問成員的函數：靜態函數和類函數，它們的不同點是類函數有一個隱形參數cls可以用來獲取類信息，而靜態函數沒有改參數。 靜態函數使用裝飾器@staticmethod定義，類函數使用 裝飾器@classmethod 定義。 print Message is called Hello, Developer. Object will be created: MyClass(Toby, Red) Constructor is called with params: Toby Red Hello, Developer. Destructor is called for Toby ! 封裝性，是面向讀象編程的重要特點，python也提供了不讓外部看到成員吟唱起來的私有成員機制。 但與大多數編程語言用public,private關鍵字表達可見範圍的方法不同，python指定變量名格式的方法定義私有成員,以雙下劃線__開始命名的成員都是是有成員變量。 Constructor is called with params: Jojo White Destructor is called for Jojo! 繼承，類之間的繼承是面向對象設計的重要方法，通過繼承可以簡化代碼和優化設計模式。 python類在定義時，可以在小括號中指定基類，所有python類都是object類型的子類，語法如下： class BaseClass(object): #父類定義 block_class class SubClass(BaseClass): #子類定義 block_class 子類除了具備自己的 block_class 中定義的特性，還從父類繼承了非私有特性。 在子類的析構函數中調用基類的析構函數，是一種比較好的方法，但這樣可能導致父類資源不能如期被釋放。 Constructor of subA is called ! move called in subA ! Destructor of Base is called ! ----------------------- Constructor fo Base is called ! move called in Base ! Destructor of SubB is called ! Destructor of Base is called ! python中允許類的多繼承，也就是一個子類可以有多個基類。 move called in BaseC !