系列文章

√第一章 元類程式設計，已完成 ;

本文目錄

類是如何產生的如何使用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")

. 使用元類的意義

正常情況下，我們都不會使用到元類。但是這並不意味著，它不重要。假如某一天，我們需要寫一個框架，很有可能就需要用到元類。

但是，為什麼要用它呢？不要它會怎樣？

經過我的總結，元類的作用過程如下

1. 攔截類的建立
2. 攔截下後，進行修改
3. 修改完後，返回修改後的類

很明顯，使用元類，是要對類進行定製修改。使用元類來動態生成元類的例項，而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="[email protected]", 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函式裡面有幾個新變數，

1. fields: 存放所有的欄位屬性
2. 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就已經成型。