數據封裝、繼承和多態只是面向對象程序設計中最基礎的3個概念。在Python中,面向對象還有很多高級特性,允許我們寫出非常強大的功能。
我們會討論多重繼承、定製類、元類等概念。
使用__slots__
正常情況下,當我們定義了一個class,創建了一個class的實例後,我們可以給該實例綁定任何屬性和方法,這就是動態語言的靈活性。先定義class:
class Student(object):
pass
然後,嘗試給實例綁定一個屬性:
>>> s = Student()
>>> s.name = 'Michael' # 動態給實例綁定一個屬性
>>> print(s.name)
Michael
還可以嘗試給實例綁定一個方法:
>>> def set_age(self, age): # 定義一個函數作爲實例方法
... self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 給實例綁定一個方法
>>> s.set_age(25) # 調用實例方法
>>> s.age # 測試結果
25
但是,給一個實例綁定的方法,對另一個實例是不起作用的:
>>> s2 = Student() # 創建新的實例
>>> s2.set_age(25) # 嘗試調用方法
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'set_age'
爲了給所有實例都綁定方法,可以給class綁定方法:
>>> def set_score(self, score):
... self.score = score
...
>>> Student.set_score = set_score
給class綁定方法後,所有實例均可調用:
>>> s.set_score(100)
>>> s.score
100
>>> s2.set_score(99)
>>> s2.score
99
通常情況下,上面的set_score
方法可以直接定義在class中,但動態綁定允許我們在程序運行的過程中動態給class加上功能,這在靜態語言中很難實現。
使用__slots__
但是,如果我們想要限制實例的屬性怎麼辦?比如,只允許對Student實例添加name
和age
屬性。
爲了達到限制的目的,Python允許在定義class的時候,定義一個特殊的__slots__
變量,來限制該class實例能添加的屬性:
class Student(object):
__slots__ = ('name', 'age') # 用tuple定義允許綁定的屬性名稱
然後,我們試試:
>>> s = Student() # 創建新的實例
>>> s.name = 'Michael' # 綁定屬性'name'
>>> s.age = 25 # 綁定屬性'age'
>>> s.score = 99 # 綁定屬性'score'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'score'
由於'score'
沒有被放到__slots__
中,所以不能綁定score
屬性,試圖綁定score
將得到AttributeError
的錯誤。
使用__slots__
要注意,__slots__
定義的屬性僅對當前類實例起作用,對繼承的子類是不起作用的:
>>> class GraduateStudent(Student):
... pass
...
>>> g = GraduateStudent()
>>> g.score = 9999
除非在子類中也定義__slots__
,這樣,子類實例允許定義的屬性就是自身的__slots__
加上父類的__slots__
。
使用@property
在綁定屬性時,如果我們直接把屬性暴露出去,雖然寫起來很簡單,但是,沒辦法檢查參數,導致可以把成績隨便改:
s = Student()
s.score = 9999
這顯然不合邏輯。爲了限制score的範圍,可以通過一個set_score()
方法來設置成績,再通過一個get_score()
來獲取成績,這樣,在set_score()
方法裏,就可以檢查參數:
class Student(object):
def get_score(self):
return self._score
def set_score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
現在,對任意的Student實例進行操作,就不能隨心所欲地設置score了:
>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!
但是,上面的調用方法又略顯複雜,沒有直接用屬性這麼直接簡單。(TMD,嫌煩還不先介紹簡單方法
有沒有既能檢查參數,又可以用類似屬性這樣簡單的方式來訪問類的變量呢?對於追求完美的Python程序員來說,這是必須要做到的!
還記得裝飾器(decorator)可以給函數動態加上功能嗎?對於類的方法,裝飾器一樣起作用。Python內置的@property
裝飾器就是負責把一個方法變成屬性調用的:
class Student(object):
@property
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
@property
的實現比較複雜,我們先考察如何使用。把一個getter方法變成屬性,只需要加上@property
就可以了,此時,@property
本身又創建了另一個裝飾器@score.setter
,負責把一個setter方法變成屬性賦值,於是,我們就擁有一個可控的屬性操作:
>>> s = Student()
>>> s.score = 60 # OK,實際轉化爲s.set_score(60)
>>> s.score # OK,實際轉化爲s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!
注意到這個神奇的@property
,我們在對實例屬性操作的時候,就知道該屬性很可能不是直接暴露的,而是通過getter和setter方法來實現的。
還可以定義只讀屬性,只定義getter方法,不定義setter方法就是一個只讀屬性:
class Student(object):
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, value):
self._birth = value
@property
def age(self):
return 2015 - self._birth
上面的birth
是可讀寫屬性,而age
就是一個只讀屬性,因爲age
可以根據birth
和當前時間計算出來。
小結
@property
廣泛應用在類的定義中,可以讓調用者寫出簡短的代碼,同時保證對參數進行必要的檢查,這樣,程序運行時就減少了出錯的可能性。
多重繼承
繼承是面向對象編程的一個重要的方式,因爲通過繼承,子類就可以擴展父類的功能。
回憶一下Animal
類層次的設計,假設我們要實現以下4種動物:
- Dog - 狗狗;
- Bat - 蝙蝠;
- Parrot - 鸚鵡;
- Ostrich - 鴕鳥。
如果按照哺乳動物和鳥類歸類,我們可以設計出這樣的類的層次:
┌───────────────┐
│ Animal │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Mammal │ │ Bird │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Bat │ │ Parrot │ │ Ostrich │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
但是如果按照“能跑”和“能飛”來歸類,我們就應該設計出這樣的類的層次:
┌───────────────┐
│ Animal │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Runnable │ │ Flyable │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Ostrich │ │ Parrot │ │ Bat │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
如果要把上面的兩種分類都包含進來,我們就得設計更多的層次:
- 哺乳類:能跑的哺乳類,能飛的哺乳類;
- 鳥類:能跑的鳥類,能飛的鳥類。
這麼一來,類的層次就複雜了:
┌───────────────┐
│ Animal │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Mammal │ │ Bird │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ MRun │ │ MFly │ │ BRun │ │ BFly │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
│ │ │ │
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Bat │ │ Ostrich │ │ Parrot │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
如果要再增加“寵物類”和“非寵物類”,這麼搞下去,類的數量會呈指數增長,很明顯這樣設計是不行的。
正確的做法是採用多重繼承。首先,主要的類層次仍按照哺乳類和鳥類設計:
class Animal(object):
pass
# 大類:
class Mammal(Animal):
pass
class Bird(Animal):
pass
# 各種動物:
class Dog(Mammal):
pass
class Bat(Mammal):
pass
class Parrot(Bird):
pass
class Ostrich(Bird):
pass
現在,我們要給動物再加上Runnable
和Flyable
的功能,只需要先定義好Runnable
和Flyable
的類:
class Runnable(object):
def run(self):
print('Running...')
class Flyable(object):
def fly(self):
print('Flying...')
對於需要Runnable
功能的動物,就多繼承一個Runnable
,例如Dog
:
class Dog(Mammal, Runnable):
pass
對於需要Flyable
功能的動物,就多繼承一個Flyable
,例如Bat
:
class Bat(Mammal, Flyable):
pass
通過多重繼承,一個子類就可以同時獲得多個父類的所有功能。
MixIn
在設計類的繼承關係時,通常,主線都是單一繼承下來的,例如,Ostrich
繼承自Bird
。但是,如果需要“混入”額外的功能,通過多重繼承就可以實現,比如,讓Ostrich
除了繼承自Bird
外,再同時繼承Runnable
。這種設計通常稱之爲MixIn。
爲了更好地看出繼承關係,我們把Runnable
和Flyable
改爲RunnableMixIn
和FlyableMixIn
。類似的,你還可以定義出肉食動物CarnivorousMixIn
和植食動物HerbivoresMixIn
,讓某個動物同時擁有好幾個MixIn:
class Dog(Mammal, RunnableMixIn, CarnivorousMixIn):
pass
MixIn的目的就是給一個類增加多個功能,這樣,在設計類的時候,我們優先考慮通過多重繼承來組合多個MixIn的功能,而不是設計多層次的複雜的繼承關係。
Python自帶的很多庫也使用了MixIn。舉個例子,Python自帶了TCPServer
和UDPServer
這兩類網絡服務,而要同時服務多個用戶就必須使用多進程或多線程模型,這兩種模型由ForkingMixIn
和ThreadingMixIn
提供。通過組合,我們就可以創造出合適的服務來。
比如,編寫一個多進程模式的TCP服務,定義如下:
class MyTCPServer(TCPServer, ForkingMixIn):
pass
編寫一個多線程模式的UDP服務,定義如下:
class MyUDPServer(UDPServer, ThreadingMixIn):
pass
如果你打算搞一個更先進的協程模型,可以編寫一個CoroutineMixIn
:
class MyTCPServer(TCPServer, CoroutineMixIn):
pass
這樣一來,我們不需要複雜而龐大的繼承鏈,只要選擇組合不同的類的功能,就可以快速構造出所需的子類。
小結
由於Python允許使用多重繼承,因此,MixIn就是一種常見的設計。
只允許單一繼承的語言(如Java)不能使用MixIn的設計。
定製類
看到類似__slots__
這種形如__xxx__
的變量或者函數名就要注意,這些在Python中是有特殊用途的。
__slots__
我們已經知道怎麼用了,__len__()
方法我們也知道是爲了能讓class作用於len()
函數。
除此之外,Python的class中還有許多這樣有特殊用途的函數,可以幫助我們定製類。
__str__
我們先定義一個Student
類,打印一個實例:
>>> class Student(object):
... def __init__(self, name):
... self.name = name
...
>>> print(Student('Michael'))
<__main__.Student object at 0x109afb190>
怎麼才能打印得好看呢?只需要定義好__str__()
方法,返回一個好看的字符串就可以了:
>>> class Student(object):
... def __init__(self, name):
... self.name = name
... def __str__(self):
... return 'Student object (name: %s)' % self.name
...
>>> print(Student('Michael'))
Student object (name: Michael)
但是細心的朋友會發現直接敲變量不用print
,打印出來的實例還是不好看:
這是因爲直接顯示變量調用的不是__str__()
,而是__repr__()
,兩者的區別是__str__()
返回用戶看到的字符串,而__repr__()
返回程序開發者看到的字符串,也就是說,__repr__()
是爲調試服務的。
解決辦法是再定義一個__repr__()
。但是通常__str__()
和__repr__()
代碼都是一樣的,所以,有個偷懶的寫法:
class Student(object):
def __init__(self, name):
self.name = name
def __str__(self):
return 'Student object (name=%s)' % self.name
__repr__ = __str__
__iter__
如果一個類想被用於for ... in
循環,類似list或tuple那樣,就必須實現一個__iter__()
方法,該方法返回一個迭代對象,然後,Python的for循環就會不斷調用該迭代對象的__next__()
方法拿到循環的下一個值,直到遇到StopIteration
錯誤時退出循環。
我們以斐波那契數列爲例,寫一個Fib類,可以作用於for循環:
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化兩個計數器a,b
def __iter__(self):
return self # 實例本身就是迭代對象,故返回自己
def __next__(self):
self.a, self.b = self.b, self.a + self.b # 計算下一個值
if self.a > 100000: # 退出循環的條件
raise StopIteration()
return self.a # 返回下一個值
現在,試試把Fib實例作用於for循環:
>>> for n in Fib():
... print(n)
...
1
1
2
3
5
...
46368
75025
__getitem__
Fib實例雖然能作用於for循環,看起來和list有點像,但是,把它當成list來使用還是不行,比如,取第5個元素:
>>> Fib()[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'Fib' object does not support indexing
要表現得像list那樣按照下標取出元素,需要實現__getitem__()
方法:
class Fib(object):
def __getitem__(self, n):
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
但是list有個神奇的切片方法:
>>> list(range(100))[5:10]
[5, 6, 7, 8, 9]
對於Fib卻報錯。原因是__getitem__()
傳入的參數可能是一個int,也可能是一個切片對象slice
,所以要做判斷
class Fib(object):
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice): # n是切片
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
現在試試Fib的切片:
>>> f = Fib()
>>> f[0:5]
[1, 1, 2, 3, 5]
>>> f[:10]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
但是沒有對step參數作處理:
>>> f[:10:2]
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
也沒有對負數作處理,所以,要正確實現一個__getitem__()
還是有很多工作要做的。
此外,如果把對象看成dict
,__getitem__()
的參數也可能是一個可以作key的object,例如str
。
與之對應的是__setitem__()
方法,把對象視作list或dict來對集合賦值。最後,還有一個__delitem__()
方法,用於刪除某個元素。
總之,通過上面的方法,我們自己定義的類表現得和Python自帶的list、tuple、dict沒什麼區別,這完全歸功於動態語言的“鴨子類型”,不需要強制繼承某個接口。
__getattr__
正常情況下,當我們調用類的方法或屬性時,如果不存在,就會報錯。比如定義Student
類:
class Student(object):
def __init__(self):
self.name = 'Michael'
調用name
屬性,沒問題,但是,調用不存在的score
屬性,就有問題了:
>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
...
AttributeError: 'Student' object has no attribute 'score'
錯誤信息很清楚地告訴我們,沒有找到score
這個attribute。
要避免這個錯誤,除了可以加上一個score
屬性外,Python還有另一個機制,那就是寫一個__getattr__()
方法,動態返回一個屬性。修改如下:
class Student(object):
def __init__(self):
self.name = 'Michael'
def __getattr__(self, attr):
if attr=='score':
return 99
當調用不存在的屬性時,比如score
,Python解釋器會試圖調用__getattr__(self, 'score')
來嘗試獲得屬性,這樣,我們就有機會返回score
的值:
>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99
返回函數也是完全可以的:
class Student(object):
def __getattr__(self, attr):
if attr=='age':
return lambda: 25
只是調用方式要變爲:
>>> s.age()
25
注意,只有在沒有找到屬性的情況下,才調用__getattr__
,已有的屬性,比如name
,不會在__getattr__
中查找。
此外,注意到任意調用如s.abc
都會返回None
,這是因爲我們定義的__getattr__
默認返回就是None
。要讓class只響應特定的幾個屬性,我們就要按照約定,拋出AttributeError
的錯誤:
class Student(object):
def __getattr__(self, attr):
if attr=='age':
return lambda: 25
raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
這實際上可以把一個類的所有屬性和方法調用全部動態化處理了,不需要任何特殊手段。
這種完全動態調用的特性有什麼實際作用呢?作用就是,可以針對完全動態的情況作調用。
舉個例子:
現在很多網站都搞REST API,比如新浪微博、豆瓣啥的,調用API的URL類似:
- http://api.server/user/friends
- http://api.server/user/timeline/list
如果要寫SDK,給每個URL對應的API都寫一個方法,那得累死,而且,API一旦改動,SDK也要改。
利用完全動態的__getattr__
,我們可以寫出一個鏈式調用:
class Chain(object):
def __init__(self, path=''):
self._path = path
def __getattr__(self, path):
return Chain('%s/%s' % (self._path, path))
def __str__(self):
return self._path
__repr__ = __str__
>>> Chain().status.user.timeline.list
'/status/user/timeline/list'
這樣,無論API怎麼變,SDK都可以根據URL實現完全動態的調用,而且,不隨API的增加而改變!
還有些REST API會把參數放到URL中,比如GitHub的API:
GET /users/:user/repos
調用時,需要把:user
替換爲實際用戶名。如果我們能寫出這樣的鏈式調用:
Chain().users('michael').repos
就可以非常方便地調用API了。有興趣的童鞋可以試試寫出來。
__call__
一個對象實例可以有自己的屬性和方法,當我們調用實例方法時,我們用instance.method()
來調用。能不能直接在實例本身上調用呢?在Python中,答案是肯定的。
任何類,只需要定義一個__call__()
方法,就可以直接對實例進行調用。請看示例:
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
調用方式如下:
>>> s = Student('Michael')
>>> s() # self參數不要傳入
My name is Michael.
__call__()
還可以定義參數。對實例進行直接調用就好比對一個函數進行調用一樣,所以你完全可以把對象看成函數,把函數看成對象,因爲這兩者之間本來就沒啥根本的區別。
如果你把對象看成函數,那麼函數本身其實也可以在運行期動態創建出來,因爲類的實例都是運行期創建出來的,這麼一來,我們就模糊了對象和函數的界限。
那麼,怎麼判斷一個變量是對象還是函數呢?其實,更多的時候,我們需要判斷一個對象是否能被調用,能被調用的對象就是一個Callable
對象,比如函數和我們上面定義的帶有__call__()
的類實例:
>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False
通過callable()
函數,我們就可以判斷一個對象是否是“可調用”對象。
小結
Python的class允許定義許多定製方法,可以讓我們非常方便地生成特定的類。
本節介紹的是最常用的幾個定製方法,還有很多可定製的方法,請參考Python的官方文檔。
使用枚舉類
當我們需要定義常量時,一個辦法是用大寫變量通過整數來定義,例如月份:
JAN = 1
FEB = 2
MAR = 3
...
NOV = 11
DEC = 12
好處是簡單,缺點是類型是int
,並且仍然是變量。
更好的方法是爲這樣的枚舉類型定義一個class類型,然後,每個常量都是class的一個唯一實例。Python提供了Enum
類來實現這個功能:
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
這樣我們就獲得了Month
類型的枚舉類,可以直接使用Month.Jan
來引用一個常量,或者枚舉它的所有成員:
for name, member in Month.__members__.items():
print(name, '=>', member, ',', member.value)
value
屬性則是自動賦給成員的int
常量,默認從1
開始計數。
如果需要更精確地控制枚舉類型,可以從Enum
派生出自定義類:
from enum import Enum, unique
@unique
class Weekday(Enum):
Sun = 0 # Sun的value被設定爲0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
@unique
裝飾器可以幫助我們檢查保證沒有重複值。
訪問這些枚舉類型可以有若干種方法:
訪問這些枚舉類型可以有若干種方法:
>>> day1 = Weekday.Mon
>>> print(day1)
Weekday.Mon
>>> print(Weekday.Tue)
Weekday.Tue
>>> print(Weekday['Tue'])
Weekday.Tue
>>> print(Weekday.Tue.value)
2
>>> print(day1 == Weekday.Mon)
True
>>> print(day1 == Weekday.Tue)
False
>>> print(Weekday(1))
Weekday.Mon
>>> print(day1 == Weekday(1))
True
>>> Weekday(7)
Traceback (most recent call last):
...
ValueError: 7 is not a valid Weekday
>>> for name, member in Weekday.__members__.items():
... print(name, '=>', member)
...
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat
可見,既可以用成員名稱引用枚舉常量,又可以直接根據value的值獲得枚舉常量。
小結
Enum
可以把一組相關常量定義在一個class中,且class不可變,而且成員可以直接比較。
使用元類
type()
動態語言和靜態語言最大的不同,就是函數和類的定義,不是編譯時定義的,而是運行時動態創建的。
比方說我們要定義一個Hello
的class,就寫一個hello.py
模塊:
class Hello(object):
def hello(self, name='world'):
print('Hello, %s.' % name)
當Python解釋器載入hello
模塊時,就會依次執行該模塊的所有語句,執行結果就是動態創建出一個Hello
的class對象,測試如下:
>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class 'hello.Hello'>
type()
函數可以查看一個類型或變量的類型,Hello
是一個class,它的類型就是type
,而h
是一個實例,它的類型就是class Hello
。
我們說class的定義是運行時動態創建的,而創建class的方法就是使用type()
函數。
type()
函數既可以返回一個對象的類型,又可以創建出新的類型,比如,我們可以通過type()
函數創建出Hello
類,而無需通過class Hello(object)...
的定義:
>>> def fn(self, name='world'): # 先定義函數
... print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 創建Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<class 'type'>
>>> print(type(h))
<class '__main__.Hello'>
要創建一個class對象,type()
函數依次傳入3個參數:
- class的名稱;
- 繼承的父類集合,注意Python支持多重繼承,如果只有一個父類,別忘了tuple的單元素寫法;
- class的方法名稱與函數綁定,這裏我們把函數
fn
綁定到方法名hello
上。
通過type()
函數創建的類和直接寫class是完全一樣的,因爲Python解釋器遇到class定義時,僅僅是掃描一下class定義的語法,然後調用type()
函數創建出class。
正常情況下,我們都用class Xxx...
來定義類,但是,type()
函數也允許我們動態創建出類來,也就是說,動態語言本身支持運行期動態創建類,這和靜態語言有非常大的不同,要在靜態語言運行期創建類,必須構造源代碼字符串再調用編譯器,或者藉助一些工具生成字節碼實現,
metaclass
除了使用type()
動態創建類以外,要控制類的創建行爲,還可以使用metaclass。
metaclass,直譯爲元類,簡單的解釋就是:
當我們定義了類以後,就可以根據這個類創建出實例,所以:先定義類,然後創建實例。
但是如果我們想創建出類呢?那就必須根據metaclass創建出類,所以:先定義metaclass,然後創建類。
連接起來就是:先定義metaclass,就可以創建類,最後創建實例。
所以,metaclass允許你創建類或者修改類。換句話說,你可以把類看成是metaclass創建出來的“實例”
metaclass是Python面向對象裏最難理解,也是最難使用的魔術代碼。正常情況下,你不會碰到需要使用metaclass的情況,所以,以下內容看不懂也沒關係,因爲基本上你不會用到。
不看了,溜了