python物件導向

標籤：限制   使用   執行個體變數   elf   錯誤   ted   另一個   私人變數   traceback   

物件導向編程——Object Oriented Programming，簡稱OOP，是一種程式設計思想。OOP把對象作為程式的基本單元，一個對象包含了資料和操作資料的函數。

面向過程的程式設計把電腦程式視為一系列的命令集合，即一組函數的順序執行。為了簡化程式設計，面向過程把函數繼續切分為子函數，即把大塊函數通過切割成小塊函數來降低系統的複雜度。

而物件導向的程式設計把電腦程式視為一組對象的集合，而每個對象都可以接收其他對象發過來的訊息，並處理這些訊息，電腦程式的執行就是一系列訊息在各個對象之間傳遞。

在python中萬物皆對象，包括所有的資料類型，同時自己也可以自訂對象。自訂對象資料類型就是物件導向中類（Class）的概念。

舉個例子直觀的看一看面向過程和物件導向實現同一個功能之間的不同

比如我們要處理一個學生的成績表，面向過程會這樣做，首先用一個個dict接受學生的成績

std1 = { ‘name‘: ‘Michael‘, ‘score‘: 98 }std2 = { ‘name‘: ‘Bob‘, ‘score‘: 81 }

然後我們要列印學產生績

def print_score(std):    print(‘%s: %s‘ % (std[‘name‘], std[‘score‘]))

如果採用物件導向的程式設計思想，我們首選思考的不是程式的執行流程，而是Student這種資料類型應該被視為一個對象，這個對象擁有name和score這兩個屬性（Property）。如果要列印一個學生的成績，首先必須建立出這個學生對應的對象，然後，給對象發一個print_score訊息，讓對象自己把自己的資料列印出來。

class Student(object):    def __init__(self, name, score):        self.name = name        self.score = score    def print_score(self):        print(‘%s: %s‘ % (self.name, self.score))

給對象發訊息實際上就是調用對象對應的關聯函數，我們稱之為對象的方法

bart = Student(‘Bart Simpson‘, 59)lisa = Student(‘Lisa Simpson‘, 87)bart.print_score()lisa.print_score()

類（Class）和執行個體（Instance）

在上面的例子中Student就是一個類，而bart,lisa就是一個個具體的Student執行個體。

牢記類是抽象的模板，比如Student類，而執行個體是根據類建立出來的一個個具體的“對象”，每個對象都擁有相同的方法，但各自的資料可能不同。

在python中定義類是以Class關鍵字定義：

 

Class Student(object):      pass

 Class後面緊接著是類名，即Student，類名通常是大寫開頭的單詞，緊接著是(object)，表示該類是從哪個類繼承下來的，繼承的概念我們先不急，通常，如果沒有合適的繼承類，就使用object類，這是所有類最終都會繼承的類。

當然我們有可能會見到下面這種定義：

 

Class Student:     pass

 

這是經典類，上面的叫新式類，在Python3中都使用新式類，預設不必顯示的寫object,但規範最好都寫上。

定義好了Student類，就可以根據Student類建立出Student的執行個體，建立執行個體是通過類名+()實現的：

>>> bart = Student()>>> bart<__main__.Student object at 0x10a67a590>>>> Student<class ‘__main__.Student‘>

 變數bart指向的是一個Student的一個執行個體，後面的0x10a67a590則是記憶體位址，每個Object的記憶體位址都不相同，而Student本身則是一個類。

我們可以 自由的給執行個體變數綁定一個屬性，例如給bart綁定一個name的屬性：

>>> bart.name = ‘Bart Simpson‘>>> bart.name‘Bart Simpson‘

由於類起到模板的作用，我們在建立類時就可以把認為必須要的屬性強制寫進去。通過定義一個__init__方法就可以把name，score綁上去：

class Student(object):    def __init__(self, name, score):        self.name = name        self.score = score

注意到__init__方法的第一個參數永遠是self，表示建立的執行個體本身，因此，在__init__方法內部，就可以把各種屬性綁定到self，因為self就指向建立的執行個體本身。

有了__init__方法，在建立執行個體的時候，就不能傳入空的參數了，必須傳入與__init__方法匹配的參數，但self不需要傳，Python解譯器自己會把執行個體變數傳進去：

>>> bart = Student(‘Bart Simpson‘, 59)>>> bart.name‘Bart Simpson‘>>> bart.score59

和普通的函數相比，在類中定義的函數只有一點不同，就是第一個參數永遠是執行個體變數self，並且，調用時，不用傳遞該參數。除此之外，類的方法和普通函數沒有什麼區別，所以，你仍然可以用預設參數、可變參數、關鍵字參數和命名關鍵字參數。

封裝

物件導向編程最重要的一個特點就是封裝，在上面的Student類中，每個執行個體就擁有各自的name和score這些資料。我們可以通過函數來訪問這些資料，比如列印一個學生的成績：

>>> def print_score(std):...     print(‘%s: %s‘ % (std.name, std.score))...>>> print_score(bart)Bart Simpson: 59

 但是既然Student執行個體本身就已經有了這些資料，要訪問這些資料就沒必要從外部函數訪問了，我們可以直接在Student內部定義訪問資料的函數，這樣就把資料給封裝起來了。這些封裝資料的函數與Student類本身也是關聯的，所以我們也稱之為類的方法：

class Student(object):    def __init__(self, name, score):        self.name = name        self.score = score    def print_score(self):        print(‘%s: %s‘ % (self.name, self.score))

要定義一個方法，除了第一個參數是self外，其他和普通函數一樣。要調用一個方法，只需要在執行個體變數上直接調用，除了self不用傳遞，其他參數正常傳入：

>>> bart.print_score()Bart Simpson: 59

這樣一來，我們從外部看Student類，就只需要知道，建立執行個體需要給出name和score，而如何列印，都是在Student類的內部定義的，這些資料和邏輯被“封裝”起來了，調用很容易，但卻不用知道內部實現的細節。

封裝的另一個好處是可以給Student類增加新的方法，比如get_grade：

class Student(object):    ...    def get_grade(self):        if self.score >= 90:            return ‘A‘        elif self.score >= 60:            return ‘B‘        else:            return ‘C‘

同樣的，get_grade方法可以直接在執行個體變數上調用，不需要知道內部實現細節：

>>> bart.get_grade()‘C‘

所以說，封裝其實就是將對象的屬性和實現細節隱藏起來，不允許外部直接存取，把方法暴露出去，讓方法來操作或訪問這些屬性。

訪問限制

但是，從前面Student類的定義來看，外部代碼還是可以自由地修改一個執行個體的name、score屬性：

>>> bart = Student(‘Bart Simpson‘, 98)>>> bart.score98>>> bart.score = 59>>> bart.score59

如果要讓內部屬性不被外部存取，可以把屬性的名稱前加上兩個底線__，在Python中，執行個體的變數名如果以__開頭，就變成了一個私人變數（private），只有內部可以訪問，外部不能訪問，所以，我們把Student類改一改：

class Student(object):    def __init__(self, name, score):        self.__name = name        self.__score = score    def print_score(self):        print(‘%s: %s‘ % (self.__name, self.__score))

改完後，對於外部代碼來說，沒什麼變動，但是已經無法從外部存取執行個體變數.__name和執行個體變數.__score了：

>>> bart = Student(‘Bart Simpson‘, 98)>>> bart.__nameTraceback (most recent call last):  File "<stdin>", line 1, in <module>AttributeError: ‘Student‘ object has no attribute ‘__name‘

這樣就確保了外部代碼不能隨意修改對象內部的狀態，這樣通過訪問限制的保護，代碼更加健壯。

雙底線開頭的執行個體變數是不是一定不能從外部存取呢？答案是No:

>>> bart._Student__name‘Bart Simpson‘

其實在python中並沒有私人屬性這一說法，‘_’告訴別人我是一個私人屬性，你不要訪問，並沒有一個文法上面的限制，還是能被外部代碼訪問，‘__‘雖然不能被訪問，但是其實是python耍了一個小聰明，把屬性名稱給換了，如.__name換成了.Student.__name。

總的來說就是，Python本身沒有任何機制阻止你幹壞事，一切全靠自覺。

還有一個錯誤的寫法：

>>> bart = Student(‘Bart Simpson‘, 98)>>> bart.get_name()‘Bart Simpson‘>>> bart.__name = ‘New Name‘ # 設定__name變數！>>> bart.__name‘New Name‘　

表面上是修改成功了，其實沒有，因為實際上這個__name變數和class內部的__name變數不是一個變數！內部的__name變數已經被Python解譯器自動改成了_Student__name，而外部代碼給bart新增了一個__name變數。

繼承

在OOP程式設計中，當我們定義一個class的時候，可以從某個現有的class繼承，新的class稱為子類（Subclass），而被繼承的class稱為基類、父類或超類（Base class、Super class）。

比如我們編寫了一個Animal類，並寫了一個talk方法：

 

class Animal(object):    def talk(self):        print(‘Animal is talking‘)

 

 然後我又寫一個Dog和Cat類繼承Animal類：

class Dog(Animal):    passclass Cat(Animal):    pass　　

繼承有什麼好處，最大的好處就是實現了父類的功能：

dog = Dog()cat = Cat()dog.talk()cat.talk()

運行結果如下：Animal is talkingAnimal is talking

繼承的第二個好處需要我們對代碼做一點改進。按理說Dog和Cat在talk()時應該是‘Dog is talking’和‘Cat is talking’，做出如下修改：

class Dog(Animal):    def talk(self):        print(‘Dog is talking‘)class Cat(Animal):    def talk(self):        print(‘Cat is talking‘)

再次運行結果如下：

Dog is talkingCat is talking

 

多態

多態可以說也是繼承的一個好處：當子類和父類都存在相同的talk()方法時，我們說，子類的talk()覆蓋了父類的talk()，在代碼啟動並執行時候，總是會調用子類的。

要理解多態的好處，還需要寫一個例子，這個函數接受一個Animal類型的變數：

 

def talk_twice(animal):
    animal.talk()
    animal.talk()

 

當我們傳入Dog和Cat執行個體時就列印出：

 

dog = Dog()cat = Cat()Animal.talk_twice(dog)Animal.talk_twice(cat)運行結果Dog is talkingDog is talkingCat is talkingCat is talking

 

這樣的好處就是下一次我再定義一個類Pig繼承Animal，不需要對talk_twice()進行修改就可以將Pig的執行個體傳進去。

Python中其實是不支援多態或者說多態基本上用不上，python支援的是‘鴨子模型’，“只要像鴨子一樣走路，叫聲像鴨子的，都是鴨子”：

class Car(object):    def talk(self):        print(‘Car is talking‘)

然後調用talk_twice():

Animal.talk_twice(car)

輸出結果：

Car is talkingCar is talking

對於Python這樣的動態語言來說，則不一定需要傳入Animal類型。我們只需要保證傳入的對象有一個run()方法就可以了。

 

 

python物件導向