本文程式設計環境：Jupyter NoteBook python3

類也是物件

在大多數程式語言中，類就是一組用來描述如何生成一個物件的程式碼段。在 Python 中這一點仍然成立：

class ObjectCreator(object):
    pass

my_object = ObjectCreator()
my_object

<__main__.ObjectCreator at 0x233e50a8ba8>

但是，Python 中的類還遠不止如此。類同樣也是一種物件。只要你使用關鍵字 class，Python 直譯器在執行的時候就會建立一個物件。下面的程式碼段：

class ObjectCreator(object):
    pass

將在記憶體中建立一個物件，名字就是 ObjectCreator。這個物件（類）自身擁有建立物件（類例項）的能力，而這就是為什麼它是一個類的原因。但是，它的本質仍然是一個物件，於是乎你可以對它做如下的操作：

1. 你可以將它賦值給一個變數
2. 你可以拷貝它
3. 你可以為它增加屬性
4. 你可以將它作為函式引數進行傳遞

你可以列印一個類，因為它其實也是一個物件

print(ObjectCreator)     

<class `__main__.ObjectCreator`>

你可以將類做為引數傳給函式

def echo(o):
    print(o)
    
echo(ObjectCreator)        

<class `__main__.ObjectCreator`>

你可以為類增加屬性

print(hasattr(ObjectCreator, `new_attribute`))

False

ObjectCreator.new_attribute = `foo` 
print(hasattr(ObjectCreator, `new_attribute`))

True

print(ObjectCreator.new_attribute)

foo

你可以將類賦值給一個變數

ObjectCreatorMirror = ObjectCreator 

print(ObjectCreatorMirror())

<__main__.ObjectCreator object at 0x00000233E51241D0>

動態地建立類

因為類也是物件，你可以在執行時動態的建立它們，就像其他任何物件一樣。首先，你可以在函式中建立類，使用 class 關鍵字即可。

def choose_class(name):
    if name == `foo`:
        class Foo(object):
            pass
        return Foo     # 返回的是類，不是類的例項
    else:
        class Bar(object):
            pass
        return Bar

MyClass = choose_class(`foo`)

print(MyClass)              # 函式返回的是類，不是類的例項

<class `__main__.choose_class.<locals>.Foo`>

print(MyClass())            # 你可以通過這個類建立類例項，也就是物件

<__main__.choose_class.<locals>.Foo object at 0x00000233E51242E8>

但這還不夠動態，因為你仍然需要自己編寫整個類的程式碼。由於類也是物件，所以它們必須是通過什麼東西來生成的才對。當你使用 class 關鍵字時， Python 直譯器自動建立這個物件。但就和 Python 中的大多數事情一樣，Python 仍然提供給你手動處理的方法。還記得內建函式 type 嗎？這個古老但強大的函式能夠讓你知道一個物件的型別是什麼，就像這樣：

type(1)

int

type("1")

str

type(ObjectCreator)

type

type(ObjectCreator())

__main__.ObjectCreator

type 動態的建立類

這裡，type 有一種完全不同的能力，它也能動態的建立類。type 可以接受一個類的描述作為引數，然後返回一個類。（我們知道，根據傳入引數的不同，同一個函式擁有兩種完全不同的用法是一件很傻的事情，但這在 Python 中是為了保持向後相容性）。

type 可以像這樣工作：

type(類名, 父類的元組 （針對繼承的情況，可以為空），包含屬性的字典（名稱和值）)

比如下面的程式碼：

class MyShinyClass(object):
    pass

可以手動像這樣建立：

MyShinyClass = type(`MyShinyClass`, (), {})  # 返回一個類物件
MyShinyClass

__main__.MyShinyClass

MyShinyClass()  #  建立一個該類的例項

<__main__.MyShinyClass at 0x233e51240f0>

你會發現我們使用 "MyShinyClass" 作為類名，並且也可以把它當做一個變數來作為類的引用。類和變數是不同的，這裡沒有任何理由把事情弄的複雜。

type 接受一個字典來為類定義屬性，因此

class Foo(object):
    bar = True

可以翻譯為：

Foo = type(`Foo`, (), {`bar`:True})

並且可以將 Foo 當成一個普通的類一樣使用：

Foo

__main__.Foo

Foo.bar

True

f = Foo()
f

<__main__.Foo at 0x233e5124be0>

f.bar

True

當然，你可以向這個類繼承，所以，如下的程式碼：

class FooChild(Foo):
    pass

就可以寫成：

FooChild = type(`FooChild`, (Foo,),{})
print(FooChild)
print(FooChild.bar)   # bar屬性是由 Foo 繼承而來

<class `__main__.FooChild`>
True

最終你會希望為你的類增加方法。只需要定義一個有著恰當簽名的函式並將其作為屬性賦值就可以了。

def echo_bar(self):
    print(self.bar)

FooChild = type(`FooChild`, (Foo,), {`echo_bar`: echo_bar})
hasattr(Foo, `echo_bar`)

False

hasattr(FooChild, `echo_bar`)

True

my_foo = FooChild()
my_foo.echo_bar()

True

你可以看到，在 Python 中，類也是物件，你可以動態的建立類。這就是當你使用關鍵字 class 時 Python 在幕後做的事情，而這就是通過元類來實現的。

Test = type(`Test`,(),{})
print(Test)
help(Test)

<class `__main__.Test`>
Help on class Test in module __main__:

class Test(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

Dog = type(`Dog`,(),{`name`:`二哈`,`age`:1})
print(Dog)
help(Dog)

<class `__main__.Dog`>
Help on class Dog in module __main__:

class Dog(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  age = 1
 |  
 |  name = `二哈`

Dog = type(`Dog`,(),{`name`:`二哈`,`age`:1})
print(Dog)
help(Dog)

DogChild = type(`DogChild`, (Dog,),{})
print(DogChild)
print(DogChild.name)

<class `__main__.Dog`>
Help on class Dog in module __main__:

class Dog(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  age = 1
 |  
 |  name = `二哈`

<class `__main__.DogChild`>
二哈

help(DogChild)

Help on class DogChild in module __main__:

class DogChild(Dog)
 |  Method resolution order:
 |      DogChild
 |      Dog
 |      builtins.object
 |  
 |  Data descriptors inherited from Dog:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from Dog:
 |  
 |  age = 1
 |  
 |  name = `二哈`

使用 type 建立帶有方法的類

#普通方法
def test(self):
    print("test")

#靜態方法
@staticmethod
def static_test():
    print("static_test")

#類方法
@classmethod
def class_test(cls):
    print("class_test")

Test = type(`Test`,(),{`name`:`name`,`test`:test,`static_test`:static_test,`class_test`:class_test})
print(Test)

test = Test()
test.test()
test.static_test()
test.class_test()

<class `__main__.Test`>
test
static_test
class_test

元類

元類就是用來建立類的「東西」。你建立類就是為了建立類的例項物件，不是嗎？但是我們已經學習到了 Python 中的類也是物件。好吧，元類就是用來建立這些類（物件）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass()
MyObject = MyClass()

你已經看到了 type 可以讓你像這樣做：

MyClass = type(`MyClass`, (), {})

這是因為函式 type 實際上是一個元類。type 就是 Python 在背後用來建立所有類的元類。現在你想知道那為什麼 type 會全部採用小寫形式而不是Type 呢？好吧，我猜這是為了和 str 保持一致性，str 是用來建立字串物件的類，而 int 是用來建立整數物件的類。type 就是建立類物件的類。你可以通過檢查 __class__ 屬性來看到這一點。Python 中所有的東西，注意，我是指所有的東西——都是物件。這包括整數、字串、函式以及類。它們全部都是物件，而且它們都是從一個類建立而來。

a = b`a2`
a.__class__

bytes

age = 35
age.__class__

int

name = `bob`
name.__class__

str

def foo(): pass

foo.__class__

function

class Bar(object): pass

b = Bar()
b.__class__

__main__.Bar

Bar.__class__

type

現在，對於任何一個 __class__ 的 __class__ 屬性又是什麼呢？

a.__class__.__class__

type

age.__class__.__class__

type

foo.__class__.__class__

type

b.__class__.__class__

type

因此，元類就是建立類這種物件的東西。如果你喜歡的話，可以把元類稱為「類工廠」。 type 就是 Python 的內建元類，當然了，你也可以建立自己的元類。

在 python2 中可以通過定義一個類級別屬性 __metaclass__ 來實建立元類，不過在 python3 中取消了 __metaclass__ 屬性。python3 中可以通過在定義類的時候宣告 metaclass 引數來建立元類。

class UpperAttrMetaClass(type):
    # __new__ 是在 __init__ 之前被呼叫的特殊方法
    # __new__ 是用來建立物件並返回之的方法
    # 而 __init__ 只是用來將傳入的引數初始化給物件
    # 你很少用到 __new__，除非你希望能夠控制物件的建立
    # 這裡，建立的物件是類，我們希望能夠自定義它，所以我們這裡改寫 __new__
    # 如果你希望的話，你也可以在 __init__ 中做些事情
    # 還有一些高階的用法會涉及到改寫 __call__ 特殊方法，但是我們這裡不用
    def __new__(cls, future_class_name, future_class_parents, future_class_attr):
        #遍歷屬性字典，把不是 __ 開頭的屬性名字變為大寫
        newAttr = {}
        for name,value in future_class_attr.items():
            if not name.startswith("__"):
                newAttr[name.upper()] = value

        # 方法1：通過 `type` 來做類物件的建立
        # 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)

#python2的用法
#class Foo(object):
#    __metaclass__ = UpperAttrMetaClass
#    bar = `bip`

# python3的用法
class Foo(object, metaclass = UpperAttrMetaClass):
     bar = `bip`

print(hasattr(Foo, `bar`))
# 輸出: False
print(hasattr(Foo, `BAR`))
# 輸出:True

f = Foo()
print(f.BAR)
# 輸出:`bip`

就是這樣，除此之外，關於元類真的沒有別的可說的了。使用到元類的程式碼比較複雜，這背後的原因倒並不是因為元類本身，而是因為你通常會使用元類去做一些晦澀的事情，依賴於自省，控制繼承等等。確實，用元類來搞些“黑暗魔法”是特別有用的，因而會搞出些複雜的東西來。但就元類本身而言，它們其實是很簡單的：

1. 攔截類的建立
2. 修改類
3. 返回修改之後的類

為什麼要用 metaclass 類而不是函式?

由於 metaclass 可以接受任何可呼叫的物件，那為何還要使用類呢，因為很顯然使用類會更加複雜啊？這裡有好幾個原因：

1. 意圖會更加清晰。當你讀到 UpperAttrMetaclass(type) 時，你知道接下來要發生什麼。
2. 你可以使用 OOP 程式設計。元類可以從元類中繼承而來，改寫父類的方法。元類甚至還可以使用元類。
3. 你可以把程式碼組織的更好。當你使用元類的時候肯定不會是像我上面舉的這種簡單場景，通常都是針對比較複雜的問題。將多個方法歸總到一個類中會很有幫助，也會使得程式碼更容易閱讀。
4. 你可以使用 __new__, __init__ 以及 __call__ 這樣的特殊方法。它們能幫你處理不同的任務。就算通常你可以把所有的東西都在 __new__ 裡處理掉，有些人還是覺得用 __init__ 更舒服些。
5. 哇哦，這東西的名字是 metaclass，肯定非善類，我要小心！

究竟為什麼要使用元類？

現在回到我們的大主題上來，究竟是為什麼你會去使用這樣一種容易出錯且晦澀的特性？好吧，一般來說，你根本就用不上它：

• 『元類就是深度的魔法，(99\%) 的使用者應該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類，那麼你就不需要它。那些實際用到元類的人都非常清楚地知道他們需要做什麼，而且根本不需要解釋為什麼要用元類。』 —— Python 界的領袖 Tim Peters
• 元類的主要用途是建立 API。一個典型的例子是 Django ORM。它允許你像這樣定義：

class Person(models.Model):
    name = models.CharField(max_length=30)
    age = models.IntegerField()

但是如果你像這樣做的話:

guy  = Person(name=`bob`, age=`35`)
print(guy.age)

這並不會返回一個 IntegerField 物件，而是會返回一個 int，甚至可以直接從資料庫中取出資料。這是有可能的，因為 models.Model 定義了metaclass， 並且使用了一些魔法能夠將你剛剛定義的簡單的 Person 類轉變成對資料庫的一個複雜 hook。Django 框架將這些看起來很複雜的東西通過暴露出一個簡單的使用元類的 API 將其化簡，通過這個 API 重新建立程式碼，在背後完成真正的工作。

結語

首先，你知道了類其實是能夠建立出類例項的物件。好吧，事實上，類本身也是例項，當然，它們是元類的例項。

class Foo(object): pass
id(Foo)

2421904320648

Python 中的一切都是物件，它們要麼是類的例項，要麼是元類的例項，除了 type。type 實際上是它自己的元類，在純 Python 環境中這可不是你能夠做到的，這是通過在實現層面耍一些小手段做到的。其次，元類是很複雜的。對於非常簡單的類，你可能不希望通過使用元類來對類做修改。你可以通過其他兩種技術來修改類：

• Monkey patching
• class decorators

當你需要動態修改類時，(99\%) 的時間裡你最好使用上面這兩種技術。當然了，其實在 (99\%) 的時間裡你根本就不需要動態修改類。

更多內容可參考：9.15 定義有可選引數的元類

附加例項

例項1：增加一個 __author__ 類屬性

class Author(type):
    def __new__(cls, name, bases, attrs):
        attrs[`__author__`] = `xiemanR`
        return type.__new__(cls, name, bases, attrs)


class MyBlog(metaclass=Author):
    pass


print(MyBlog.__author__)

a = MyBlog()
print(a.__author__)

xiemanR
xiemanR

class Singleton(type):
    def __new__(cls, name, bases, attrs):
        print(`new`)
        attrs[`instance`] = None
        return super(Singleton, cls).__new__(cls, name, bases, attrs)

    def __call__(cls, *args, **kwargs):
        print(`call`)
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls.instance


class Foo(metaclass=Singleton):
    pass

x = Foo()
y = Foo()
print(id(x))
print(id(y))

new
call
call
2421910133840
2421910133840

class Upper(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith(`__`))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        return type.__new__(cls, name, bases, uppercase_attr)


class Bar(metaclass=Upper):
    foo = `foo`
    test = `test`

b = Bar()
print(b.FOO)
print(b.TEST)

foo
test

探尋有趣之事！