了解元類之前，先了解幾個(gè)魔術(shù)方法： __new__、__init__、__call__

__new__： 對(duì)象的創(chuàng)建，是一個(gè)靜態(tài)方法，第一個(gè)參數(shù)是cls。(想想也是，不可能是self，對(duì)象還沒(méi)創(chuàng)建，哪來(lái)的self)
__init__ ： 對(duì)象的初始化， 是一個(gè)實(shí)例方法，第一個(gè)參數(shù)是self。
__call__ ： 對(duì)象可call，注意不是類，是對(duì)象。

class Bar(object):
    def __new__(cls, *args):
        self = super(Bar, cls).__new__(cls)
        #self = super().__new__(cls) #py3
        print '__new__'
        return self

    def __init__(self, *args):
        print '__init__'
        self.name = args[0]

    def __call__(self, *args):
        print '__call__', args

#執(zhí)行
b = Bar('haha')
print b.name
b()

# 結(jié)果
__new__
__init__
hah
__call__ ()

__new__ 、__init__ 詳解

__new__方法先被調(diào)用，返回一個(gè)實(shí)例對(duì)象，接著 __init__ 被調(diào)用。
從輸出結(jié)果來(lái)看，__new__方法的返回值就是類的實(shí)例對(duì)象，這個(gè)實(shí)例對(duì)象會(huì)傳遞給 __init__ 方法中定義的 self 參數(shù)，以便實(shí)例對(duì)象可以被正確地初始化。

如果 __new__ 方法不返回值（或者說(shuō)返回 None）那么 __init__ 將不會(huì)得到調(diào)用，這個(gè)也說(shuō)得通，因?yàn)閷?shí)例對(duì)象都沒(méi)創(chuàng)建出來(lái)，調(diào)用__init__也沒(méi)什么意義，此外，Python 還規(guī)定，__init__ 只能返回 None 值，否則報(bào)錯(cuò)，這個(gè)留給大家去試。

__init__方法可以用來(lái)做一些初始化工作，比如給實(shí)例對(duì)象的狀態(tài)進(jìn)行初始化

def __init__(self, *args):
    self.name = args[0]

另外，__init__方法中除了self之外定義的參數(shù)，都將與__new__方法中除cls參數(shù)之外的參數(shù)是必須保持一致或者等效。因?yàn)锽ar(x, y)傳參的時(shí)候是先給到__new__(), 然后再傳遞給init

另外：
__new__方法在類定義中不是必須寫(xiě)的，如果沒(méi)定義，默認(rèn)會(huì)調(diào)用object.__new__去創(chuàng)建一個(gè)對(duì)象。如果定義了，就是override,可以custom創(chuàng)建對(duì)象的行為。

聰明的讀者可能想到，既然__new__可以custom對(duì)象的創(chuàng)建，那我在這里做一下手腳，每次創(chuàng)建對(duì)象都返回同一個(gè)，那不就是單例模式了嗎？沒(méi)錯(cuò)，就是這樣?？梢杂^摩《飄逸的python - 單例模式亂彈》

定義單例模式時(shí)，因?yàn)樽远x的__new__重載了父類的__new__，所以要自己顯式調(diào)用父類的new，即object.__new__(cls, *args, **kwargs)，或者用super()。
不然就不是extend原來(lái)的實(shí)例了，而是替換原來(lái)的實(shí)例。

所以：
上面的__new__()方法我們是重寫(xiě)父類object的方法， 所以我們必須至少執(zhí)行
object.__new__(cls, *args, **kwargs) 或者
super(Bar, cls).__new__(cls)
這兩個(gè)是等效的， 用super()可以不用hardcode父類名字。

__call__ 詳解

實(shí)例化后的對(duì)象，再當(dāng)函數(shù)一樣執(zhí)行就會(huì)執(zhí)行到這個(gè)__call__函數(shù)

b = Bar('hah')
b()
#  輸出
__call__ 

總結(jié)
在python中，類的行為就是這樣，__new__、__init__、__call__等方法不是必須寫(xiě)的，會(huì)默認(rèn)調(diào)用，如果自己定義了，就是override,可以custom。既然override了，通常也會(huì)顯式調(diào)用進(jìn)行補(bǔ)償以達(dá)到extend的目的。

元類

Python中的類還遠(yuǎn)不止如此。類同樣也是一種對(duì)象。是的，沒(méi)錯(cuò)，就是對(duì)象。只要你使用關(guān)鍵字class，Python解釋器在執(zhí)行的時(shí)候就會(huì)創(chuàng)建一個(gè)對(duì)象。下面的代碼段：

class ObjectCreator(object):
…       pass

將在內(nèi)存中創(chuàng)建一個(gè)對(duì)象，名字就是ObjectCreator。這個(gè)對(duì)象（類）自身?yè)碛袆?chuàng)建對(duì)象（類實(shí)例）的能力，而這就是為什么它是一個(gè)類的原因。但是，它的本質(zhì)仍然是一個(gè)對(duì)象，于是乎你可以對(duì)它做如下的操作：

1. 你可以將它賦值給一個(gè)變量
2. 你可以拷貝它
3. 你可以為它增加屬性
4. 你可以將它作為函數(shù)參數(shù)進(jìn)行傳遞

>>> print ObjectCreator     # 你可以打印一個(gè)類，因?yàn)樗鋵?shí)也是一個(gè)對(duì)象
<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 # 你可以將類賦值給一個(gè)變量
>>> print ObjectCreatorMirror()
<__main__.ObjectCreator object at 0x8997b4c>

type有一種完全不同的能力，它也能動(dòng)態(tài)的創(chuàng)建類。type可以接受一個(gè)類的描述作為參數(shù)，然后返回一個(gè)類。（我知道，根據(jù)傳入?yún)?shù)的不同，同一個(gè)函數(shù)擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向后兼容性）

type可以像這樣工作：

type(類名, 父類的元組（針對(duì)繼承的情況，可以為空），包含屬性的字典（名稱和值）)

比如下面的代碼：

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)

當(dāng)Python解釋器載入hello模塊時(shí)，就會(huì)依次執(zhí)行該模塊的所有語(yǔ)句，執(zhí)行結(jié)果就是動(dòng)態(tài)創(chuàng)建出一個(gè)Hello的class對(duì)象，測(cè)試如下：

>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<type 'type'>
>>> print(type(h))
<class 'hello.Hello'>

type()函數(shù)可以查看一個(gè)類型或變量的類型，Hello是一個(gè)class，它的類型就是type，而h是一個(gè)實(shí)例，它的類型就是class Hello。

我們說(shuō)class的定義是運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建的，而創(chuàng)建class的方法就是使用type()函數(shù)。

type()函數(shù)既可以返回一個(gè)對(duì)象的類型，又可以創(chuàng)建出新的類型，比如，我們可以通過(guò)type()函數(shù)創(chuàng)建出Hello類，而無(wú)需通過(guò)class Hello(object)...的定義：

>>> def fn(self, name='world'): # 先定義函數(shù)
...     print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 創(chuàng)建Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<type 'type'>
>>> print(type(h))
<class '__main__.Hello'>

要?jiǎng)?chuàng)建一個(gè)class對(duì)象，type()函數(shù)依次傳入3個(gè)參數(shù)：

1. class的名稱；
2. 繼承的父類集合，注意Python支持多重繼承，如果只有一個(gè)父類，別忘了tuple的單元素寫(xiě)法；
3. class的方法名稱與函數(shù)綁定，這里我們把函數(shù)fn綁定到方法名hello上。

通過(guò)type()函數(shù)創(chuàng)建的類和直接寫(xiě)class是完全一樣的，因?yàn)镻ython解釋器遇到class定義時(shí)，僅僅是掃描一下class定義的語(yǔ)法，然后調(diào)用type()函數(shù)創(chuàng)建出class。

正常情況下，我們都用class Xxx...來(lái)定義類，但是，type()函數(shù)也允許我們動(dòng)態(tài)創(chuàng)建出類來(lái)，也就是說(shuō)，動(dòng)態(tài)語(yǔ)言本身支持運(yùn)行期動(dòng)態(tài)創(chuàng)建類。

你可以看到，在Python中，類也是對(duì)象，你可以動(dòng)態(tài)的創(chuàng)建類。這就是當(dāng)你使用關(guān)鍵字class時(shí)Python在幕后做的事情，而這就是通過(guò)元類來(lái)實(shí)現(xiàn)的。

元類就是用來(lái)創(chuàng)建類的“東西”。你創(chuàng)建類就是為了創(chuàng)建類的實(shí)例對(duì)象，不是嗎？但是我們已經(jīng)學(xué)習(xí)到了Python中的類也是對(duì)象。好吧，元類就是用來(lái)創(chuàng)建這些類（對(duì)象）的，元類就是類的類，你可以這樣理解 為

這是因?yàn)楹瘮?shù)type實(shí)際上是一個(gè)元類。type就是Python在背后用來(lái)創(chuàng)建所有類的元類。現(xiàn)在你想知道那為什么type會(huì)全部采用小寫(xiě)形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來(lái)創(chuàng)建字符串對(duì)象的類，而int是用來(lái)創(chuàng)建整數(shù)對(duì)象的類。type就是創(chuàng)建類對(duì)象的類。你可以通過(guò)檢查class屬性來(lái)看到這一點(diǎn)。Python中所有的東西，注意，我是指所有的東西——都是對(duì)象。這包括整數(shù)、字符串、函數(shù)以及類。它們?nèi)慷际菍?duì)象，而且它們都是從一個(gè)類創(chuàng)建而來(lái)。

>>> a = 1
>>> b = 'hello'
>>> a.__class__
<type 'int'>
>>> b.__class__
<type 'str'>

>>> a.__class__.__class__
<type 'type'>
>>> b.__class__.__class__ 
<type 'type'>

上面看得出，哪怕int ，str的類，他們的__class__都是<type 'type'>, 說(shuō)明他們都是由type元類實(shí)例化出來(lái)的對(duì)象，所以說(shuō)元類(type)就是類的類

因此，元類就是創(chuàng)建類這種對(duì)象的東西。如果你喜歡的話，可以把元類稱為“類工廠”（不要和工廠類搞混了:D） type就是Python的內(nèi)建元類，當(dāng)然了，你也可以創(chuàng)建自己的元類。

__metaclass__

你可以在寫(xiě)一個(gè)類的時(shí)候?yàn)槠涮砑?strong>metaclass屬性。

class Foo(object):
    __metaclass__ = something…

如果你這么做了，Python就會(huì)用元類來(lái)創(chuàng)建類Foo。小心點(diǎn)，這里面有些技巧。你首先寫(xiě)下class Foo(object)，但是類對(duì)象Foo還沒(méi)有在內(nèi)存中創(chuàng)建。Python會(huì)在類的定義中尋找metaclass屬性，如果找到了，Python就會(huì)用它來(lái)創(chuàng)建類Foo，如果沒(méi)有找到，就會(huì)用內(nèi)建的type來(lái)創(chuàng)建這個(gè)類。把下面這段話反復(fù)讀幾次。當(dāng)你寫(xiě)如下代碼時(shí) :

class Foo(Bar):
    pass

Python做了如下的操作：

Foo中有__metaclass__這個(gè)屬性嗎？如果是，Python會(huì)在內(nèi)存中通過(guò)__metaclass__創(chuàng)建一個(gè)名字為Foo的類對(duì)象（我說(shuō)的是類對(duì)象，請(qǐng)緊跟我的思路）。如果Python沒(méi)有找到__metaclass__，它會(huì)繼續(xù)在Bar（父類）中尋找__metaclass__屬性，并嘗試做和前面同樣的操作。如果Python在任何父類中都找不到__metaclass__，它就會(huì)在模塊層次中去尋找__metaclass__，并嘗試做同樣的操作。如果還是找不到__metaclass__,Python就會(huì)用內(nèi)置的type來(lái)創(chuàng)建這個(gè)類對(duì)象。

現(xiàn)在的問(wèn)題就是，你可以在__metaclass__中放置些什么代碼呢？答案就是：可以創(chuàng)建一個(gè)類的東西。那么什么可以用來(lái)創(chuàng)建一個(gè)類呢？type，或者任何使用到type或者子類化type的東東都可以。

我們這里就先以一個(gè)簡(jiǎn)單的函數(shù)作為例子開(kāi)始。

# 元類會(huì)自動(dòng)將你通常傳給‘type’的參數(shù)作為自己的參數(shù)傳入
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    '''返回一個(gè)類對(duì)象，將屬性都轉(zhuǎn)為大寫(xiě)形式'''
    #  選擇所有不以'__'開(kāi)頭的屬性
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
    # 將它們轉(zhuǎn)為大寫(xiě)形式
    uppercase_attr = dict((name.upper(), value) for name, value in attrs)

    # 通過(guò)'type'來(lái)做類對(duì)象的創(chuàng)建
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr  #  這會(huì)作用到這個(gè)模塊中的所有類

class Foo(object):
    # 我們也可以只在這里定義__metaclass__，這樣就只會(huì)作用于這個(gè)類中
    bar = 'bip'

print hasattr(Foo, 'bar')
# 輸出: False
print hasattr(Foo, 'BAR')
# 輸出:True

f = Foo()
print f.BAR
# 輸出:'bip'

案例講解：

1. __metaclass__沒(méi)有定義在類里面，而是在模塊里面，所以這個(gè)根據(jù)上面的尋址規(guī)則，本類->父類->模塊 這里的定義會(huì)讓模塊所有類都使用這個(gè)__metaclass__
2. 使用upper_attr來(lái)創(chuàng)建類，它要么包含了type(), 要么直接用type(), 要么子類化type(), 這里是使用了type()
3. 創(chuàng)建類的元類type()會(huì)依次傳入3個(gè)參數(shù)：
   • class的名稱；
   • 繼承的父類集合，注意Python支持多重繼承，如果只有一個(gè)父類，別忘了tuple的單元素寫(xiě)法；
   • class的方法名稱與函數(shù)綁定，這里我們把函數(shù)fn綁定到方法名hello上。
     所以我們看到傳到upper_attr()會(huì)有三個(gè)參數(shù)， future_class_name, future_class_parents, future_class_attr，分別代表上面的參數(shù)。

4.然后我們處理完類屬性，把他們轉(zhuǎn)成大小后，調(diào)用return type(future_class_name, future_class_parents, uppercase_attr) 完成創(chuàng)建類的過(guò)程。

5. 說(shuō)到底還是要使用type() 來(lái)創(chuàng)建類，只不過(guò)我們?cè)谀J(rèn)的創(chuàng)建前攔截掉了，然后加入我們自己處理，比如屬性轉(zhuǎn)大寫(xiě)

當(dāng)然了，用函數(shù)賦值給__metaclass__是可以的，但是不夠OOP
現(xiàn)在讓我們?cè)僮鲆淮危@一次用一個(gè)真正的class來(lái)當(dāng)做元類：

class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)

但就元類本身而言，它們其實(shí)是很簡(jiǎn)單的：

1. 攔截類的創(chuàng)建
2. 修改類
3. 返回修改之后的類

為什么要用metaclass類而不是函數(shù)?

由于__metaclass__可以接受任何可調(diào)用的對(duì)象，那為何還要使用類呢，因?yàn)楹茱@然使用類會(huì)更加復(fù)雜啊？這里有好幾個(gè)原因：

1） 意圖會(huì)更加清晰。當(dāng)你讀到UpperAttrMetaclass(type)時(shí)，你知道接下來(lái)要發(fā)生什么。
2） 你可以使用OOP編程。元類可以從元類中繼承而來(lái)，改寫(xiě)父類的方法。元類甚至還可以使用元類。
3） 你可以把代碼組織的更好。當(dāng)你使用元類的時(shí)候肯定不會(huì)是像我上面舉的這種簡(jiǎn)單場(chǎng)景，通常都是針對(duì)比較復(fù)雜的問(wèn)題。將多個(gè)方法歸總到一個(gè)類中會(huì)很有幫助，也會(huì)使得代碼更容易閱讀。
4） 你可以使用__new__, __init__以及__call__這樣的特殊方法。它們能幫你處理不同的任務(wù)。就算通常你可以把所有的東西都在__new__里處理掉，有些人還是覺(jué)得用__init__更舒服些。
5） 重點(diǎn)：如果使用函數(shù)像第一個(gè)方法，必須顯式調(diào)用type.__new__()方法，如果是下面的子類繼承type類OOP的方式，則不用

例子：?jiǎn)卫Ｊ?/h2>

先看一個(gè)單例：使用__metalcass__

class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

class Foo():
    __metaclass__ = Singleton

f = Foo()
f2=Foo()
# 輸出f == f2 他們是同一個(gè)實(shí)例化對(duì)象

詳細(xì)講解這個(gè)單例模式是什么流程：

1. 首先，我們?cè)贔oo里面定義了__metaclass__= Singleton，這個(gè)Singleton是type的子類，這里如果不寫(xiě)__metaclass__=Singleton默認(rèn)會(huì)是__metaclass__= type， 創(chuàng)建類的時(shí)候，還是調(diào)用type.__new__方法。因?yàn)镕oo就是type創(chuàng)建的實(shí)例。這里Singleton只是擴(kuò)展了type，某些方法，但大部分功能還是繼承type的，__new__這里沒(méi)有重寫(xiě)，說(shuō)明還是使用的type.__new__來(lái)創(chuàng)建這個(gè)Foo
2. 既然我們子類Singleton 沒(méi)有重寫(xiě)type的__new__, __init__方法，那么就說(shuō)明在創(chuàng)建Foo這個(gè)類（對(duì)于type來(lái)說(shuō)是實(shí)例對(duì)象）的時(shí)候，還是使用默認(rèn)的方式！
3. 我們?cè)赟ingleton重寫(xiě)了__call__方法，也就是重寫(xiě)了type的這個(gè)方法，那么這個(gè)方法會(huì)在什么時(shí)候發(fā)揮作用呢？我們知道__call__是實(shí)例在像函數(shù)一樣調(diào)用的時(shí)候，會(huì)觸發(fā)的 比如f = Foo(), f(5) 這個(gè)f(5)就會(huì)調(diào)用Foo類的__call__方法。 而在我們Foo()獲取單例的時(shí)候，實(shí)際上Foo也是type的實(shí)例，F(xiàn)oo雖然是類，它同時(shí)也是type的實(shí)例所以Foo()生成Foo的實(shí)例的同時(shí)，觸發(fā)了Foo的類type的__call__方法！
4. 所以就在這時(shí)，觸發(fā)了它的元類也就是Singleton的__call__（如果沒(méi)有定義__metaclass__，就會(huì)默認(rèn)調(diào)用type.__call）方法，這個(gè)__call__方法判斷了是否單例。注意Singleton重寫(xiě)了__call__方法以后，一定要重新調(diào)用原來(lái)的默認(rèn)的type.__call__()方法, 所以也就看到了
   foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)實(shí)際上就是type在調(diào)用__call__()

一開(kāi)始誤解很久的地方：

1. 我以為_(kāi)_metaclass__=Singleton 在創(chuàng)建類Foo的時(shí)候調(diào)用Singleton() 就會(huì)馬上執(zhí)行它的__call__()方法，其實(shí)不然，可以直接把Singleton想象成在執(zhí)行默認(rèn)的type()，還是像原來(lái)的方式通過(guò)type.__new__() type.__init__()來(lái)創(chuàng)建類。
2. 當(dāng)然了既然Singleton是type的子類，也是它的實(shí)例，所以Singleton(), 也是會(huì)執(zhí)行type.__call__()方法拉，這個(gè)方法應(yīng)該就是返回Singleton的實(shí)例了。 也就是創(chuàng)建完的Foo類
3. Singleton為什么要用__call()__ 用__new()__可以么？看下面

class Singleton(type):
    def __new__(cls, future_class_name, future_class_parents, future_class_attrs):
        print '__new__', cls, future_class_name, future_class_parents, future_class_attrs
        attrs = [(k, v) for k, v in future_class_attrs.items() if not k.startswith('__')]
        new_attrs = dict([(k.upper(), v)for k, v in attrs])
        print new_attrs
        return super(Singleton, cls).__new__(cls, future_class_name, future_class_parents, new_attrs)

    def __call__(foo_cls, *args, **kwargs):
        if not hasattr(foo_cls, '_instance'):
            foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)
        return foo_cls._instance

f = Foo()
print hasattr(f, 'bar') # False
print hasattr(f, 'BAR') # True
f.GET_NAME() # haha
print f.bar  # error
print f.BAR # hello world

解答元類__new__和 __call__的區(qū)別

1. type.__new__()就是用來(lái)生成類的！所以只會(huì)調(diào)用一次，因?yàn)轭怓oo只需要一個(gè)！所以__new__是用來(lái)再創(chuàng)建類的時(shí)候，做攔截，加入一些我們自己的邏輯，比如這里我把所有類方法，類屬性轉(zhuǎn)成了大寫(xiě)！
2. __call__則是每次類調(diào)用的時(shí)候也就是Foo()會(huì)觸發(fā)，每次都會(huì)觸發(fā)。

圈重點(diǎn)了

使用__new__寫(xiě)單例

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls, *args, **kwargs)
        return cls._instance

class Foo(Singleton):
    a = 1

這個(gè)流程比較清晰了：

1. 定義Foo的時(shí)候沒(méi)有定義__metaclass__ 所以由默認(rèn)方式type()來(lái)創(chuàng)建
2. Foo()創(chuàng)建實(shí)例的時(shí)候，首先執(zhí)行__new__()方法，創(chuàng)建實(shí)例，就再此時(shí)攔截掉默認(rèn)的創(chuàng)建實(shí)例方法
   object.__new()__ 我們加入判斷類是否有這個(gè)單例的屬性，有則直接返回，沒(méi)有則先用object.__new__創(chuàng)建，然后返回

例子：ORM

ORM提供簡(jiǎn)單接口給用戶調(diào)用

class User(Model):
    # 這些定義的類變量
    id = IntegerField('id')
    name = StringField('name')
    email = StringField('email')
    password = StringField('password')

user = User(name="lisalian", email="lisalian@qq.com")
user.password = '123456'
user.save()

定義好一個(gè)User表的類，然后傳入?yún)?shù)，user.save()就能完成插入數(shù)據(jù)庫(kù)的功能

首先來(lái)定義Field類，它負(fù)責(zé)保存數(shù)據(jù)庫(kù)表的字段名和字段類型：

class Field(object):
    def __init__(self, column, column_type):
        self.column = column
        self.column_type = column_type

    def __str(self):
        return '<%s:%s>' % (self.__class__.__name__, self.column)

在Field的基礎(chǔ)上，進(jìn)一步定義各種類型的Field，比如StringField，IntegerField等等：

class IntegerField(Field):
    def __init__(self, column):
        super(IntegerField, self).__init__(column, 'int')

class StringField(Field):
    def __init__(self, column):
        super(StringField, self).__init__(column, 'varchar')

__meataclass__的編寫(xiě)：

class MetaModel(type):
    def __new__(cls, name, bases, attrs):
        """這個(gè)__metaclass__同樣適用于Model，只不過(guò)它也適用于子類User
            如果是創(chuàng)建Model類，則跳過(guò)__maping__的處理
        """
        if name == "Model":
            return super(MetaModel, cls).__new__(cls, name, bases, attrs)

        __maping__ = {}
        for k, v in attrs.iteritems():
            if isinstance(v, Field):
                print 'find field %s' % v.column
                __maping__[k] = v

        attrs['__maping__'] = __maping__
        attrs['__table__'] = name
        for k in __maping__.keys():
            attrs.pop(k)

        # 顯式調(diào)用__new__() 是要傳cls參數(shù)，
        # 平常我們不是顯示調(diào)用才不需要self, cls這樣的參數(shù)
        return super(MetaModel, cls).__new__(cls, name, bases, attrs)

以及Model基類

class Model(object):
    __metaclass__ = MetaModel

    field_dict = {}
    def __init__(self, **kw):
        self.field_dict.update(kw)
        # 如果Model(dict)這樣定義的話就這樣執(zhí)行，這樣Model就是dict的子類，一個(gè)字典
        #super(Model, self).__init__(self, **kw)

    # 實(shí)例對(duì)象設(shè)置新屬性時(shí)調(diào)用
    def __setattr__(self, name, value):
        self.field_dict[name] = value

    # 實(shí)例對(duì)象調(diào)用不存在屬性時(shí)調(diào)用
    def __getattr__(self, name):
        try:
            return self.field_dict[name]
        except KeyError:
            raise AttributeError('Model object has no attributes %s' % name)

    """save 方法定義在Model這里，就可以讓所有繼承了Model的數(shù)據(jù)表
        都有save()
       save方法作用是獲取子類的實(shí)例的各個(gè)字段值，拼湊出insert的SQL
       那么問(wèn)題來(lái)了：怎么獲取子類的實(shí)例的字段，子類的字段都是隨便定義的
       不是Model這里繼承過(guò)去，Model不能知道有什么字段

       這個(gè)save方法被繼承于User,最后執(zhí)行也是再User里面執(zhí)行
       所以在定義User類的時(shí)候，就生成一些字段的映射關(guān)系，這就要利用元類了
    """
    def save(self):
        args = []
        params = []
        fields = []
        for k, v in self.__maping__.iteritems():
            fields.append(k)
            args.append(self.field_dict.get(k, None))
            params.append('?')

        print fields
        print params
        print args
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print sql

詳解ORM：

1. User()類定義的字段，就是數(shù)據(jù)表的字段，每個(gè)字段對(duì)應(yīng)著一個(gè)Field實(shí)例。
2. User繼承了Model的方法和元類，save()和__metaclass__
   3.__metaclass__最重要的功能就是，在創(chuàng)建類的時(shí)候，把定義再User類里面的字段關(guān)系，轉(zhuǎn)成一個(gè)字段__mapping__保存到User類里面，這樣使用save()方法的時(shí)候才能獲取到這些映射關(guān)系。不然你直接定義的各個(gè)字段在save的時(shí)候，根本獲取不到。

參考：

深刻理解Python中的元類(metaclass)
飄逸的python - 單例模式亂彈
stackoverflow 單例
使用元類