元類

1. 類也是對(duì)象

在大多數(shù)編程語(yǔ)言中，類就是一組用來(lái)描述如何生成一個(gè)對(duì)象的代碼段。在Python中這一點(diǎn)仍然成立：

>>> class ObjectCreator(object): … pass … >>> my_object = ObjectCreator() >>> print(my_object) <__main__.ObjectCreator object at 0x8974f2c>

但是，Python中的類還遠(yuǎn)不止如此。類同樣也是一種對(duì)象。是的，沒(méi)錯(cuò)，就是對(duì)象。只要你使用關(guān)鍵字class，Python解釋器在執(zhí)行的時(shí)候就會(huì)創(chuàng)建一個(gè)對(duì)象。

下面的代碼段：

>>> class ObjectCreator(object): … pass …

將在內(nèi)存中創(chuàng)建一個(gè)對(duì)象，名字就是ObjectCreator。這個(gè)對(duì)象（類對(duì)象ObjectCreator）擁有創(chuàng)建對(duì)象（實(shí)例對(duì)象）的能力。但是，它的本質(zhì)仍然是一個(gè)對(duì)象，于是乎你可以對(duì)它做如下的操作：

你可以將它賦值給一個(gè)變量

你可以拷貝它

你可以為它增加屬性

你可以將它作為函數(shù)參數(shù)進(jìn)行傳遞

下面是示例：

>>> print(ObjectCreator) # 你可以打印一個(gè)類，因?yàn)樗鋵?shí)也是一個(gè)對(duì)象 <class '__main__.ObjectCreator'> >>> def echo(o): … print(o) … >>> echo(ObjectCreator) # 你可以將類做為參數(shù)傳給函數(shù) <class '__main__.ObjectCreator'> >>> print(hasattr(ObjectCreator, 'new_attribute')) Fasle >>> ObjectCreator.new_attribute = 'foo' # 你可以為類增加屬性 >>> print(hasattr(ObjectCreator, 'new_attribute')) True >>> print(ObjectCreator.new_attribute) foo >>> ObjectCreatorMirror = ObjectCreator # 你可以將類賦值給一個(gè)變量 >>> print(ObjectCreatorMirror()) <__main__.ObjectCreator object at 0x8997b4c>

2. 動(dòng)態(tài)地創(chuàng)建類

因?yàn)轭愐彩菍?duì)象，你可以在運(yùn)行時(shí)動(dòng)態(tài)的創(chuàng)建它們，就像其他任何對(duì)象一樣。首先，你可以在函數(shù)中創(chuàng)建類，使用class關(guān)鍵字即可。

>>> def choose_class(name): … if name == 'foo': … class Foo(object): … pass … return Foo # 返回的是類，不是類的實(shí)例 … else: … class Bar(object): … pass … return Bar … >>> MyClass = choose_class('foo') >>> print(MyClass) # 函數(shù)返回的是類，不是類的實(shí)例 <class '__main__'.Foo> >>> print(MyClass()) # 你可以通過(guò)這個(gè)類創(chuàng)建類實(shí)例，也就是對(duì)象 <__main__.Foo object at 0x89c6d4c>

但這還不夠動(dòng)態(tài)，因?yàn)槟闳匀恍枰约壕帉?xiě)整個(gè)類的代碼。由于類也是對(duì)象，所以它們必須是通過(guò)什么東西來(lái)生成的才對(duì)。

當(dāng)你使用class關(guān)鍵字時(shí)，Python解釋器自動(dòng)創(chuàng)建這個(gè)對(duì)象。但就和Python中的大多數(shù)事情一樣，Python仍然提供給你手動(dòng)處理的方法。

還記得內(nèi)建函數(shù)type嗎？這個(gè)古老但強(qiáng)大的函數(shù)能夠讓你知道一個(gè)對(duì)象的類型是什么，就像這樣：

>>> print(type(1)) # 數(shù)值的類型 <type 'int'> >>> print(type("1")) # 字符串的類型 <type 'str'> >>> print(type(ObjectCreator())) # 實(shí)例對(duì)象的類型 <class '__main__.ObjectCreator'> >>> print(type(ObjectCreator)) # 類的類型 <type 'type'>

仔細(xì)觀察上面的運(yùn)行結(jié)果，發(fā)現(xiàn)使用type對(duì)ObjectCreator查看類型是，答案為type， 是不是有些驚訝。。。看下面

3. 使用type創(chuàng)建類

type還有一種完全不同的功能，動(dòng)態(tài)的創(chuàng)建類。

type可以接受一個(gè)類的描述作為參數(shù)，然后返回一個(gè)類。（要知道，根據(jù)傳入?yún)?shù)的不同，同一個(gè)函數(shù)擁有兩種完全不同的用法是一件很傻的事情，但這在Python中是為了保持向后兼容性）

type可以像這樣工作：

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

比如下面的代碼：

In [2]: class Test: #定義了一個(gè)Test類...: pass...: In [3]: Test() # 創(chuàng)建了一個(gè)Test類的實(shí)例對(duì)象 Out[3]: <__main__.Test at 0x10d3f8438>

可以手動(dòng)像這樣創(chuàng)建：

Test2 = type("Test2", (), {}) # 定了一個(gè)Test2類 In [5]: Test2() # 創(chuàng)建了一個(gè)Test2類的實(shí)例對(duì)象 Out[5]: <__main__.Test2 at 0x10d406b38>

我們使用"Test2"作為類名，并且也可以把它當(dāng)做一個(gè)變量來(lái)作為類的引用。類和變量是不同的，這里沒(méi)有任何理由把事情弄的復(fù)雜。即type函數(shù)中第1個(gè)實(shí)參，也可以叫做其他的名字，這個(gè)名字表示類的名字

In [23]: MyDogClass = type('MyDog', (), {})In [24]: print(MyDogClass) <class '__main__.MyDog'>

使用help來(lái)測(cè)試這2個(gè)類

In [10]: help(Test) # 用help查看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) In [8]: help(Test2) #用help查看Test2類Help on class Test2 in module __main__:class Test2(builtins.object)| Data descriptors defined here:|| __dict__| dictionary for instance variables (if defined)|| __weakref__| list of weak references to the object (if defined)

4. 使用type創(chuàng)建帶有屬性的類

type 接受一個(gè)字典來(lái)為類定義屬性，因此

>>> Foo = type('Foo', (), {'bar': True})

可以翻譯為：

>>> class Foo(object): … bar = True

并且可以將Foo當(dāng)成一個(gè)普通的類一樣使用：

>>> print(Foo) <class '__main__.Foo'> >>> print(Foo.bar) True >>> f = Foo() >>> print(f) <__main__.Foo object at 0x8a9b84c> >>> print(f.bar) True

當(dāng)然，你可以繼承這個(gè)類，代碼如下：

>>> class FooChild(Foo): … pass

就可以寫(xiě)成：

>>> FooChild = type('FooChild', (Foo,), {}) >>> print(FooChild) <class '__main__.FooChild'> >>> print(FooChild.bar) # bar屬性是由Foo繼承而來(lái) True

注意：

• type的第2個(gè)參數(shù)，元組中是父類的名字，而不是字符串
• 添加的屬性是類屬性，并不是實(shí)例屬性

5. 使用type創(chuàng)建帶有方法的類

最終你會(huì)希望為你的類增加方法。只需要定義一個(gè)有著恰當(dāng)簽名的函數(shù)并將其作為屬性賦值就可以了。

添加實(shí)例方法

In [46]: def echo_bar(self): # 定義了一個(gè)普通的函數(shù)...: print(self.bar)...:In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) # 讓FooChild類中的echo_bar屬性，指向了上面定義的函數(shù)In [48]: hasattr(Foo, 'echo_bar') # 判斷Foo類中 是否有echo_bar這個(gè)屬性 Out[48]: FalseIn [49]:In [49]: hasattr(FooChild, 'echo_bar') # 判斷FooChild類中 是否有echo_bar這個(gè)屬性 Out[49]: TrueIn [50]: my_foo = FooChild()In [51]: my_foo.echo_bar() True

添加靜態(tài)方法

In [36]: @staticmethod...: def test_static():...: print("static method ....")...:In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar": echo_bar, "test_static": test_static})In [38]: fooclid = Foochild()In [39]: fooclid.test_static Out[39]: <function __main__.test_static>In [40]: fooclid.test_static() static method ....In [41]: fooclid.echo_bar() True

添加類方法

In [42]: @classmethod...: def test_class(cls):...: print(cls.bar)...:In [43]:In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "test_static": test_static, "test_class": test_class})In [44]:In [44]: fooclid = Foochild()In [45]: fooclid.test_class() True

你可以看到，在Python中，類也是對(duì)象，你可以動(dòng)態(tài)的創(chuàng)建類。這就是當(dāng)你使用關(guān)鍵字class時(shí)Python在幕后做的事情，而這就是通過(guò)元類來(lái)實(shí)現(xiàn)的。

較為完整的使用type創(chuàng)建類的方式:

class A(object):num = 100def print_b(self):print(self.num)@staticmethod def print_static():print("----haha-----")@classmethod def print_class(cls):print(cls.num)B = type("B", (A,), {"print_b": print_b, "print_static": print_static, "print_class": print_class}) b = B() b.print_b() b.print_static() b.print_class() # 結(jié)果 # 100 # ----haha----- # 100

6. 到底什么是元類（終于到主題了）

元類就是用來(lái)創(chuàng)建類的“東西”。你創(chuàng)建類就是為了創(chuàng)建類的實(shí)例對(duì)象，不是嗎？但是我們已經(jīng)學(xué)習(xí)到了Python中的類也是對(duì)象。

元類就是用來(lái)創(chuàng)建這些類（對(duì)象）的，元類就是類的類，你可以這樣理解為：

MyClass = MetaClass() # 使用元類創(chuàng)建出一個(gè)對(duì)象，這個(gè)對(duì)象稱為“類” my_object = MyClass() # 使用“類”來(lái)創(chuàng)建出實(shí)例對(duì)象

你已經(jīng)看到了type可以讓你像這樣做：

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

這是因?yàn)楹瘮?shù)type實(shí)際上是一個(gè)元類。type就是Python在背后用來(lái)創(chuàng)建所有類的元類。現(xiàn)在你想知道那為什么type會(huì)全部采用小寫(xiě)形式而不是Type呢？好吧，我猜這是為了和str保持一致性，str是用來(lái)創(chuàng)建字符串對(duì)象的類，而int是用來(lái)創(chuàng)建整數(shù)對(duì)象的類。type就是創(chuàng)建類對(duì)象的類。你可以通過(guò)檢查_(kāi)_class__屬性來(lái)看到這一點(diǎn)。Python中所有的東西，注意，我是指所有的東西——都是對(duì)象。這包括整數(shù)、字符串、函數(shù)以及類。它們?nèi)慷际菍?duì)象，而且它們都是從一個(gè)類創(chuàng)建而來(lái)，這個(gè)類就是type。

>>> age = 35 >>> age.__class__ <type 'int'> >>> >>> name = 'bob' >>> name.__class__ <type 'str'> >>> >>> def foo(): pass >>>foo.__class__ <type 'function'> >>> >>> class Bar(object): pass >>> b = Bar() >>> b.__class__ <class '__main__.Bar'> >>>

現(xiàn)在，對(duì)于任何一個(gè)__class__的__class__屬性又是什么呢？

>>> a.__class__.__class__ <type 'type'> >>> age.__class__.__class__ <type 'type'> >>> foo.__class__.__class__ <type 'type'> >>> b.__class__.__class__ <type 'type'>

因此，元類就是創(chuàng)建類這種對(duì)象的東西。type就是Python的內(nèi)建元類，當(dāng)然了，你也可以創(chuàng)建自己的元類。

7. __metaclass__屬性

你可以在定義一個(gè)類的時(shí)候?yàn)槠涮砑觃_metaclass__屬性。

class Foo(object):__metaclass__ = something…...省略...

如果你這么做了，Python就會(huì)用元類來(lái)創(chuàng)建類Foo。小心點(diǎn)，這里面有些技巧。你首先寫(xiě)下class Foo(object)，但是類Foo還沒(méi)有在內(nèi)存中創(chuàng)建。Python會(huì)在類的定義中尋找__metaclass__屬性，如果找到了，Python就會(huì)用它來(lái)創(chuàng)建類Foo，如果沒(méi)有找到，就會(huì)用內(nèi)建的type來(lái)創(chuàng)建這個(gè)類。把下面這段話反復(fù)讀幾次。當(dāng)你寫(xiě)如下代碼時(shí) :

class Foo(Bar):pass

Python做了如下的操作：

Foo中有__metaclass__這個(gè)屬性嗎？如果是，Python會(huì)通過(guò)__metaclass__創(chuàng)建一個(gè)名字為Foo的類(對(duì)象)

如果Python沒(méi)有找到__metaclass__，它會(huì)繼續(xù)在Bar（父類）中尋找__metaclass__屬性，并嘗試做和前面同樣的操作。

如果Python在任何父類中都找不到__metaclass__，它就會(huì)在模塊層次中去尋找__metaclass__，并嘗試做同樣的操作。

如果還是找不到__metaclass__,Python就會(huì)用內(nèi)置的type來(lái)創(chuàng)建這個(gè)類對(duì)象。

現(xiàn)在的問(wèn)題就是，你可以在__metaclass__中放置些什么代碼呢？答案就是：可以創(chuàng)建一個(gè)類的東西。那么什么可以用來(lái)創(chuàng)建一個(gè)類呢？type，或者任何使用到type或者子類化type的東東都可以。

8. 自定義元類

元類的主要目的就是為了當(dāng)創(chuàng)建類時(shí)能夠自動(dòng)地改變類。

假想一個(gè)很傻的例子，你決定在你的模塊里所有的類的屬性都應(yīng)該是大寫(xiě)形式。有好幾種方法可以辦到，但其中一種就是通過(guò)在模塊級(jí)別設(shè)定__metaclass__。采用這種方法，這個(gè)模塊中的所有類都會(huì)通過(guò)這個(gè)元類來(lái)創(chuàng)建，我們只需要告訴元類把所有的屬性都改成大寫(xiě)形式就萬(wàn)事大吉了。

幸運(yùn)的是，__metaclass__實(shí)際上可以被任意調(diào)用，它并不需要是一個(gè)正式的類。所以，我們這里就先以一個(gè)簡(jiǎn)單的函數(shù)作為例子開(kāi)始。

python2中

#-*- coding:utf-8 -*- def upper_attr(class_name, class_parents, class_attr):# class_name 會(huì)保存類的名字 Foo# class_parents 會(huì)保存類的父類 object# class_attr 會(huì)以字典的方式保存所有的類屬性# 遍歷屬性字典，把不是__開(kāi)頭的屬性名字變?yōu)榇髮?xiě)new_attr = {}for name, value in class_attr.items():if not name.startswith("__"):new_attr[name.upper()] = value# 調(diào)用type來(lái)創(chuàng)建一個(gè)類return type(class_name, class_parents, new_attr)class Foo(object):__metaclass__ = upper_attr # 設(shè)置Foo類的元類為upper_attrbar = 'bip'print(hasattr(Foo, 'bar')) print(hasattr(Foo, 'BAR'))f = Foo() print(f.BAR)

python3中

#-*- coding:utf-8 -*- def upper_attr(class_name, class_parents, class_attr):#遍歷屬性字典，把不是__開(kāi)頭的屬性名字變?yōu)榇髮?xiě)new_attr = {}for name,value in class_attr.items():if not name.startswith("__"):new_attr[name.upper()] = value#調(diào)用type來(lái)創(chuàng)建一個(gè)類return type(class_name, class_parents, new_attr)class Foo(object, metaclass=upper_attr):bar = 'bip'print(hasattr(Foo, 'bar')) print(hasattr(Foo, 'BAR'))f = Foo() print(f.BAR)

現(xiàn)在讓我們?cè)僮鲆淮?#xff0c;這一次用一個(gè)真正的class來(lái)當(dāng)做元類。

#coding=utf-8class UpperAttrMetaClass(type):# __new__ 是在__init__之前被調(diào)用的特殊方法# __new__是用來(lái)創(chuàng)建對(duì)象并返回之的方法# 而__init__只是用來(lái)將傳入的參數(shù)初始化給對(duì)象# 你很少用到__new__，除非你希望能夠控制對(duì)象的創(chuàng)建# 這里，創(chuàng)建的對(duì)象是類，我們希望能夠自定義它，所以我們這里改寫(xiě)__new__# 如果你希望的話，你也可以在__init__中做些事情# 還有一些高級(jí)的用法會(huì)涉及到改寫(xiě)__call__特殊方法，但是我們這里不用def __new__(cls, class_name, class_parents, class_attr):# 遍歷屬性字典，把不是__開(kāi)頭的屬性名字變?yōu)榇髮?xiě)new_attr = {}for name, value in class_attr.items():if not name.startswith("__"):new_attr[name.upper()] = value# 方法1：通過(guò)'type'來(lái)做類對(duì)象的創(chuàng)建return type(class_name, class_parents, new_attr)# 方法2：復(fù)用type.__new__方法# 這就是基本的OOP編程，沒(méi)什么魔法# return type.__new__(cls, class_name, class_parents, new_attr)# python3的用法 class Foo(object, metaclass=UpperAttrMetaClass):bar = 'bip'# python2的用法 # class Foo(object): # __metaclass__ = UpperAttrMetaClass # bar = 'bip'print(hasattr(Foo, 'bar')) # 輸出: False print(hasattr(Foo, 'BAR')) # 輸出:Truef = Foo() print(f.BAR) # 輸出:'bip'

就是這樣，除此之外，關(guān)于元類真的沒(méi)有別的可說(shuō)的了。但就元類本身而言，它們其實(shí)是很簡(jiǎn)單的：

攔截類的創(chuàng)建

修改類

返回修改之后的類

究竟為什么要使用元類？

現(xiàn)在回到我們的大主題上來(lái)，究竟是為什么你會(huì)去使用這樣一種容易出錯(cuò)且晦澀的特性？好吧，一般來(lái)說(shuō)，你根本就用不上它：

“元類就是深度的魔法，99%的用戶應(yīng)該根本不必為此操心。如果你想搞清楚究竟是否需要用到元類，那么你就不需要它。那些實(shí)際用到元類的人都非常清楚地知道他們需要做什么，而且根本不需要解釋為什么要用元類。” —— Python界的領(lǐng)袖 Tim Peters

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來(lái)咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)

總結(jié)

以上是生活随笔為你收集整理的元类--用不上的先了解的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。