改變 Python 對象規(guī)則的黑魔法 Metaclass
新年新氣象，今天你學習了嗎？
今天小明哥要分享的主題是：改變類定義的神器-metaclass
看到標題，你可能會想改變類的定義有什么用呢？什么時候才需要使用metaclass呢？
今天我將帶大家設計一個簡單的orm框架，并簡單剖析一下YAML這個序列化工具的原理。
Python類的上帝-type
說到metaclass，我們首先必須清楚一個最基礎的概念就是對象是類的實例，而類是type的實例，重復一遍：
對象是類的實例 類是type的實例
在面向對象的編程模型中，類就相當于一個房子的設計圖紙，而對象則是根據(jù)這個設計圖紙建出來的房子。
下圖中，玩具模型就可以代表一個類，而具體生產(chǎn)出來的玩具就可以代表一個對象：
總之，類就是創(chuàng)建對象的模板。
而type又是創(chuàng)建類的模板，那么我們就可以通過type創(chuàng)建自己想要的類。
比如定義一個 Hello 的 class：
class?Hello(object):
????def?hello(self,?name='world'):
?????print('Hello,?%s.'?%?name)
當 Python 解釋器載入 hello 模塊時，就會依次執(zhí)行該模塊的所有語句，執(zhí)行結果就是動態(tài)創(chuàng)建出一個 Hello 的 class對象。
type()函數(shù)既可以查看一個類型或變量的類型，也可以根據(jù)參數(shù)創(chuàng)建出新的類型，比如上面那段類的定義本質上就是：
def?hello(self,?name='world'):
????print('Hello,?%s.'?%?name)
Hello?=?type('Hello',?(object,),?dict(hello=hello))
type()函數(shù)創(chuàng)建class 對象，依次傳入 3 個參數(shù)：
class 類的名稱；
繼承的父類集合，注意 Python 支持多重繼承，如果只有一個父類，別忘了 tuple 的單元素寫法；
class 的方法名稱與函數(shù)綁定以及字段名稱與對應的值，這里我們把函數(shù) fn 綁定到方法名 hello 上。
通過 type() 函數(shù)創(chuàng)建的類和直接寫 class 是完全一樣的，因為 Python 解釋器遇到 class 定義時，僅僅是掃描一下class 定義的語法，然后調(diào)用 type() 函數(shù)創(chuàng)建出 class。
正常情況下，我們肯定都是用 class Xxx... 來定義類，但是type() 函數(shù)允許我們動態(tài)創(chuàng)建出類來，這意味著Python這門動態(tài)語言支持運行期動態(tài)創(chuàng)建類。你可能感受不到這有多強大，要知道想在靜態(tài)語言運行期創(chuàng)建類，必須構造源代碼字符串再調(diào)用編譯器，或者借助一些工具生成字節(jié)碼實現(xiàn)，本質上都是動態(tài)編譯，會非常復雜。
metaclass到底是什么
那type和metaclass有什么關系呢？metaclass到底是什么呢？
我認為metaclass 其實就是type或type的子類，通過繼承type，重載__call__運算符，便可以在class類對象創(chuàng)建時作出一些修改。
對于類 MyClass：
class?MyClass():
?pass
其實相當于：
class?MyClass(metaclass?=?type):
?pass
一旦我們把它的 metaclass 設置成 MyMeta：
class?MyClass(metaclass?=?MyMeta):
?pass
MyClass 就不再由原生的 type 創(chuàng)建，而是會調(diào)用 MyMeta 的__call__運算符重載。
class?=?type(classname,?superclasses,?attributedict)?
##?變?yōu)榱?br>class?=?MyMeta(classname,?superclasses,?attributedict)
對于具有繼承關系的類：
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)建這個類對象。
假想一個很傻的例子，你決定在你的模塊里所有的類的屬性都應該是大寫形式。有好幾種方法可以辦到，但其中一種就是通過在模塊級別設定__metaclass__：
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)榇髮?/span>
????????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：復用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)
class?Foo(object,?metaclass?=?UpperAttrMetaClass):
????bar?=?'bip'
print(hasattr(Foo,?'bar'))
##?輸出:?False
print(hasattr(Foo,?'BAR'))
##?輸出:True
f?=?Foo()
print(f.BAR)
##?輸出:'bip'
簡易ORM框架的設計
ORM全稱“Object Relational Mapping”，即對象-關系映射，就是把關系數(shù)據(jù)庫的一行映射為一個對象，也就是一個類對應一個表，這樣，寫代碼更簡單，不用直接操作SQL語句。
現(xiàn)在設計一下ORM框架的調(diào)用接口，比如用戶想通過User類來操作對應的數(shù)據(jù)庫表User，我們期待他寫出這樣的代碼：
class?User(Model):
????##?定義類的屬性到列的映射：
????id?=?IntegerField('id')
????name?=?StringField('username')
????email?=?StringField('email')
????password?=?StringField('password')
##?創(chuàng)建一個實例：
u?=?User(id=12345,?name='xiaoxiaoming',?email='[email protected]',?password='my-pwd')
##?保存到數(shù)據(jù)庫：
u.save()
上面的接口通過常規(guī)方法很難或幾乎很難實現(xiàn)，但通過metaclass就會相對比較簡單。核心思想就是通過metaclass修改類的定義，將類的所有Field類型的屬性，用一個額外的字典去保存，然后從原定義中刪除。對于User創(chuàng)建對象時傳入的參數(shù)（id=12345, name='xiaoxiaoming'等）可以模仿字典的實現(xiàn)或直接繼承dict類保存起來。
其中，父類Model和屬性類型StringField、IntegerField是由ORM框架提供的，剩下的魔術方法比如save()全部由metaclass自動完成。雖然metaclass的編寫會比較復雜，但ORM的使用者用起來卻異常簡單。
首先定義Field類，它負責保存數(shù)據(jù)庫表的字段名和字段類型：
class?Field(object):
????def?__init__(self,?name,?column_type):
????????self.name?=?name
????????self.column_type?=?column_type
????def?__str__(self):
????????return?'<%s:%s>'?%?(self.__class__.__name__,?self.name)
在Field的基礎上，進一步定義各種類型的Field，比如StringField，IntegerField等等：
class?StringField(Field):
????def?__init__(self,?name):
????????super(StringField,?self).__init__(name,?'varchar(100)')
class?IntegerField(Field):
????def?__init__(self,?name):
????????super(IntegerField,?self).__init__(name,?'bigint')
下一步，編寫ModelMetaclass：
class?ModelMetaclass(type):
????def?__new__(cls,?name,?bases,?attrs):
????????if?name?==?'Model':
????????????return?type.__new__(cls,?name,?bases,?attrs)
????????print('Found?model:?%s'?%?name)
????????mappings?=?dict()
????????for?k,?v?in?attrs.items():
????????????if?isinstance(v,?Field):
????????????????print('Found?mapping:?%s?==>?%s'?%?(k,?v))
????????????????mappings[k]?=?v
????????for?k?in?mappings.keys():
????????????attrs.pop(k)
????????attrs['__mappings__']?=?mappings??##?保存屬性和列的映射關系
????????attrs.setdefault('__table__',?name)?##?當未定義__table__屬性時，表名直接使用類名
????????return?type.__new__(cls,?name,?bases,?attrs)
以及基類Model：
class?Model(dict,?metaclass=ModelMetaclass):
????def?__init__(self,?**kw):
????????super(Model,?self).__init__(**kw)
????def?__getattr__(self,?key):
????????try:
????????????return?self[key]
????????except?KeyError:
????????????raise?AttributeError(r"'Model'?object?has?no?attribute?'%s'"?%?key)
????def?__setattr__(self,?key,?value):
????????self[key]?=?value
????def?save(self):
????????fields?=?[]
????????params?=?[]
????????args?=?[]
????????for?k,?v?in?self.__mappings__.items():
????????????fields.append(v.name)
????????????params.append('?')
????????????args.append(getattr(self,?k,?None))
????????sql?=?'insert?into?%s?(%s)?values?(%s)'?%?(self.__table__,?','.join(fields),?','.join(params))
????????print('SQL:?%s'?%?sql)
????????print('ARGS:?%s'?%?str(args))
在ModelMetaclass中，一共做了幾件事情：
在當前類（比如 User）中查找定義的類的所有屬性，如果找到一個Field屬性，就把它保存到一個__mappings__的dict中，同時從類屬性中刪除該Field屬性（避免實例的屬性遮蓋類的同名屬性）；當類中未定義 __table__字段時，直接將類名保存到__table__字段中作為表名。
在Model類中，就可以定義各種操作數(shù)據(jù)庫的方法，比如save()，delete()，find()，update等等。
我們實現(xiàn)了save()方法，把一個實例保存到數(shù)據(jù)庫中。因為有表名，屬性到字段的映射和屬性值的集合，就可以構造出INSERT語句。
測試：
u?=?User(id=12345,?name='xiaoxiaoming',?email='[email protected]',?password='my-pwd')
u.save()
輸出如下：
Found?model:?User
Found?mapping:?id?==>?
Found?mapping:?name?==>?
Found?mapping:?email?==>?
Found?mapping:?password?==>?
SQL:?insert?into?User?(id,username,email,password)?values?(?,?,?,?)
ARGS:?[12345,?'xiaoxiaoming',?'[email protected]',?'my-pwd']
測試2：
class?Blog(Model):
????__table__?=?'blogs'
????id?=?IntegerField('id')
????user_id?=?StringField('user_id')
????user_name?=?StringField('user_name')
????name?=?StringField('user_name')
????summary?=?StringField('summary')
????content?=?StringField('content')
b?=?Blog(id=12345,?user_id='user_id1',?user_name='xxm',?name='orm框架的基本運行機制',?summary="簡單講述一下orm框架的基本運行機制",
?????????content="此處省略一萬字...")
b.save()
輸出：
Found?model:?Blog
Found?mapping:?id?==>?
Found?mapping:?user_id?==>?
Found?mapping:?user_name?==>?
Found?mapping:?name?==>?
Found?mapping:?summary?==>?
Found?mapping:?content?==>?
SQL:?insert?into?blogs?(id,user_id,user_name,user_name,summary,content)?values?(?,?,?,?,?,?)
ARGS:?[12345,?'user_id1',?'xxm',?'orm框架的基本運行機制',?'簡單講述一下orm框架的基本運行機制',?'此處省略一萬字...']
可以看到，save()方法已經(jīng)打印出了可執(zhí)行的SQL語句，以及參數(shù)列表，只需要真正連接到數(shù)據(jù)庫，執(zhí)行該SQL語句，就可以完成真正的功能。
YAML序列化工具的實現(xiàn)原理淺析
YAML是一個家喻戶曉的 Python 工具，可以方便地序列化 / 逆序列化結構數(shù)據(jù)。
官方文檔：https://pyyaml.org/wiki/PyYAMLDocumentation
安裝：
pip?install?pyyaml
YAMLObject 的任意子類支持序列化和反序列化（serialization & deserialization）。比如說下面這段代碼：
import?yaml
class?Monster(yaml.YAMLObject):
????yaml_tag?=?'!Monster'
????def?__init__(self,?name,?hp,?ac,?attacks):
????????self.name?=?name
????????self.hp?=?hp
????????self.ac?=?ac
????????self.attacks?=?attacks
????def?__repr__(self):
????????return?f"{self.__class__.__name__}(name={self.name},?hp={self.hp},?ac={self.ac},?attacks={self.attacks})"
monster1?=?yaml.load("""
---?!Monster
name:?Cave?spider
hp:?[2,6]
ac:?16
attacks:?[BITE,?HURT]
""")
print(monster1,?type(monster1))
monster2?=?Monster(name='Cave?lizard',?hp=[3,?6],?ac=16,?attacks=['BITE',?'HURT'])
print(yaml.dump(monster2))
運行結果：
Monster(name=Cave?spider,?hp=[2,?6],?ac=16,?attacks=['BITE',?'HURT'])?'__main__.Monster'>
!Monster
ac:?16
attacks:?[BITE,?HURT]
hp:?[3,?6]
name:?Cave?lizard
這里面調(diào)用統(tǒng)一的 yaml.load()，就能把任意一個 yaml 序列載入成一個 Python Object；而調(diào)用統(tǒng)一的 yaml.dump()，就能把一個 YAMLObject 子類序列化。
對于 load() 和 dump() 的使用者來說，他們完全不需要提前知道任何類型信息，這讓超動態(tài)配置編程成了可能。比方說，在一個智能語音助手的大型項目中，我們有 1 萬個語音對話場景，每一個場景都是不同團隊開發(fā)的。作為智能語音助手的核心團隊成員，我不可能去了解每個子場景的實現(xiàn)細節(jié)。
在動態(tài)配置實驗不同場景時，經(jīng)常是今天我要實驗場景 A 和 B 的配置，明天實驗 B 和 C 的配置，光配置文件就有幾萬行量級，工作量不可謂不小。而應用這樣的動態(tài)配置理念，就可以讓引擎根據(jù)配置文件，動態(tài)加載所需要的 Python 類。
對于 YAML 的使用者也很方便，只要簡單地繼承 yaml.YAMLObject，就能讓你的 Python Object 具有序列化和逆序列化能力。
據(jù)說即使是在大廠 Google 的 Python 開發(fā)者，發(fā)現(xiàn)能深入解釋 YAML 這種設計模式優(yōu)點的人，大概只有 10%。而能知道類似 YAML 的這種動態(tài)序列化 / 逆序列化功能正是用 metaclass 實現(xiàn)的人，可能只有 1% 了。而能夠將YAML 怎樣用 metaclass 實現(xiàn)動態(tài)序列化 / 逆序列化功能講出一二的可能只有 0.1%了。
對于YAMLObject 的 load和dump() 功能，簡單來說，我們需要一個全局的注冊器，讓 YAML 知道，序列化文本中的!Monster需要載入成 Monster 這個 Python 類型，Monster 這個 Python 類型需要被序列化為!Monster標簽開頭的字符串。
一個很自然的想法就是，那我們建立一個全局變量叫 registry，把所有需要逆序列化的 YAMLObject，都注冊進去。比如下面這樣：
registry?=?{}
?
def?add_constructor(target_class):
????registry[target_class.yaml_tag]?=?target_class
然后，在 Monster 類定義后面加上下面這行代碼：
add_constructor(Monster)
這樣的缺點很明顯，對于 YAML 的使用者來說，每一個 YAML 的可逆序列化的類 Foo 定義后，都需要加上一句話add_constructor(Foo)。這無疑給開發(fā)者增加了麻煩，也更容易出錯，畢竟開發(fā)者很容易忘了這一點。
更優(yōu)雅的實現(xiàn)方式自然是通過metaclass 解決了這個問題，YAML 的源碼正是這樣實現(xiàn)的：
class?YAMLObjectMetaclass(type):
????def?__init__(cls,?name,?bases,?kwds):
????????super(YAMLObjectMetaclass,?cls).__init__(name,?bases,?kwds)
????????if?'yaml_tag'?in?kwds?and?kwds['yaml_tag']?is?not?None:
????????????cls.yaml_loader.add_constructor(cls.yaml_tag,?cls.from_yaml)
????????????cls.yaml_dumper.add_representer(cls,?cls.to_yaml)
????##?省略其余定義
?
class?YAMLObject(metaclass=YAMLObjectMetaclass):
????yaml_loader?=?Loader
????yaml_dumper?=?Dumper
????##?省略其余定義
可以看到，YAMLObject 把 metaclass 聲明成了 YAMLObjectMetaclass，YAMLObjectMetaclass則會改變YAMLObject類和其子類的定義，就是下面這行代碼將YAMLObject 的子類加入到了yaml的兩個全局注冊表中：
cls.yaml_loader.add_constructor(cls.yaml_tag,?cls.from_yaml)
cls.yaml_dumper.add_representer(cls,?cls.to_yaml)
YAML 應用 metaclass，攔截了所有 YAMLObject 子類的定義。也就是說，在你定義任何 YAMLObject 子類時，Python 會強行插入運行上面這段代碼，把我們之前想要的add_constructor(Foo)和add_representer(Foo)給自動加上。所以 YAML 的使用者，無需自己去手寫add_constructor(Foo)和add_representer(Foo)。
總結
這次分享主要是簡單的淺析了 metaclass 的實現(xiàn)機制。通過實現(xiàn)一個orm框架并解讀 YAML 的源碼，相信你已經(jīng)對metaclass 有了不錯的理解。
metaclass 是 Python 黑魔法級別的語言特性，它可以改變類創(chuàng)建時的行為，這種強大的功能使用起來務必小心。
看完本文，你覺得裝飾器和 metaclass 有什么區(qū)別呢？歡迎下方留言和我討論。記得一鍵三連呦，筆芯！
我們的文章到此就結束啦，如果你喜歡今天的Python 實戰(zhàn)教程，請持續(xù)關注Python實用寶典。
有任何問題，可以在公眾號后臺回復：加群，回答相應紅字驗證信息，進入互助群詢問。
原創(chuàng)不易，希望你能在下面點個贊和在看支持我繼續(xù)創(chuàng)作，謝謝！
點擊下方閱讀原文可獲得更好的閱讀體驗
Python實用寶典?(pythondict.com)
不只是一個寶典
歡迎關注公眾號：Python實用寶典