元類

1. 類也是對象

在大多數編程語言中，類就是一組用來描述如何生成一個對象的代碼段。在Python中這一點仍然成立：

>>> class ObjectCreator(object):
… pass
…
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但是，Python中的類還遠不止如此。類同樣也是一種對象。是的，沒錯，就是對象。只要你使用關鍵字class，Python解釋器在執行的時候就會創建一個對象。

下面的代碼段：

>>> class ObjectCreator(object):
… pass
…

將在內存中創建一個對象，名字就是ObjectCreator。這個對象（類對象ObjectCreator）擁有創建對象（實例對象）的能力。但是，它的本質仍然是一個對象，于是乎你可以對它做如下的操作：

你可以將它賦值給一個變量

你可以拷貝它

你可以為它增加屬性

你可以將它作為函數參數進行傳遞

下面是示例：

>>> print(ObjectCreator) # 你可以打印一個類，因為它其實也是一個對象
<class '__main__.ObjectCreator'>
>>> def echo(o):
… print(o)
…
>>> echo(ObjectCreator) # 你可以將類做為參數傳給函數
<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>

2. 動態地創建類

因為類也是對象，你可以在運行時動態的創建它們，就像其他任何對象一樣。首先，你可以在函數中創建類，使用class關鍵字即可。

>>> 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) # 函數返回的是類，不是類的實例
<class '__main__'.Foo>
>>> print(MyClass()) # 你可以通過這個類創建類實例，也就是對象
<__main__.Foo object at 0x89c6d4c>

但這還不夠動態，因為你仍然需要自己編寫整個類的代碼。由于類也是對象，所以它們必須是通過什么東西來生成的才對。

當你使用class關鍵字時，Python解釋器自動創建這個對象。但就和Python中的大多數事情一樣，Python仍然提供給你手動處理的方法。

還記得內建函數type嗎？這個古老但強大的函數能夠讓你知道一個對象的類型是什么，就像這樣：

>>> print(type(1)) # 數值的類型
<type 'int'>
>>> print(type("1")) # 字符串的類型
<type 'str'>
>>> print(type(ObjectCreator())) # 實例對象的類型
<class '__main__.ObjectCreator'>
>>> print(type(ObjectCreator)) # 類的類型
<type 'type'>

仔細觀察上面的運行結果，發現使用type對ObjectCreator查看類型是，答案為type， 是不是有些驚訝。。。看下面

3. 使用type創建類

type還有一種完全不同的功能，動態的創建類。

type可以接受一個類的描述作為參數，然后返回一個類。（要知道，根據傳入參數的不同，同一個函數擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向后兼容性）

type可以像這樣工作：

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

比如下面的代碼：

In [2]: class Test: #定義了一個Test類
 ...: pass
 ...:
In [3]: Test() # 創建了一個Test類的實例對象
Out[3]: <__main__.Test at 0x10d3f8438>

可以手動像這樣創建：

Test2 = type("Test2", (), {}) # 定了一個Test2類
In [5]: Test2() # 創建了一個Test2類的實例對象
Out[5]: <__main__.Test2 at 0x10d406b38>

我們使用"Test2"作為類名，并且也可以把它當做一個變量來作為類的引用。類和變量是不同的，這里沒有任何理由把事情弄的復雜。即type函數中第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)

4. 使用type創建帶有屬性的類

type 接受一個字典來為類定義屬性，因此

>>> Foo = type('Foo', (), {'bar': True})

可以翻譯為：

>>> class Foo(object):
… bar = True

并且可以將Foo當成一個普通的類一樣使用：

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

當然，你可以繼承這個類，代碼如下：

>>> class FooChild(Foo):
… pass

就可以寫成：

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar屬性是由Foo繼承而來
True

注意：

type的第2個參數，元組中是父類的名字，而不是字符串

添加的屬性是類屬性，并不是實例屬性

5. 使用type創建帶有方法的類

最終你會希望為你的類增加方法。只需要定義一個有著恰當簽名的函數并將其作為屬性賦值就可以了。

添加實例方法

In [46]: def echo_bar(self): # 定義了一個普通的函數
 ...: print(self.bar)
 ...:
In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) # 讓FooChild類中的echo_bar屬性，指向了上面定義的函數
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

添加靜態方法

In [36]: @staticmethod
 ...: def test_static():
 ...: print("static method ....")
 ...:
In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar": echo_bar, "test_static": test_static})
In [38]: fooclid = Foochild()
In [39]: fooclid.test_static
Out[39]: <function __main__.test_static>
In [40]: fooclid.test_static()
static method ....
In [41]: fooclid.echo_bar()
True

添加類方法

In [42]: @classmethod
 ...: def test_class(cls):
 ...: print(cls.bar)
 ...:
In [43]:
In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "test_static": test_static, "test_class": test_class})
In [44]:
In [44]: fooclid = Foochild()
In [45]: fooclid.test_class()
True

你可以看到，在Python中，類也是對象，你可以動態的創建類。這就是當你使用關鍵字class時Python在幕后做的事情，而這就是通過元類來實現的。

較為完整的使用type創建類的方式:

class A(object):
 num = 100
def print_b(self):
 print(self.num)
@staticmethod
def print_static():
 print("----haha-----")
@classmethod
def print_class(cls):
 print(cls.num)
B = type("B", (A,), {"print_b": print_b, "print_static": print_static, "print_class": print_class})
b = B()
b.print_b()
b.print_static()
b.print_class()
# 結果
# 100
# ----haha-----
# 100

6. 到底什么是元類（終于到主題了）

元類就是用來創建類的“東西”。你創建類就是為了創建類的實例對象，不是嗎？但是我們已經學習到了Python中的類也是對象。

元類就是用來創建這些類（對象）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass() # 使用元類創建出一個對象，這個對象稱為“類”
my_object = MyClass() # 使用“類”來創建出實例對象

你已經看到了type可以讓你像這樣做：

MyClass = type('MyClass', (), {})

這是因為函數type實際上是一個元類。type就是Python在背后用來創建所有類的元類。現在你想知道那為什么type會全部采用小寫形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來創建字符串對象的類，而int是用來創建整數對象的類。type就是創建類對象的類。你可以通過檢查__class__屬性來看到這一點。Python中所有的東西，注意，我是指所有的東西——都是對象。這包括整數、字符串、函數以及類。它們全部都是對象，而且它們都是從一個類創建而來，這個類就是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'>

因此，元類就是創建類這種對象的東西。type就是Python的內建元類，當然了，你也可以創建自己的元類。

7. __metaclass__屬性

你可以在定義一個類的時候為其添加__metaclass__屬性。

class Foo(object):
 __metaclass__ = something…
 ...省略...

如果你這么做了，Python就會用元類來創建類Foo。小心點，這里面有些技巧。你首先寫下class Foo(object)，但是類Foo還沒有在內存中創建。Python會在類的定義中尋找__metaclass__屬性，如果找到了，Python就會用它來創建類Foo，如果沒有找到，就會用內建的type來創建這個類。把下面這段話反復讀幾次。當你寫如下代碼時 :

class Foo(Bar):
 pass

Python做了如下的操作：

Foo中有__metaclass__這個屬性嗎？如果是，Python會通過__metaclass__創建一個名字為Foo的類(對象)

如果Python沒有找到__metaclass__，它會繼續在Bar（父類）中尋找__metaclass__屬性，并嘗試做和前面同樣的操作。

如果Python在任何父類中都找不到__metaclass__，它就會在模塊層次中去尋找__metaclass__，并嘗試做同樣的操作。

如果還是找不到__metaclass__,Python就會用內置的type來創建這個類對象。

現在的問題就是，你可以在__metaclass__中放置些什么代碼呢？答案就是：可以創建一個類的東西。那么什么可以用來創建一個類呢？type，或者任何使用到type或者子類化type的東東都可以。

8. 自定義元類

元類的主要目的就是為了當創建類時能夠自動地改變類。

假想一個很傻的例子，你決定在你的模塊里所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過在模塊級別設定__metaclass__。采用這種方法，這個模塊中的所有類都會通過這個元類來創建，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。

幸運的是，__metaclass__實際上可以被任意調用，它并不需要是一個正式的類。所以，我們這里就先以一個簡單的函數作為例子開始。

python2中

#-*- coding:utf-8 -*-
def upper_attr(class_name, class_parents, class_attr):
 # class_name 會保存類的名字 Foo
 # class_parents 會保存類的父類 object
 # class_attr 會以字典的方式保存所有的類屬性
 # 遍歷屬性字典，把不是__開頭的屬性名字變為大寫
 new_attr = {}
 for name, value in class_attr.items():
 if not name.startswith("__"):
 new_attr[name.upper()] = value
 # 調用type來創建一個類
 return type(class_name, class_parents, new_attr)
class Foo(object):
 __metaclass__ = upper_attr # 設置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(class_name, class_parents, class_attr):
 #遍歷屬性字典，把不是__開頭的屬性名字變為大寫
 new_attr = {}
 for name,value in class_attr.items():
 if not name.startswith("__"):
 new_attr[name.upper()] = value
 #調用type來創建一個類
 return type(class_name, class_parents, new_attr)
class Foo(object, metaclass=upper_attr):
 bar = 'bip'
print(hasattr(Foo, 'bar'))
print(hasattr(Foo, 'BAR'))
f = Foo()
print(f.BAR)

現在讓我們再做一次，這一次用一個真正的class來當做元類。

#coding=utf-8
class UpperAttrMetaClass(type):
 # __new__ 是在__init__之前被調用的特殊方法
 # __new__是用來創建對象并返回之的方法
 # 而__init__只是用來將傳入的參數初始化給對象
 # 你很少用到__new__，除非你希望能夠控制對象的創建
 # 這里，創建的對象是類，我們希望能夠自定義它，所以我們這里改寫__new__
 # 如果你希望的話，你也可以在__init__中做些事情
 # 還有一些高級的用法會涉及到改寫__call__特殊方法，但是我們這里不用
 def __new__(cls, class_name, class_parents, class_attr):
 # 遍歷屬性字典，把不是__開頭的屬性名字變為大寫
 new_attr = {}
 for name, value in class_attr.items():
 if not name.startswith("__"):
 new_attr[name.upper()] = value
 # 方法1：通過'type'來做類對象的創建
 return type(class_name, class_parents, new_attr)
 # 方法2：復用type.__new__方法
 # 這就是基本的OOP編程，沒什么魔法
 # return type.__new__(cls, class_name, class_parents, new_attr)
# python3的用法
class Foo(object, metaclass=UpperAttrMetaClass):
 bar = 'bip'
# python2的用法
# class Foo(object):
# __metaclass__ = UpperAttrMetaClass
# bar = 'bip'
print(hasattr(Foo, 'bar'))
# 輸出: False
print(hasattr(Foo, 'BAR'))
# 輸出:True
f = Foo()
print(f.BAR)
# 輸出:'bip'

就是這樣，除此之外，關于元類真的沒有別的可說的了。但就元類本身而言，它們其實是很簡單的：

攔截類的創建

修改類

返回修改之后的類

究竟為什么要使用元類？

現在回到我們的大主題上來，究竟是為什么你會去使用這樣一種容易出錯且晦澀的特性？好吧，一般來說，你根本就用不上它：

“元類就是深度的魔法，99%的用戶應該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類，那么你就不需要它。那些實際用到元類的人都非常清楚地知道他們需要做什么，而且根本不需要解釋為什么要用元類。” —— Python界的領袖 Tim Peters

元類實現ORM

1. ORM是什么

ORM 是 python編程語言后端web框架 Django的核心思想，“Object Relational MApping”，即對象-關系映射，簡稱ORM。

一個句話理解就是：創建一個實例對象，用創建它的類名當做數據表名，用創建它的類屬性對應數據表的字段，當對這個實例對象操作時，能夠對應MySQL語句

demo:

class User(父類省略):
 uid = ('uid', "int unsigned")
 name = ('username', "varchar(30)")
 email = ('email', "varchar(30)")
 password = ('password', "varchar(30)")
 ...省略...
u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')
u.save()
# 對應如下sql語句
# insert into User (username,email,password,uid)
# values ('Michael','test@orm.org','my-pwd',12345)

說明

所謂的ORM就是讓開發者在操作數據庫的時候，能夠像操作對象時通過xxxx.屬性=yyyy一樣簡單，這是開發ORM的初衷

只不過ORM的實現較為復雜，Django中已經實現了 很復雜的操作，本節知識 主要通過完成一個 insert相類似的ORM，理解其中的道理就就可以了

2. 通過元類簡單實現ORM中的insert功能

class ModelMetaclass(type):
 def __new__(cls, name, bases, attrs):
 mappings = dict()
 # 判斷是否需要保存
 for k, v in attrs.items():
 # 判斷是否是指定的StringField或者IntegerField的實例對象
 if isinstance(v, tuple):
 print('Found mapping: %s ==> %s' % (k, v))
 mappings[k] = v
 # 刪除這些已經在字典中存儲的屬性
 for k in mappings.keys():
 attrs.pop(k)
 # 將之前的uid/name/email/password以及對應的對象引用、類名字
 attrs['__mappings__'] = mappings # 保存屬性和列的映射關系
 attrs['__table__'] = name # 假設表名和類名一致
 return type.__new__(cls, name, bases, attrs)
class User(metaclass=ModelMetaclass):
 uid = ('uid', "int unsigned")
 name = ('username', "varchar(30)")
 email = ('email', "varchar(30)")
 password = ('password', "varchar(30)")
 # 當指定元類之后，以上的類屬性將不在類中，而是在__mappings__屬性指定的字典中存儲
 # 以上User類中有 
 # __mappings__ = {
 # "uid": ('uid', "int unsigned")
 # "name": ('username', "varchar(30)")
 # "email": ('email', "varchar(30)")
 # "password": ('password', "varchar(30)")
 # }
 # __table__ = "User"
 def __init__(self, **kwargs):
 for name, value in kwargs.items():
 setattr(self, name, value)
 def save(self):
 fields = []
 args = []
 for k, v in self.__mappings__.items():
 fields.append(v[0])
 args.append(getattr(self, k, None))
 sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join([str(i) for i in args]))
 print('SQL: %s' % sql)
u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')
# print(u.__dict__)
u.save()

執行的效果:

Found mapping: password ==> ('password', 'varchar(30)')
Found mapping: email ==> ('email', 'varchar(30)')
Found mapping: uid ==> ('uid', 'int unsigned')
Found mapping: name ==> ('username', 'varchar(30)')
SQL: insert into User (uid,password,username,email) values (12345,my-pwd,Michael,test@orm.org)

3. 完善對數據類型的檢測

class ModelMetaclass(type):
 def __new__(cls, name, bases, attrs):
 mappings = dict()
 # 判斷是否需要保存
 for k, v in attrs.items():
 # 判斷是否是指定的StringField或者IntegerField的實例對象
 if isinstance(v, tuple):
 print('Found mapping: %s ==> %s' % (k, v))
 mappings[k] = v
 # 刪除這些已經在字典中存儲的屬性
 for k in mappings.keys():
 attrs.pop(k)
 # 將之前的uid/name/email/password以及對應的對象引用、類名字
 attrs['__mappings__'] = mappings # 保存屬性和列的映射關系
 attrs['__table__'] = name # 假設表名和類名一致
 return type.__new__(cls, name, bases, attrs)
class User(metaclass=ModelMetaclass):
 uid = ('uid', "int unsigned")
 name = ('username', "varchar(30)")
 email = ('email', "varchar(30)")
 password = ('password', "varchar(30)")
 # 當指定元類之后，以上的類屬性將不在類中，而是在__mappings__屬性指定的字典中存儲
 # 以上User類中有 
 # __mappings__ = {
 # "uid": ('uid', "int unsigned")
 # "name": ('username', "varchar(30)")
 # "email": ('email', "varchar(30)")
 # "password": ('password', "varchar(30)")
 # }
 # __table__ = "User"
 def __init__(self, **kwargs):
 for name, value in kwargs.items():
 setattr(self, name, value)
 def save(self):
 fields = []
 args = []
 for k, v in self.__mappings__.items():
 fields.append(v[0])
 args.append(getattr(self, k, None))
 args_temp = list()
 for temp in args:
 # 判斷入如果是數字類型
 if isinstance(temp, int):
 args_temp.append(str(temp))
 elif isinstance(temp, str):
 args_temp.append("""'%s'""" % temp)
 sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(args_temp))
 print('SQL: %s' % sql)
u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')
# print(u.__dict__)
u.save()

運行效果如下:

Found mapping: uid ==> ('uid', 'int unsigned')
Found mapping: password ==> ('password', 'varchar(30)')
Found mapping: name ==> ('username', 'varchar(30)')
Found mapping: email ==> ('email', 'varchar(30)')
SQL: insert into User (email,uid,password,username) values ('test@orm.org',12345,'my-pwd','Michael')

4. 抽取到基類中

class ModelMetaclass(type):
 def __new__(cls, name, bases, attrs):
 mappings = dict()
 # 判斷是否需要保存
 for k, v in attrs.items():
 # 判斷是否是指定的StringField或者IntegerField的實例對象
 if isinstance(v, tuple):
 print('Found mapping: %s ==> %s' % (k, v))
 mappings[k] = v
 # 刪除這些已經在字典中存儲的屬性
 for k in mappings.keys():
 attrs.pop(k)
 # 將之前的uid/name/email/password以及對應的對象引用、類名字
 attrs['__mappings__'] = mappings # 保存屬性和列的映射關系
 attrs['__table__'] = name # 假設表名和類名一致
 return type.__new__(cls, name, bases, attrs)
class Model(object, metaclass=ModelMetaclass):
 def __init__(self, **kwargs):
 for name, value in kwargs.items():
 setattr(self, name, value)
 def save(self):
 fields = []
 args = []
 for k, v in self.__mappings__.items():
 fields.append(v[0])
 args.append(getattr(self, k, None))
 args_temp = list()
 for temp in args:
 # 判斷入如果是數字類型
 if isinstance(temp, int):
 args_temp.append(str(temp))
 elif isinstance(temp, str):
 args_temp.append("""'%s'""" % temp)
 sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(args_temp))
 print('SQL: %s' % sql)
class User(Model):
 uid = ('uid', "int unsigned")
 name = ('username', "varchar(30)")
 email = ('email', "varchar(30)")
 password = ('password', "varchar(30)")
u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')
# print(u.__dict__)
u.save()