面向對象最重要的概念就是類(Class)和實例(Instance),必須牢記類是抽象的模板,比如Student類,而實例是根據類創建出來的一個個具體的“對象”,每個對象都擁有相同的方法,但各自的數據可能不同。
仍以Student類爲例,在Python中,定義類是通過class
關鍵字:
class Student(object):
pass
class
後面緊接着是類名,即Student
,類名通常是大寫開頭的單詞,緊接着是(object)
,表示該類是從哪個類繼承下來的,繼承的概念我們後面再講,通常,如果沒有合適的繼承類,就使用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.score
59
和普通的函數相比,在類中定義的函數只有一點不同,就是第一個參數永遠是實例變量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
方法可以直接在實例變量上調用,不需要知道內部實現細節:
# -*- coding: utf-8 -*-
lisa = Student('Lisa', 99) bart = Student('Bart', 59) print(lisa.name, lisa.get_grade()) print(bart.name, bart.get_grade())
在Class內部,可以有屬性和方法,而外部代碼可以通過直接調用實例變量的方法來操作數據,這樣,就隱藏了內部的複雜邏輯。
但是,從前面Student類的定義來看,外部代碼還是可以自由地修改一個實例的name
、score
屬性:
>>> bart = Student('Bart Simpson', 59)
>>> bart.score
59
>>> bart.score = 99
>>> bart.score
99
如果要讓內部屬性不被外部訪問,可以把屬性的名稱前加上兩個下劃線__
,在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', 59)
>>> bart.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
這樣就確保了外部代碼不能隨意修改對象內部的狀態,這樣通過訪問限制的保護,代碼更加健壯。
但是如果外部代碼要獲取name和score怎麼辦?可以給Student類增加get_name
和get_score
這樣的方法:
class Student(object):
...
def get_name(self):
return self.__name
def get_score(self):
return self.__score
如果又要允許外部代碼修改score怎麼辦?可以再給Student類增加set_score
方法:
class Student(object):
...
def set_score(self, score):
self.__score = score
你也許會問,原先那種直接通過bart.score = 99
也可以修改啊,爲什麼要定義一個方法大費周折?因爲在方法中,可以對參數做檢查,避免傳入無效的參數:
class Student(object):
...
def set_score(self, score):
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score')
需要注意的是,在Python中,變量名類似__xxx__
的,也就是以雙下劃線開頭,並且以雙下劃線結尾的,是特殊變量,特殊變量是可以直接訪問的,不是private變量,所以,不能用__name__
、__score__
這樣的變量名。
有些時候,你會看到以一個下劃線開頭的實例變量名,比如_name
,這樣的實例變量外部是可以訪問的,但是,按照約定俗成的規定,當你看到這樣的變量時,意思就是,“雖然我可以被訪問,但是,請把我視爲私有變量,不要隨意訪問”。
雙下劃線開頭的實例變量是不是一定不能從外部訪問呢?其實也不是。不能直接訪問__name
是因爲Python解釋器對外把__name
變量改成了_Student__name
,所以,仍然可以通過_Student__name
來訪問__name
變量:
>>> bart._Student__name
'Bart Simpson'
但是強烈建議你不要這麼幹,因爲不同版本的Python解釋器可能會把__name
改成不同的變量名。
總的來說就是,Python本身沒有任何機制阻止你幹壞事,一切全靠自覺。
最後注意下面的這種錯誤寫法:
>>> bart = Student('Bart Simpson', 59)
>>> bart.get_name()
'Bart Simpson'
>>> bart.__name = 'New Name' # 設置__name變量!
>>> bart.__name
'New Name'
表面上看,外部代碼“成功”地設置了__name
變量,但實際上這個__name
變量和class內部的__name
變量不是一個變量!內部的__name
變量已經被Python解釋器自動改成了_Student__name
,而外部代碼給bart
新增了一個__name
變量。不信試試:
>>> bart.get_name() # get_name()內部返回self.__name
'Bart Simpson'
在OOP程序設計中,當我們定義一個class的時候,可以從某個現有的class繼承,新的class稱爲子類(Subclass),而被繼承的class稱爲基類、父類或超類(Base class、Super class)。
比如,我們已經編寫了一個名爲Animal
的class,有一個run()
方法可以直接打印:
class Animal(object):
def run(self):
print('Animal is running...')
當我們需要編寫Dog
和Cat
類時,就可以直接從Animal
類繼承:
class Dog(Animal):
pass
class Cat(Animal):
pass
對於Dog
來說,Animal
就是它的父類,對於Animal
來說,Dog
就是它的子類。Cat
和Dog
類似。
繼承有什麼好處?最大的好處是子類獲得了父類的全部功能。由於Animial
實現了run()
方法,因此,Dog
和Cat
作爲它的子類,什麼事也沒幹,就自動擁有了run()
方法:
dog = Dog()
dog.run()
cat = Cat()
cat.run()
運行結果如下:
Animal is running...
Animal is running...
當然,也可以對子類增加一些方法,比如Dog類:
class Dog(Animal):
def run(self):
print('Dog is running...')
def eat(self):
print('Eating meat...')
繼承的第二個好處需要我們對代碼做一點改進。你看到了,無論是Dog
還是Cat
,它們run()
的時候,顯示的都是Animal is running...
,符合邏輯的做法是分別顯示Dog is running...
和Cat is running...
,因此,對Dog
和Cat
類改進如下:
class Dog(Animal):
def run(self):
print('Dog is running...')
class Cat(Animal):
def run(self):
print('Cat is running...')
再次運行,結果如下:
Dog is running...
Cat is running...
當子類和父類都存在相同的run()
方法時,我們說,子類的run()
覆蓋了父類的run()
,在代碼運行的時候,總是會調用子類的run()
。這樣,我們就獲得了繼承的另一個好處:多態。
要理解什麼是多態,我們首先要對數據類型再作一點說明。當我們定義一個class的時候,我們實際上就定義了一種數據類型。我們定義的數據類型和Python自帶的數據類型,比如str、list、dict沒什麼兩樣:
a = list() # a是list類型
b = Animal() # b是Animal類型
c = Dog() # c是Dog類型
判斷一個變量是否是某個類型可以用isinstance()
判斷:
>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True
看來a
、b
、c
確實對應着list
、Animal
、Dog
這3種類型。
但是等等,試試:
>>> isinstance(c, Animal)
True
看來c
不僅僅是Dog
,c
還是Animal
!
不過仔細想想,這是有道理的,因爲Dog
是從Animal
繼承下來的,當我們創建了一個Dog
的實例c
時,我們認爲c
的數據類型是Dog
沒錯,但c
同時也是Animal
也沒錯,Dog
本來就是Animal
的一種!
所以,在繼承關係中,如果一個實例的數據類型是某個子類,那它的數據類型也可以被看做是父類。但是,反過來就不行:
>>> b = Animal()
>>> isinstance(b, Dog)
False
Dog
可以看成Animal
,但Animal
不可以看成Dog
。
要理解多態的好處,我們還需要再編寫一個函數,這個函數接受一個Animal
類型的變量:
def run_twice(animal):
animal.run()
animal.run()
當我們傳入Animal
的實例時,run_twice()
就打印出:
>>> run_twice(Animal())
Animal is running...
Animal is running...
當我們傳入Dog
的實例時,run_twice()
就打印出:
>>> run_twice(Dog())
Dog is running...
Dog is running...
當我們傳入Cat
的實例時,run_twice()
就打印出:
>>> run_twice(Cat())
Cat is running...
Cat is running...
看上去沒啥意思,但是仔細想想,現在,如果我們再定義一個Tortoise
類型,也從Animal
派生:
class Tortoise(Animal):
def run(self):
print('Tortoise is running slowly...')
當我們調用run_twice()
時,傳入Tortoise
的實例:
>>> run_twice(Tortoise())
Tortoise is running slowly...
Tortoise is running slowly...
你會發現,新增一個Animal
的子類,不必對run_twice()
做任何修改,實際上,任何依賴Animal
作爲參數的函數或者方法都可以不加修改地正常運行,原因就在於多態。
多態的好處就是,當我們需要傳入Dog
、Cat
、Tortoise
……時,我們只需要接收Animal
類型就可以了,因爲Dog
、Cat
、Tortoise
……都是Animal
類型,然後,按照Animal
類型進行操作即可。由於Animal
類型有run()
方法,因此,傳入的任意類型,只要是Animal
類或者子類,就會自動調用實際類型的run()
方法,這就是多態的意思:
對於一個變量,我們只需要知道它是Animal
類型,無需確切地知道它的子類型,就可以放心地調用run()
方法,而具體調用的run()
方法是作用在Animal
、Dog
、Cat
還是Tortoise
對象上,由運行時該對象的確切類型決定,這就是多態真正的威力:調用方只管調用,不管細節,而當我們新增一種Animal
的子類時,只要確保run()
方法編寫正確,不用管原來的代碼是如何調用的。這就是著名的“開閉”原則:
對擴展開放:允許新增Animal
子類;
對修改封閉:不需要修改依賴Animal
類型的run_twice()
等函數。
繼承還可以一級一級地繼承下來,就好比從爺爺到爸爸、再到兒子這樣的關係。而任何類,最終都可以追溯到根類object,這些繼承關係看上去就像一顆倒着的樹。比如如下的繼承樹:
┌───────────────┐
│ object │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Animal │ │ Plant │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Cat │ │ Tree │ │ Flower │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
靜態語言 vs 動態語言
對於靜態語言(例如Java)來說,如果需要傳入Animal
類型,則傳入的對象必須是Animal
類型或者它的子類,否則,將無法調用run()
方法。
對於Python這樣的動態語言來說,則不一定需要傳入Animal
類型。我們只需要保證傳入的對象有一個run()
方法就可以了:
class Timer(object):
def run(self):
print('Start...')
這就是動態語言的“鴨子類型”,它並不要求嚴格的繼承體系,一個對象只要“看起來像鴨子,走起路來像鴨子”,那它就可以被看做是鴨子。
Python的“file-like object“就是一種鴨子類型。對真正的文件對象,它有一個read()
方法,返回其內容。但是,許多對象,只要有read()
方法,都被視爲“file-like object“。許多函數接收的參數就是“file-like object“,你不一定要傳入真正的文件對象,完全可以傳入任何實現了read()
方法的對象。
小結
繼承可以把父類的所有功能都直接拿過來,這樣就不必重零做起,子類只需要新增自己特有的方法,也可以把父類不適合的方法覆蓋重寫。
動態語言的鴨子類型特點決定了繼承不像靜態語言那樣是必須的。