Python進階開發之元類編程

Photo by Joyous From Lofter

本文目錄

1. 類是如何產生的

2. 如何使用type建立類

3. 理解什麼是元類

4. 使用元類的意義

5. 元類實戰：ORM

---

. 1. 類是如何產生的

類是如何產生？這個問題確定很傻。實則否則，不少人只知道使用繼承的表面形式來建立一個類，殊不知道其內部真正的建立是由type來建立的。

type？這不是判斷對象類型的函數嗎？

是的，type一般用法就是用來判斷對象的類型。但除此以外，他最大的用途是用來動態建立類。當Python掃描到class的語法的時候，就會調用type函數進行類的建立。

. 2. 如何使用type建立類

首先，type()須要接收三個參數

• 類的名稱：若不指定，也要傳入空字符串：""

• 父類：注意以tuple的形式傳入，若沒有父類也要傳入空tuple：()，默認繼承object

• 綁定的方法或屬性：注意以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})

. 3. 理解什麼是元類

什麼是類？可能誰都知道，類就是用來建立對象的「模板」。

那什麼是元類呢？一句話通俗來講，元類就是建立類的「模板」。

爲何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")

. 4. 使用元類的意義

正常狀況下，咱們都不會使用到元類。可是這並不意味着，它不重要。假如某一天，咱們須要寫一個框架，頗有可能就須要用到元類。

可是，爲何要用它呢？不要它會怎樣？

通過個人總結，元類的做用過程以下

1. 攔截類的建立

2. 攔截下後，進行修改

3. 修改完後，返回修改後的類

很明顯，使用元類，是要對類進行定製修改。使用元類來動態生成元類的實例，而99%的開發人員是不須要動態修改類的，由於這應該是框架才須要考慮的事。

可是，這樣說，你必定不會服氣，到底元類用來幹什麼？其實元類的做用就是建立API，一個最典型的應用是 Django ORM。

. 5. 元類實戰：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            _value=str(getattr(self, column))
14            db_values.append('\''+_value+'\'')
15        sql = "insert into `{table}` ({columns}) values({values})".format(
16                table=self.db_table,
17                columns=','.join(db_columns),
18                values=','.join(db_values))
19        # mysql_execute 函數能夠本身寫。調用驅動插入到數據庫
20        # 查看完整代碼請點擊文章底部查看原文
21        mysql_execute(sql)

從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就已經成型。