如果說一切皆對象，那么萬物起始就是元類楼熄，元類是用來定義和構(gòu)建類型的。
類：也是對象
????在大多數(shù)編程語言中础钠，類就是一組用來描述如何生成一個對象的代碼段。在python中這一點仍然成立：
>>> class ObjectCreator(object):
... pass
...
>>> my_object = ObjectCreator()
>>> print my_object
<__main__.ObjectCreator object at 0x8974f2c>
????但是叉谜，python中的類還遠(yuǎn)不止如此旗吁。類同樣也是一種對象。只要使用關(guān)鍵字 class停局，Python 解釋器在執(zhí)行的時候就會創(chuàng)建一個對象很钓。
下面的代碼段：
>>> class ObjectCreator(object):
... pass
...
????將在內(nèi)存中創(chuàng)建一個對象，名字就是 ObjectCreator董栽。這個對象（類對象 ObjectCreator） 擁有創(chuàng)建對象（實例對象）的能力码倦。但是，它的本質(zhì)仍然是一個對象裆泳，于是乎你可以對它做如下的操作：
????????可以將它賦值給一個變量 叹洲；
????????可以拷貝它；
????????可以為它增加屬性工禾；
????????可以將它作為函數(shù)參數(shù)進(jìn)行傳遞 运提。
下面是示例：
>>> print ObjectCreator # 你可以打印一個類，因為它其實也是一個對象
<class '__main__.ObjectCreator'>
>>> def echo(o):
... print o
...
>>> echo(ObjectCreator) # 你可以將類做為參數(shù)傳給函數(shù)
<class '__main__.ObjectCreator'>
>>> print hasattr(ObjectCreator, 'new_attribute')
Fasle
>>> ObjectCreator.new_attribute = 'foo' # 你可以為類增加屬性
>>> print hasattr(ObjectCreator, 'new_attribute')
True
>>> print ObjectCreator.new_attribute
foo
>>> ObjectCreatorMirror = ObjectCreator # 你可以將類賦值給一個變量
>>> print ObjectCreatorMirror()
<__main__.ObjectCreator object at 0x8997b4c>
類的動態(tài)創(chuàng)建
????因為類也是對象闻葵，你可以在運行時動態(tài)的創(chuàng)建它們民泵，就像其他任何對象一樣。首先槽畔，你可以在函數(shù)中創(chuàng)建類栈妆，使用 class 關(guān)鍵字即可。
>>> def choose_class(name):
... if name == 'foo':
... class Foo(object):
... pass
... return Foo # 返回的是類厢钧，不是類的實例
... else:
... class Bar(object):
... pass
... return Bar
...
>>> MyClass = choose_class('foo')
>>> print MyClass # 函數(shù)返回的是類鳞尔，不是類的實例
<class '__main__'.Foo>
>>> print MyClass() # 你可以通過這個類創(chuàng)建類實例，也就是對象
<__main__.Foo object at 0x89c6d4c>
????但這還不夠動態(tài)早直，因為你仍然需要自己編寫整個類的代碼寥假。由于類也是對象，所以它們必須是通過什么東西來生成的才對霞扬。當(dāng)你使用 class 關(guān)鍵字時糕韧，Python 解釋器自動創(chuàng)建這個對象。但就和 Python 中的大多數(shù)事情一樣喻圃，Python 仍然提供給你手動處理的方法萤彩。
????還記得內(nèi)建函數(shù) type 嗎？這個古老但強(qiáng)大的函數(shù)能夠讓你知道一個對象的類型是什么斧拍，像這樣：
>>> print type(1) #數(shù)值的類型
<type 'int'>
>>> print type("1") #字符串的類型
<type 'str'>
>>> print type(ObjectCreator()) #實例對象的類型
<class '__main__.ObjectCreator'>
>>> print type(ObjectCreator) #類的類型
<type 'type'>
仔細(xì)觀察上面的運行結(jié)果雀扶，發(fā)現(xiàn)使用 type 對 ObjectCreator 查看類型是，答案為 type肆汹。
type創(chuàng)建類愚墓、屬性窍侧、方法
????type 還有一種完全不同的功能，動態(tài)的創(chuàng)建類转绷。
????type 可以接受一個類的描述作為參數(shù)，然后返回一個類硼啤。（要知道议经，根據(jù)傳入?yún)?shù)的不同，同一個函數(shù)擁有兩種完全不同的用法是一件很傻的事情谴返，但這在 Python 中是為了保持向后兼容性）煞肾。
type 可以這樣工作：
????type（類名, 由父類名稱組成的元組（針對繼承的情況，可以為空）嗓袱，包含屬性的字典（名稱和值））籍救。
比如下面的代碼：
In [2]: class Test: #定義了一個 Test 類
...: pass
...:
In [3]: Test() #創(chuàng)建了一個 Test 類的實例對象
Out[3]: <__main__.Test at 0x10d3f8438>
可以手動像這樣創(chuàng)建：
Test2 = type("Test2",(),{}) #定了一個 Test2 類
In [5]: Test2() #創(chuàng)建了一個 Test2 類的實例對象
Out[5]: <__main__.Test2 at 0x10d406b38>
????使用"Test2"作為類名，并且也可以把它當(dāng)做一個變量來作為類的引用渠抹。類和變量是不同的蝙昙，這里沒有任何理由把事情弄的復(fù)雜。即 type 函數(shù)中第 1 個實參梧却，也可以叫做其他的名字奇颠，這個名字表示類的名字。
In [23]: MyDogClass = type('MyDog', (), {})
In [24]: print MyDogClass
<class '__main__.MyDog'>
使用 help 來測試這 2 個類
In [10]: help(Test) #用 help 查看 Test 類
Help on class Test in module __main__:
class Test(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
In [8]: help(Test2) #用 help 查看 Test2 類
Help on class Test2 in module __main__:
class Test2(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
type 接受一個字典來為類定義屬性放航，因此
>>> Foo = type('Foo', (), {'bar':True})
可以翻譯為：
>>> class Foo(object):
... bar = True
并且可以將 Foo 當(dāng)成一個普通的類一樣使用：
>>> print Foo
<class '__main__.Foo'>
>>> print Foo.bar
True
>>> f = Foo()
>>> print f
<__main__.Foo object at 0x8a9b84c>
>>> print f.bar
True
當(dāng)然烈拒，你可以向這個類繼承，所以广鳍，如下的代碼：
>>> class FooChild(Foo):
... pass
就可以寫成：
>>> FooChild = type('FooChild', (Foo,),{})
>>> print FooChild
<class '__main__.FooChild'>
>>> print FooChild.bar # bar 屬性是由 Foo 繼承而來
True
type 的第2個參數(shù)荆几，元組中是父類的名字，而不是字符串赊时；添加的屬性是類屬性吨铸，并不是實例屬性。
最終你會希望為你的類增加方法蛋叼。只需要定義一個有著恰當(dāng)簽名的函數(shù)并將其作為屬性賦值就可以焊傅。
添加實例方法：
In [46]: def echo_bar(self): #定義了一個普通的函數(shù)
...: print(self.bar)
...:
In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) #讓FooChild 類中的 echo_bar 屬性，指向了上面定義的函數(shù)
In [48]: hasattr(Foo, 'echo_bar') #判斷 Foo 類中狈涮，是否有 echo_bar 這個屬性
Out[48]: False
In [49]:
In [49]: hasattr(FooChild, 'echo_bar') #判斷 FooChild 類中狐胎，是否有 echo_bar 這個屬性
Out[49]: True
In [50]: my_foo = FooChild()
In [51]: my_foo.echo_bar()
True
添加靜態(tài)方法
In [36]: @staticmethod
...: def testStatic():
...: print("static method ....")
...:
In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,"testStatic":
...: testStatic})
In [38]: fooclid = Foochild()
In [39]: fooclid.testStatic
Out[39]: <function __main__.testStatic>
In [40]: fooclid.testStatic()
static method ....
In [41]: fooclid.echo_bar()
True
添加類方法
In [42]: @classmethod
...: def testClass(cls):
...: print(cls.bar)
...:
In [43]:
In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,
"testStatic":
...: testStatic, "testClass":testClass})
In [44]:
In [44]: fooclid = Foochild()
In [45]: fooclid.testClass()
True
可以看到，在 Python 中歌馍，類也是對象握巢，可以動態(tài)的創(chuàng)建類。這就是使用關(guān)鍵字class 時 Python 在幕后做的事情松却，而這就是通過元類來實現(xiàn)的暴浦。
再說元類
????元類就是用來創(chuàng)建類的“東西”溅话。你創(chuàng)建類就是為了創(chuàng)建類的實例對象。Python 中的類也是對象歌焦。元類就是用來創(chuàng)建這些類（對象）的飞几，元類就是類的類，你可以這樣理解為：
MyClass = MetaClass() #使用元類創(chuàng)建出一個對象独撇，這個對象稱為“類”
MyObject = MyClass() #使用“類”來創(chuàng)建出實例對象
type 可以像這樣做：
MyClass = type('MyClass', (), {})
????這是因為函數(shù) type 實際上是一個元類屑墨。type 就是 Python 在背后用來創(chuàng)建所有類的元類。
????想知道那為什么 type 會全部采用小寫形式而不是 Type 呢纷铣？我猜這是為了和str 保持一致性卵史，str 是用來創(chuàng)建字符串對象的類，而 int 是用來創(chuàng)建整數(shù)對象的類搜立。type就是創(chuàng)建類對象的類以躯。你可以通過檢查class屬性來看到這一點。Python 中所有的東西啄踊，注意忧设，所有的東西——都是對象。這包括整數(shù)社痛、字符串见转、函數(shù)以及類。它們?nèi)慷际菍ο笏獍В宜鼈兌际菑囊粋€類創(chuàng)建而來斩箫，這個類就是 type。
>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>>foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>
對于任何一個class的class屬性是什么撵儿？
>>> a.__class__.__class__
<type 'type'>
>>> age.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>
因此乘客，元類就是創(chuàng)建類這種對象的東西。type就是Python的內(nèi)建元類淀歇，當(dāng)然也可以創(chuàng)建自己的元類易核。
_metaclass_
可以在定義一個類的時候為其添加metaclass屬性。
class Foo(object):
__metaclass__ = something…
...省略...
????如果這么做浪默，Python 就會用元類來創(chuàng)建類 Foo牡直。首先寫下 class Foo(object)，但是類 Foo 還沒有在內(nèi)存中創(chuàng)建纳决。Python 會在類的定義中尋找metaclass屬性碰逸，如果找到了，Python 就會用它來創(chuàng)建類 Foo阔加，如果沒有找到饵史，就會用內(nèi)建的 type 來創(chuàng)建這個類。當(dāng)寫如下代碼時:
class Foo(Bar):
pass
Python 做了如下的操作：
????Foo 中有metaclass這個屬性嗎？如果是胳喷，Python 會通過metaclass創(chuàng)建一個名字為 Foo 的類(對象)湃番；如果 Python 沒有找到metaclass，它會繼續(xù)在 Bar（父類）中尋找metaclass屬性吭露，并嘗試做和前面同樣的操作吠撮。
????如果 Python 在任何父類中都找不到metaclass，它就會在模塊層次中去尋找metaclass讲竿，并嘗試做同樣的操作纬向。
????如果還是找不到metaclass,Python 就會用內(nèi)置的 type 來創(chuàng)建這個類對象。
????現(xiàn)在的問題就是戴卜，可以在metaclass中放置些什么代碼？答案就是：可以創(chuàng)建一個類的東西琢岩。那么可以用什么來創(chuàng)建一個類投剥？type，或者任何使用到 type 或者子類化 type的都可以担孔。
自定義元類
????元類的主要目的就是為了當(dāng)創(chuàng)建類時能夠自動地改變類江锨。通常，你會為 API 做這樣的事情糕篇，你希望可以創(chuàng)建符合當(dāng)前上下文的類啄育。
????假想一個很傻的例子，你決定在你的模塊里所有的類的屬性都應(yīng)該是大寫形式拌消。有好幾種方法可以辦到挑豌，但其中一種就是通過在模塊級別設(shè)定metaclass。采用這種方法墩崩，這個模塊中的所有類都會通過這個元類來創(chuàng)建氓英，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。
????幸運的是鹦筹，metaclass實際上可以被任意調(diào)用铝阐，它并不需要是一個正式的類。所以铐拐，我們這里就先以一個簡單的函數(shù)作為例子開始徘键。
python2 中
#-*- coding:utf-8 -*-
def upper_attr(future_class_name, future_class_parents, future_class_attr):
#遍歷屬性字典，把不是__開頭的屬性名字變?yōu)榇髮?newAttr = {}
for name,value in future_class_attr.items():
if not name.startswith("__"):
newAttr[name.upper()] = value
#調(diào)用 type 來創(chuàng)建一個類
return type(future_class_name, future_class_parents, newAttr)
class Foo(object):
__metaclass__ = upper_attr #設(shè)置 Foo 類的元類為 upper_attr
bar = 'bip'
print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))
f = Foo()
print(f.BAR)
python3 中
#-*- coding:utf-8 -*-
def upper_attr(future_class_name, future_class_parents, future_class_attr):
#遍歷屬性字典遍蟋，把不是__開頭的屬性名字變?yōu)榇髮?newAttr = {}
for name,value in future_class_attr.items():
if not name.startswith("__"):
newAttr[name.upper()] = value
#調(diào)用 type 來創(chuàng)建一個類
return type(future_class_name, future_class_parents, newAttr)
class Foo(object, metaclass=upper_attr):
bar = 'bip'
print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))
f = Foo()
print(f.BAR)
現(xiàn)在讓我們再做一次吹害，這一次用一個真正的 class 來當(dāng)做元類。
#coding=utf-8
class UpperAttrMetaClass(type):
# __new__ 是在__init__之前被調(diào)用的特殊方法
# __new__是用來創(chuàng)建對象并返回之的方法
# 而__init__只是用來將傳入的參數(shù)初始化給對象
# 你很少用到__new__匿值，除非你希望能夠控制對象的創(chuàng)建
# 這里赠制，創(chuàng)建的對象是類，我們希望能夠自定義它，所以我們這里改寫__new__
# 如果你希望的話钟些，你也可以在__init__中做些事情
# 還有一些高級的用法會涉及到改寫__call__特殊方法烟号，但是我們這里不用
def __new__(cls, future_class_name, future_class_parents,
future_class_attr):
# 遍歷屬性字典，把不是__開頭的屬性名字變?yōu)榇髮?newAttr = {}
for name,value in future_class_attr.items():
if not name.startswith("__"):
newAttr[name.upper()] = value
# 方法 1：通過'type'來做類對象的創(chuàng)建
# return type(future_class_name, future_class_parents, newAttr)
# 方法 2：復(fù)用 type.__new__方法
# 這就是基本的 OOP 編程政恍，沒什么魔法
# return type.__new__(cls, future_class_name, future_class_parents,
newAttr)
# 方法 3：使用 super 方法
return super(UpperAttrMetaClass, cls).__new__(cls, future_class_name, future_class_parents, newAttr)
# python2 的用法
class Foo(object):
__metaclass__ = UpperAttrMetaClass
bar = 'bip'
# python3 的用法
# class Foo(object, metaclass = UpperAttrMetaClass):
# bar = 'bip'
print(hasattr(Foo, 'bar'))
# 輸出: False
print(hasattr(Foo, 'BAR'))
# 輸出:True
f = Foo()
print(f.BAR)
# 輸出:'bip'
就是這樣汪拥，除此之外，關(guān)于元類真的沒有別的可說的篙耗。但就元類本身而言迫筑，它們其實是很
簡單的：
攔截類的創(chuàng)建
修改類
返回修改之后的類
為什么使用元類
????現(xiàn)在回到大主題上來，究竟是為什么使用這樣一種容易出錯且晦澀的特性宗弯？
????“元類就是深度的魔法脯燃，99%的用戶應(yīng)該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類蒙保，那么你就不需要它辕棚。那些實際用到元類的人都非常清楚地知道他們需要做什么，而且根本不需要解釋為什么要用元類邓厕∈藕浚”—— Python 界的領(lǐng)袖 Tim Peters
