Python MetaClass 元類
MetaClass 元類
一、元類介紹
1.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>
1.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， 是不是有些驚訝。。。看下面
1.3 使用 type 建立類
type 還有一種完全不同的功能，動態的建立類。
type 可以接受一個類的描述作為引數，然後返回一個類。（要知道，根據傳入引數的不同，同一個函式擁有兩種完全不同的用法是一件很傻的事情，但這在 Python 中是為了保持向後相容性）
type 可以像這樣工作：
type(類名, 由父類名稱組成的元組（針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)
比如下面的程式碼：
class Test: # 定義了一個Test類
pass
Test() # 建立了一個Test類的例項物件
<__main__.Test at 0x10d3f8438>
可以手動像這樣建立
Test2 = type("Test2", (), {}) # 定了一個Test2類
Test2() # 建立了一個Test2類的例項物件
# <__main__.Test2 at 0x10d406b38>
我們使用"Test2"作為類名，並且也可以把它當做一個變數來作為類的引用。類和變數是不同的，這裡沒有任何理由把事情弄的複雜。即type函式中第1個實參，也可以叫做其他的名字，這個名字表示類的名字
MyDogClass = type('MyDog', (), {})
print(MyDogClass)
# <class '__main__.MyDog'>
使用 help 來測試這 2 個類
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)
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)
1.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個引數，元組中是父類的名字，而不是字串
- 新增的屬性是類屬性，並不是例項屬性
1.5 使用type建立帶有方法的類
最終你會希望為你的類增加方法。只需要定義一個有著恰當簽名的函式並將其作為屬性賦值就可以了。
- 新增例項方法：
def echo_bar(self): # 定義了一個普通的函式
print(self.bar)
FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) # 讓FooChild類中的echo_bar屬性，指向了上面定義的函式
hasattr(Foo, 'echo_bar') # 判斷Foo類中 是否有echo_bar這個屬性
# False
hasattr(FooChild, 'echo_bar') # 判斷FooChild類中 是否有echo_bar這個屬性
# True
my_foo = FooChild()
my_foo.echo_bar()
# True
- 新增靜態方法
@staticmethod
def test_static():
print("static method ....")
Foochild = type('Foochild', (Foo,), {"echo_bar": echo_bar, "test_static": test_static})
fooclid = Foochild()
fooclid.test_static
# <function __main__.test_static>
fooclid.test_static()
# static method ....
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
1.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的內建元類，當然了，你也可以建立自己的元類。
1.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 的東東都可以。
1.8 自定義元類
元類的主要目的就是為了當建立類時能夠自動地改變類。
假想一個很傻的例子，你決定在你的模組裡所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過在模組級別設定__metaclass__。採用這種方法，這個模組中的所有類都會通過這個元類來建立，我們只需要告訴元類把所有的屬性都改成大寫形式就萬事大吉了。
幸運的是，__metaclass__實際上可以被任意呼叫，它並不需要是一個正式的類。所以，我們這裡就先以一個簡單的函式作為例子開始。
#-*- 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'
就是這樣，除此之外，關於元類真的沒有別的可說的了。但就元類本身而言，它們其實是很簡單的：
-
攔截類的建立
-
修改類
-
返回修改之後的類
究竟為什麼要使用元類？
現在回到我們的大主題上來，究竟是為什麼你會去使用這樣一種容易出錯且晦澀的特性？好吧，一般來說，你根本就用不上它：
“元類就是深度的魔法，99%的使用者應該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類，那麼你就不需要它。那些實際用到元類的人都非常清楚地知道他們需要做什麼，而且根本不需要解釋為什麼要用元類。” —— Python界的領袖 Tim Peters
二、元類實現 ORM
2.1 ORM是什麼
ORM 是 Python 程式語言後端 web 框架 Django 的核心思想，“Object Relational Mapping”，即物件-關係對映，簡稱ORM。
一個句話理解就是：建立一個例項物件，用建立它的類名當做資料表名，用建立它的類屬性對應資料表的欄位，當對這個例項物件操作時，能夠對應MySQL語句
示例：
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='[email protected]', password='my-pwd')
u.save()
# 對應如下sql語句
# insert into User (username,email,password,uid)
# values ('Michael','[email protected]','my-pwd',12345)
說明
-
所謂的 ORM 就是讓開發者在操作資料庫的時候，能夠像操作物件時通過
xxxx.屬性 = yyyy一樣簡單，這是開發 ORM 的初衷 -
只不過 ORM 的實現較為複雜，Django 中已經實現了 很複雜的操作，本節知識 主要通過完成一個 insert 相類似的 ORM，理解其中的道理就就可以了
2.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='[email protected]', 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,[email protected])
2.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='[email protected]', 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 ('[email protected]',12345,'my-pwd','Michael')
2.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='[email protected]', password='my-pwd')
# print(u.__dict__)
u.save()