溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇文章給大家分享的是有關怎樣進行python異常處理和面向對象編程的分析，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。
異常處理和面向對象編程，是python編程中，比較重要的基礎。在實際生產編程設計和開發(fā)中，異常處理和面向讀象都是必須在設計和開發(fā)過程中充分考慮的。
對于python開發(fā)和面向對象這兩部分基礎，用一個python程序進行封裝說明，結果如下：
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
#################
#異常處理
#################
print '''
異常處理是用于處理軟件或信息系統(tǒng)中出現(xiàn)的異常狀況的一種機制，及超出程序正常執(zhí)行流程的某些特殊條件。
在當前主流的編程語言的錯誤處理機制中，異常處理逐步替代了error code錯誤的處理方式，異常處理分離了接收和處理錯誤代碼。
這個功能理清編程思路，使代碼的可讀性增強，方便維護者閱讀和理解。
'''
print
print '''
異常處理，有稱錯誤處理，提供了程序運行時出現(xiàn)的任何意外或異常情況的方法。
python異常處理使用try,catch,else,finally等關鍵字來嘗試可能未成功的操作，處理失敗及正常情況，在事后清理資源。
python異常捕捉及處理的語法如下：
#可能會發(fā)生異常的程序塊
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
#當沒有出現(xiàn)異常情況時的處理
else:
block_for_no_exceptions
#無論是否出現(xiàn)異常，最后要做的處理
finally:
block_anyway
'''
print
print '''
異常處理規(guī)則分為四部分：
可能產生異常的代碼，寫在try塊中，try塊中發(fā)生異常，則try塊剩余的代碼被終止；
異常判斷和發(fā)生時的代碼，寫在except中，具有有5種形式：
1是一種異常發(fā)生時，執(zhí)行except塊內代碼；2是捕獲多種異常，執(zhí)行代碼；3是捕獲的異?？梢赞D換為變量；4是捕獲多種異常轉換為變量；5是捕獲任何異常；
每種except捕獲形式，都可以定義多次，系統(tǒng)會逐個檢查，但有一個滿足條件時，執(zhí)行except塊，其他的不再檢查和執(zhí)行，類似于多個if-else條件；
else是可選模塊，定義如果沒有發(fā)生異常時，需要做的處理；
finally是可選模塊，無論try模塊是否發(fā)生異常，都會執(zhí)行這里的代碼；
總結一下，try模塊是程序對象，except是異常捕獲提交及應對，else是沒有異常時的處理，finally是最后必定執(zhí)行的內容，與是否出現(xiàn)異常無關。
'''
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 '''
除了系統(tǒng)預定義的異常，還可以定義自己的特定邏輯異常。
自己定義異常，建立一個繼承系統(tǒng)異常的子類，并且在需要引發(fā)該異常時用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 '''
面向讀象編程，與面向過程編程，函數(shù)式編程的特點是：
面向過程：根據業(yè)務邏輯從上到下寫壘代碼
函數(shù)式：將某功能代碼封裝到函數(shù)中，日后便無需重復編寫，僅調用函數(shù)即可
面向對象：對函數(shù)進行分類和封裝，讓開發(fā)“更快更好更強...”
面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現(xiàn)，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。
類就是一個模板，模板里可以包含多個函數(shù)，函數(shù)里實現(xiàn)一些功能
對象則是根據模板創(chuàng)建的實例，通過實例對象可以執(zhí)行類中的函數(shù)
面向對象的三大特性是指：封裝、繼承和多態(tài)。
'''
print
print '''
面向對象是中程序設計規(guī)范，也是一種程序開發(fā)方法。python即可支持函數(shù)式編程，又可以支持面向對象編程，面向對象編程可以實現(xiàn)函數(shù)式編程的功能，函數(shù)式編程則不一定。
一般能夠使用面向對象編程，就盡量使用面向對象編程來實現(xiàn)。有的高級函數(shù)，如C#和Java只支持面向對象編程，不支持函數(shù)式編程。
面向對象，對象是指類的實例，類是創(chuàng)建對象的模板，一個類可以創(chuàng)建多個對象，每個對象都是類類型的一個變量；創(chuàng)建對象的過程，也叫作類的實例化。
面向對象編程中的主要概念有：
類 class：定義了一個事物抽象的特點。類定義了事物的屬性和它可以做到的行為，一個類中可以有成員函數(shù)和成員變量，在面向讀象中，成員函數(shù)叫方法，成員變量叫屬性；
對象 object：是類的實例，每個類可以有若干個被實例化的對象。在OS中，熊給讀象分配內存，不會給類分配內存；
繼承 inheritance：是指通過一個已有的類（父類）定義另外一個類（子類），子類共享父類開放的屬性和方法。子類的對象是一個子類的實例，還是父類的一個實例。
封裝性 encapsulation：封裝性是指在定義時，可以將不能或不需要其他類知道的成員定義成私有成員，而只公開需要使用的成員，以達到信息隱藏和簡化的作用。
多態(tài)性 polymorphism：是指同一方法作用于不同的讀象，可以有不同的解釋，產生不同的執(zhí)行結果，在實現(xiàn)上，多態(tài)性是孕婦開發(fā)者將父對象的變量設置為對子對象的引用，賦值之后，父對象變量就可以根據當前的賦值給子對象的特性以不同方式運作。
隨著面向對象編程OOP的普及，面向對象涉及OOD也逐漸成熟，形成了以UML為代表的標準建模語言。
UML是一個支持模型化和軟件系統(tǒng)開發(fā)的圖形化語言，為軟件開發(fā)所有階段提供了模型化和可視化支持，包括有需求分析到規(guī)格，再到構造和配置的所有階段。
'''
print
print "類和讀象是面向對象編程的基礎，通過在類名后面加小括號可以直接實例化類來獲得讀象變量，使用對象變量可以訪問成員函數(shù)和成員變量。在構造函數(shù)中不能有返回值。"
#定義一個類
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 "構造函數(shù)是一種特殊的類成員方法，主要用來在創(chuàng)建對象時，初始化對象，為對象成員賦初始值。python中構造函數(shù)用 __init__命名，為類添加一個構造方法，實例一個對象。"
#定義類，增加構造函數(shù)示例
class MyClass(object):
message = 'Hello, Developer.'
def show(self):
print self.message
def _init__(self):
print "Constructor is called"
inst = MyClass()
inst.show()
#用默認參數(shù)的方式，實現(xiàn)多種方式構造對象
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 '''
析構函數(shù)，是構造函數(shù)的反向函數(shù)，在銷毀釋放對象時，調用析構函數(shù)。析構函數(shù)往往做清理善后工作，例如數(shù)據庫連接，可以用析構函數(shù)是否對數(shù)據庫資源的占用。
python中為類定義析構函數(shù)的方法是在類中定義一個 __del__ 的沒有返回值和參數(shù)的函數(shù)。
與Java類似，python解釋器的堆中存儲這正在運行程序鎖建立的對象，不需要形式釋放；如果需要顯示銷毀對象，就使用del關鍵字。
'''
#創(chuàng)建類，調用析構函數(shù)示例
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。如果要定義每個對象自己的成員變量，就要在構造函數(shù)中定義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 '''
訪問類時，類成員函數(shù)與實例綁定，只能通過對象訪問而不能通過類名訪問。
python中支持兩種基于類名訪問成員的函數(shù)：靜態(tài)函數(shù)和類函數(shù)，它們的不同點是類函數(shù)有一個隱形參數(shù)cls可以用來獲取類信息，而靜態(tài)函數(shù)沒有改參數(shù)。
靜態(tài)函數(shù)使用裝飾器@staticmethod定義，類函數(shù)使用 裝飾器@classmethod 定義。
'''
#靜態(tài)函數(shù)和類函數(shù)的代碼示例
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也提供了不讓外部看到成員吟唱起來的私有成員機制。
但與大多數(shù)編程語言用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 '''
繼承，類之間的繼承是面向對象設計的重要方法，通過繼承可以簡化代碼和優(yōu)化設計模式。
python類在定義時，可以在小括號中指定基類，所有python類都是object類型的子類，語法如下：
class BaseClass(object): #父類定義
block_class
class SubClass(BaseClass): #子類定義
block_class
子類除了具備自己的 block_class 中定義的特性，還從父類繼承了非私有特性。
在子類的析構函數(shù)中調用基類的析構函數(shù)，是一種比較好的方法，但這樣可能導致父類資源不能如期被釋放。
'''
#繼承，子類繼承父類示例
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()
該腳本執(zhí)行結果如下：
# python try.py
異常處理是用于處理軟件或信息系統(tǒng)中出現(xiàn)的異常狀況的一種機制，及超出程序正常執(zhí)行流程的某些特殊條件。
在當前主流的編程語言的錯誤處理機制中，異常處理逐步替代了error code錯誤的處理方式，異常處理分離了接收和處理錯誤代碼。
這個功能理清編程思路，使代碼的可讀性增強，方便維護者閱讀和理解。
異常處理，有稱錯誤處理，提供了程序運行時出現(xiàn)的任何意外或異常情況的方法。
python異常處理使用try,catch,else,finally等關鍵字來嘗試可能未成功的操作，處理失敗及正常情況，在事后清理資源。
python異常捕捉及處理的語法如下：
#可能會發(fā)生異常的程序塊
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
#當沒有出現(xiàn)異常情況時的處理
else:
block_for_no_exceptions
#無論是否出現(xiàn)異常，最后要做的處理
finally:
block_anyway
異常處理規(guī)則分為四部分：
可能產生異常的代碼，寫在try塊中，try塊中發(fā)生異常，則try塊剩余的代碼被終止；
異常判斷和發(fā)生時的代碼，寫在except中，具有有5種形式：
1是一種異常發(fā)生時，執(zhí)行except塊內代碼；2是捕獲多種異常，執(zhí)行代碼；3是捕獲的異?？梢赞D換為變量；4是捕獲多種異常轉換為變量；5是捕獲任何異常；
每種except捕獲形式，都可以定義多次，系統(tǒng)會逐個檢查，但有一個滿足條件時，執(zhí)行except塊，其他的不再檢查和執(zhí)行，類似于多個if-else條件；
else是可選模塊，定義如果沒有發(fā)生異常時，需要做的處理；
finally是可選模塊，無論try模塊是否發(fā)生異常，都會執(zhí)行這里的代碼；
總結一下，try模塊是程序對象，except是異常捕獲提交及應對，else是沒有異常時的處理，finally是最后必定執(zhí)行的內容，與是否出現(xiàn)異常無關。
Exception happened
Process
Exception happened
list index out of range
Process
除了系統(tǒng)預定義的異常，還可以定義自己的特定邏輯異常。
自己定義異常，建立一個繼承系統(tǒng)異常的子類，并且在需要引發(fā)該異常時用raise語句拋出該異常。
以上就是怎樣進行python異常處理和面向對象編程的分析，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業(yè)資訊頻道。
免責聲明：本站發(fā)布的內容（圖片、視頻和文字）以原創(chuàng)、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯(lián)系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
