Python元編程：控制你想控制的一切

不少人不理解「元編程」是個什麼東西，關於它也沒有一個十分準確的定義。這篇文章要說的是Python裏的元編程，實際上也不必定就真的符合「元編程」的定義。只不過我沒法找到一個更準確的名字來表明這篇文章的主題，因此就借了這麼一個名號。

副標題是控制你想控制的一切，實際上這篇文章講的都是一個東西，利用Python提供給咱們的特性，儘量的使代碼優雅簡潔。具體而言，經過編程的方法，在更高的抽象層次上對一種層次的抽象的特性進行修改。

首先說，Python中一切皆對象，老生常談。還有，Python提供了許多特殊方法、元類等等這樣的「元編程」機制。像給對象動態添加屬性方法之類的，在Python中根本談不上是「元編程」，但在某些靜態語言中倒是須要必定技巧的東西。咱們來談些Python程序員也容易被搞糊塗的東西。

咱們先來把對象分分層次，一般咱們知道一個對象有它的類型，老早之前Python就將類型也實現爲對象。這樣咱們就有了實例對象和類對象。這是兩個層次。稍有基礎的讀者就會知道還有元類這個東西的存在，簡言之，元類就是「類」的「類」，也就是比類更高層次的東西。這又有了一個層次。還有嗎？

ImportTime vs RunTime

若是咱們換個角度，不用非得和以前的三個層次使用一樣的標準。咱們再來區分兩個東西：ImportTime和RunTime，它們之間也並不是界限分明，顧名思義，就是兩個時刻，導入時和運行時。

當一個模塊被導入時，會發生什麼？在全局做用域的語句（非定義性語句）被執行。函數定義呢？一個函數對象被建立，但其中的代碼不會被執行。類定義呢？一個類對象被建立，類定義域的代碼被執行，類的方法中的代碼天然也不會被執行。

執行時呢？函數和方法中的代碼會被執行。固然你要先調用它們。

元類

因此咱們能夠說元類和類是屬於ImportTime的，import一個模塊以後，它們就會被建立。實例對象屬於RunTime，單import是不會建立實例對象的。不過話不能說的太絕對，由於若是你要是在模塊做用域實例化類，實例對象也是會被建立的。只不過咱們一般把它們寫在函數裏面，因此這樣劃分。

若是你想控制產生的實例對象的特性該怎麼作？太簡單了，在類定義中重寫__init__方法。那麼咱們要控制類的一些性質呢？有這種需求嗎？固然有！

經典的單例模式，你們都知道有不少種實現方式。要求就是，一個類只能有一個實例。

最簡單的實現方法是這樣的

class _Spam:
    def __init__(self):
        print("Spam!!！")

_spam_singleton =None

def Spam():
    global _spam_singleton
    if _spam_singleton is not None:
        return _spam_singleton
    else:
        _spam_singleton = _Spam()
        return _spam_singleton
複製代碼

工廠模式，不太優雅。咱們再來審視一下需求，要一個類只能有一個實例。咱們在類中定義的方法都是實例對象的行爲，那麼要想改變類的行爲，就須要更高層次的東西。元類在這個時候登場在合適不過了。前面說過，元類是類的類。也就是說，元類的__init__方法就是類的初始化方法。 咱們知道還有__call__這個東西，它能讓實例像函數那樣被調用，那麼元類的這個方法就是類在被實例化時調用的方法。

代碼就能夠寫出來了:

class Singleton(type):
    def __init__(self, *args, **kwargs):
        self._instance = None
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self._instance is None:
            self._instance = super().__call__(*args, **kwargs)
            return self._instance
        else:
            return self._instance


class Spam(metaclass=Singleton):
    def __init__(self):
        print("Spam!!!")
複製代碼

主要有兩個地方和通常的類定義不一樣，一是Singleton的基類是type，一是Spam定義的地方有一個metaclass=Singleton。type是什麼？它是object的子類，object是它的實例。也就是說，type是全部類的類，也就是最基本的元類，它規定了一些全部類在產生時須要的一些操做。因此咱們的自定義元類須要子類化type。同時type也是一個對象，因此它又是object的子類。有點不太好理解，大概知道就能夠了。

裝飾器

咱們再來講說裝飾器。大多數人認爲裝飾器是Python裏面最難理解的概念之一。其實它不過就是一個語法糖，理解了函數也是對象以後。就能夠很輕易的寫出本身的裝飾器了。

from functools import wraps

def print_result(func):

    @wraps(func)
    def wrappper(*args, **kwargs):
        result = func(*args, **kwargs)
        print(result)
        return result

    return wrappper

@print_result
def add(x, y):
    return x + y
#至關於：
#add = print_result(add)

add(1, 3)
複製代碼

這裏咱們還用到了一個裝飾器@wraps，它是用來讓咱們返回的內部函數wrapper和原來的函數擁有相同的函數簽名的，基本上咱們在寫裝飾器時都要加上它。

我在註釋裏寫了，@decorator這樣的形式等價於func=decorator（func），理解了這一點，咱們就能夠寫出更多種類的裝飾器。好比類裝飾器，以及將裝飾器寫成一個類。

def attr_upper(cls):
    for attrname,value in cls.__dict__.items():
        if isinstance(value,str):
            if not value.startswith('__'):
                setattr(cls,attrname,bytes.decode(str.encode(value).upper()))
    return cls    

@attr_upper
class Person:
    sex = 'man'

print(Person.sex) # MAN
複製代碼

注意普通的裝飾器和類裝飾器實現的不一樣點。

對數據的抽象--描述符

若是咱們想讓某一些類擁有某些相同的特性，或者說能夠實如今類定義對其的控制，咱們能夠自定義一個元類，而後讓它成爲這些類的元類。若是咱們想讓某一些函數擁有某些相同的功能，又不想把代碼複製粘貼一遍，咱們能夠定義一個裝飾器。那麼，假如咱們想讓實例的屬性擁有某些共同的特色呢？有人可能會說能夠用property，固然能夠。可是這些邏輯必須在每一個類定義的時候都寫一遍。若是咱們想讓這些類的實例的某些屬性都有相同的特色的話，就能夠自定義一個描述符類。

關於描述符，這篇文章docs.python.org/3/howto/des…講得很好，同時它還講解了描述符是怎麼隱藏在函數的背後，實現函數、方法的統一和不一樣的。這裏咱們給出一些例子。

class TypedField:
    def __init__(self, _type):
        self._type = _type

    def __get__(self, instance, cls):
        if instance is None:
            return self
        else:
            return getattr(instance, self.name)

    def __set_name__(self, cls, name):
        self.name = name

    def __set__(self, instance, value):
        if not isinstance(value, self._type):
            raise TypeError('Expected' + str(self._type))
        instance.__dict__[self.name] = value

class Person:
    age = TypedField(int)
    name = TypedField(str)

    def __init__(self, age, name):
        self.age = age
        self.name = name

jack = Person(15, 'Jack')
jack.age = '15'  # 會報錯
複製代碼

在這裏面有幾個角色，TypedField是一個描述符類，Person的屬性是描述符類的實例，看似描述符是做爲Person，也就是類的屬性而不是實例屬性存在的。但實際上，一旦Person的實例訪問了同名的屬性，描述符就會起做用。須要注意的是，在Python3.5及以前的版本中，是沒有__set_name__這個特殊方法的，這意味着若是你想要知道在類定義中描述符被起了一個什麼樣的名字，是須要在描述符實例化時顯式傳遞給它的，也就是須要多一個參數。不過在Python3.6中，這個問題獲得瞭解決，只須要在描述符類定義中重寫__set_name__這個方法就行了。還須要注意的是__get__的寫法，基本上對instance的判斷是必需的，否則會報錯。緣由也不難理解，就不細說了。

控制子類的建立——代替元類的方法

在Python3.6中，咱們能夠經過實現__init_subclass__特殊方法，來自定義子類的建立，這樣咱們就能夠在某些狀況下襬脫元類這個討厭的東西。

class PluginBase:
    subclasses = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.subclasses.append(cls)

class Plugin1(PluginBase):
    pass

class Plugin2(PluginBase):
    pass
複製代碼

小結

諸如元類等元編程對於大多數人來講有些晦澀難懂，大多數時候也無需用到它們。可是大多數框架背後的實現都使用到了這些技巧，這樣才能讓使用者寫出來的代碼簡潔易懂。若是你想更深刻的瞭解這些技巧，能夠參看一些書籍例如《Fluent Python》、《Python Cookbook》（這篇文章有的內容就是參考了它們），或者看官方文檔中的某些章節例如上文說的描述符HowTo，還有Data Model一節等等。或者直接看Python的源碼，包括用Python寫的以及CPython的源碼。

記住，只有在充分理解了它們以後再去使用，也不要是個地方就想着使用這些技巧。