系列文章
√第一章 元類編程，已完成 ;
本文目錄
類是如何產生的如何使用type創建類理解什么是元類使用元類的意義元類實戰：ORM
. 類是如何產生的
類是如何產生？這個問題肯定很傻。實則不然，很多人只知道使用繼承的表面形式來創建一個類，卻不知道其內部真正的創建是由type來創建的。
type？這不是判斷對象類型的函數嗎？
是的，type通常用法就是用來判斷對象的類型。但除此之外，他最大的用途是用來動態創建類。當Python掃描到class的語法的時候，就會調用type函數進行類的創建。
. 如何使用type創建類
首先，type()需要接收三個參數
11. 類的名稱，若不指定，也要傳入空字符串：""
22. 父類，注意以tuple的形式傳入，若沒有父類也要傳入空tuple：()，默認繼承object
33. 綁定的方法或屬性，注意以dict的形式傳入
來看個例子
1# 准備一個基類（父類）
2class BaseClass:
3 def talk(self):
4 print("i am people")
5
6# 准備一個方法
7def say(self):
8 print("hello")
9
10# 使用type來創建User類
11User = type("User", (BaseClass, ), {"name":"user", "say":say})
. 理解什么是元類
什么是類？可能誰都知道，類就是用來創建對象的「模板」。
那什么是元類呢？一句話通俗來說，元類就是創建類的「模板」。
為什么type能用來創建類？因為它本身是一個元類。使用元類創建類，那就合理了。
type是Python在背后用來創建所有類的元類，我們熟知的類的始祖 object 也是由type創建的。更有甚者，連type自己也是由type自己創建的，這就過份了。
1>>> type(type)
2<class 'type'>
3>>> type(object
4<class 'type'>
5>>> type(int)
6<class 'type'>
7>>> type(str)
8<class 'type'>
如果要形象的來理解的話，就看下面這三行話。
1str：用來創建字符串對象的類。
2int：是用來創建整數對象的類。
3type：是用來創建類對象的類。
反過來看
1一個實例的類型，是類
2一個類的類型，是元類
3一個元類的類型，是type
來看下實例
1# Python3.7
2>>> class MetaPerson(type):
3... pass
4...
5>>> class Person(metaclass=MetaPerson):
6... pass
7...
8>>> Tom = Person()
9>>> print(type(Tom))
10<class '__main__.Person'>
11>>> print(type(Tom.__class__))
12<class '__main__.MetaPerson'>
13>>> print(type(Tom.__class__.__class__))
14<class 'type'>
上面是一個簡單的示例。
下面看一個稍微完整的
1# 注意要從type繼承
2class BaseClass(type):
3 def __new__(cls, *args, **kwargs):
4 print("in BaseClass")
5 return super().__new__(cls, *args, **kwargs)
6
7class User(metaclass=BaseClass):
8 def __init__(self, name):
9 self.name = name
10
11user = User("wangbm")
. 使用元類的意義
正常情況下，我們都不會使用到元類。但是這並不意味着，它不重要。假如某一天，我們需要寫一個框架，很有可能就需要用到元類。
但是，為什么要用它呢？不要它會怎樣？
經過我的總結，元類的作用過程如下
- 攔截類的創建
- 攔截下后，進行修改
- 修改完后，返回修改后的類
很明顯，使用元類，是要對類進行定制修改。使用元類來動態生成元類的實例，而99%的開發人員是不需要動態修改類的，因為這應該是框架才需要考慮的事。
但是，這樣說，你一定不會服氣，到底元類用來干什么？其實元類的作用就是創建API，一個最典型的應用是 Django ORM。
. 元類實戰：ORM
使用過Django ORM的人都知道，有了ORM，使得我們操作數據庫，變得異常簡單。
ORM的一個類(User)，就對應數據庫中的一張表。id,name,email,password 就是字段。
1class User(BaseModel):
2 id = IntField('id')
3 name = StrField('username')
4 email = StrField('email')
5 password = StrField('password')
6
7 class Meta:
8 db_table = "user"
如果我們要插入一條數據，我們只需這樣做
1# 實例化成一條記錄
2u = User(id=20180424, name="xiaoming",
3 email="xiaoming@163.com", password="abc123")
4
5# 保存這條記錄
6u.save()
通常用戶層面，只需要懂應用，就像上面這樣操作就可以了。
但是今天我並不是來教大家如何使用ORM，我們是用來探究ORM內部究竟是如何實現的。我們也可以自己寫一個簡易的ORM。
從上面的User類中，我們看到StrField和IntField，從字段意思上看，我們很容易看出這代表兩個字段類型。字段名分別是id,username,email,password。
StrField和IntField在這里的用法，叫做屬性描述符，如果對這個不了解的可以查看文章底部的參考文章，也是我寫的。
簡單來說呢，屬性描述符可以實現對屬性值的類型，范圍等一切做約束，意思就是說變量id只能是int類型，變量name只能是str類型，否則將會拋出異常。
那如何實現這兩個屬性描述符呢？請看代碼。
1import numbers
2
3class Field:
4 pass
5
6class IntField(Field):
7 def __init__(self, name):
8 self.name = name
9 self._value = None
10
11 def __get__(self, instance, owner):
12 return self._value
13
14 def __set__(self, instance, value):
15 if not isinstance(value, numbers.Integral):
16 raise ValueError("int value need")
17 self._value = value
18
19class StrField(Field):
20 def __init__(self, name):
21 self.name = name
22 self._value = None
23
24 def __get__(self, instance, owner):
25 return self._value
26
27 def __set__(self, instance, value):
28 if not isinstance(value, str):
29 raise ValueError("string value need")
30 self._value = value
我們看到User類繼承自BaseModel，這個BaseModel里，定義了數據庫操作的各種方法，譬如我們使用的save函數，也可以放在這里面的。所以我們就可以來寫一下這個BaseModel類
1class BaseModel(metaclass=ModelMetaClass):
2 def __init__(self, *args, **kw):
3 for k,v in kw.items():
4 # 這里執行賦值操作，會進行數據描述符的__set__邏輯
5 setattr(self, k, v)
6 return super().__init__()
7
8 def save(self):
9 db_columns=[]
10 db_values=[]
11 for column, value in self.fields.items():
12 db_columns.append(str(column))
13 db_values.append(str(getattr(self, column)))
14 sql = "insert into {table} ({columns}) values({values})".format(
15 table=self.db_table, columns=','.join(db_columns),
16 values=','.join(db_values))
17 pass
從BaseModel類中，save函數里面有幾個新變量，
- fields: 存放所有的字段屬性
- db_table：表名
注意：上面代碼中class BaseModel(metaclass=ModelMetaClass)請替換成class BaseModel(object) 再閱讀。這樣更貼合思考順序。
我們思考一下這個u實例的創建過程：
type -> object -> BaseModel -> User -> u
這里會有幾個問題。
- init的參數是User實例時傳入的，所以傳入的id是int類型，name是str類型。看起來沒啥問題，若是這樣，我上面的數據描述符就失效了，不能起約束作用。所以我們希望init接收到的id是IntField類型，name是StrField類型。
- 同時，我們希望這些字段屬性，能夠自動歸類到fields變量中。因為，做為BaseModel，它可不是專門為User類服務的，它還要兼容各種各樣的表。不同的表，表里有不同數量，不同屬性的字段，這些都要能自動類別並歸類整理到一起。這是一個ORM框架最基本的。
- 我們希望對表名有兩種選擇，一個是User中若指定Meta信息，比如表名，就以此為表名，若未指定就以類名的小寫 做為表名。雖然BaseModel可以直接取到User的db_table屬性，但是如果在數據庫業務邏輯中，加入這段復雜的邏輯，顯然是很不優雅的。
上面這幾個問題，其實都可以通過元類的__new__函數來完成。
元類的__new__和普通類的可不一樣，元類的__new__，可以獲取到上層類的一切屬性和方法，包括類名，魔法方法。
而普通類的__new__ 只能獲取到實例化時外界傳入的屬性。
下面就來看看，如何用元類來解決這些問題呢？請看代碼。
1class ModelMetaClass(type):
2 def __new__(cls, name, bases, attrs):
3 if name == "BaseModel":
4 # 第一次進入__new__是創建BaseModel類，name="BaseModel"
5 # 第二次進入__new__是創建User類及其實例，name="User"
6 return super().__new__(cls, name, bases, attrs)
7
8 # 根據屬性類型，取出字段
9 fields = {k:v for k,v in attrs.items() if isinstance(v, Field)}
10
11 # 如果User中有指定Meta信息，比如表名，就以此為准
12 # 如果沒有指定，就默認以 類名的小寫 做為表名，比如User類，表名就是user
13 _meta = attrs.get("Meta", None)
14 db_table = name.lower()
15 if _meta is not None:
16 table = getattr(_meta, "db_table", None)
17 if table is not None:
18 db_table = table
19
20 # 注意原來由User傳遞過來的各項參數attrs，最好原模原樣的返回，
21 # 如果不返回，有可能下面的數據描述符不起作用
22 # 除此之外，我們可以往里面添加我們自定義的參數
23 attrs["db_table"] = db_table
24 attrs["fields"] = fields
25 return super().__new__(cls, name, bases, attrs)
至此，我們的簡易ORM就已經成型。
參考文章：
