python教程下载 - 什麼是Python中的元類?




python小白 (10)

什麼是元類,我們用它們做什麼?

https://code.i-harness.com


什麼是元類? 你用它們做什麼的?

TLDR:元類實例化並定義類的行為,就像類實例化一樣,並定義實例的行為。

偽代碼:

>>> Class(...)
instance

以上應該看起來很熟悉。 那麼, Class來自哪裡? 它是元類(也是偽代碼)的一個實例:

>>> Metaclass(...)
Class

在實際代碼中,我們可以傳遞默認的元類, type ,實例化類所需的一切,我們得到一個類:

>>> type('Foo', (object,), {}) # requires a name, bases, and a namespace
<class '__main__.Foo'>

換句話說

  • 類是一個實例,因為元類是一個類。

    當我們實例化一個對象時,我們得到一個實例:

    >>> object()                          # instantiation of class
    <object object at 0x7f9069b4e0b0>     # instance
    

    同樣,當我們使用默認元類, type顯式定義一個類時,我們實例化它:

    >>> type('Object', (object,), {})     # instantiation of metaclass
    <class '__main__.Object'>             # instance
    
  • 換句話說,類是元類的實例:

    >>> isinstance(object, type)
    True
    
  • 換句話說,元類是類的類。

    >>> type(object) == type
    True
    >>> object.__class__
    <class 'type'>
    

當您編寫類定義並且Python執行它時,它使用元類來實例化類對象(反過來,它將用於實例化該類的實例)。

就像我們可以使用類定義來改變自定義對象實例的行為方式一樣,我們可以使用元類定義來改變類對象的行為方式。

它們可以用於什麼? 來自docs

元類的潛在用途是無限的。 已探索的一些想法包括日誌記錄,接口檢查,自動委託,自動屬性創建,代理,框架和自動資源鎖定/同步。

儘管如此,除非絕對必要,否則通常鼓勵用戶避免使用元類。

每次創建類時都使用元類:

當你編寫類定義時,例如,像這樣,

class Foo(object): 
    'demo'

您實例化一個類對象。

>>> Foo
<class '__main__.Foo'>
>>> isinstance(Foo, type), isinstance(Foo, object)
(True, True)

它與具有適當參數的函數調用type相同,並將結果分配給該名稱的變量:

name = 'Foo'
bases = (object,)
namespace = {'__doc__': 'demo'}
Foo = type(name, bases, namespace)

注意,有些東西會自動添加到__dict__ ,即命名空間:

>>> Foo.__dict__
dict_proxy({'__dict__': <attribute '__dict__' of 'Foo' objects>, 
'__module__': '__main__', '__weakref__': <attribute '__weakref__' 
of 'Foo' objects>, '__doc__': 'demo'})

在兩種情況下,我們創建的對象的元類都是type

(關於類__module____module__的內容的__module__是因為類必須知道它們的定義位置,並且__dict____weakref__存在,因為我們沒有定義__slots__ - 如果我們定義__slots__我們將節省一些實例中的空格,因為我們可以通過排除它們來禁止__dict____weakref__ 。例如:

>>> Baz = type('Bar', (object,), {'__doc__': 'demo', '__slots__': ()})
>>> Baz.__dict__
mappingproxy({'__doc__': 'demo', '__slots__': (), '__module__': '__main__'})

......但我離題了。)

我們可以像任何其他類定義一樣擴展type

這是類的默認__repr__

>>> Foo
<class '__main__.Foo'>

在編寫Python對象時,我們默認可以做的最有價值的事情之一就是為它提供一個好的__repr__ 。 當我們調用help(repr)我們知道對__repr__有一個很好的測試,它也需要測試相等性 - obj == eval(repr(obj)) 。 以下對類型類的類實例的__repr____eq__簡單實現為我們提供了一個可以改進類的默認__repr__的演示:

class Type(type):
    def __repr__(cls):
        """
        >>> Baz
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        >>> eval(repr(Baz))
        Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
        """
        metaname = type(cls).__name__
        name = cls.__name__
        parents = ', '.join(b.__name__ for b in cls.__bases__)
        if parents:
            parents += ','
        namespace = ', '.join(': '.join(
          (repr(k), repr(v) if not isinstance(v, type) else v.__name__))
               for k, v in cls.__dict__.items())
        return '{0}(\'{1}\', ({2}), {{{3}}})'.format(metaname, name, parents, namespace)
    def __eq__(cls, other):
        """
        >>> Baz == eval(repr(Baz))
        True            
        """
        return (cls.__name__, cls.__bases__, cls.__dict__) == (
                other.__name__, other.__bases__, other.__dict__)

所以現在當我們使用這個元類創建一個對象時,__repr__命令行上的回顯提供了比默認值更不醜的視覺:

>>> class Bar(object): pass
>>> Baz = Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})
>>> Baz
Type('Baz', (Foo, Bar,), {'__module__': '__main__', '__doc__': None})

通過__repr__為類實例定義一個很好的,我們有更強的調試代碼的能力。然而,進一步檢查eval(repr(Class))是不太可能的(因為函數將無法從默認值中進行評估__repr__)。

預期用法:__prepare__命名空間

例如,如果我們想知道創建類的方法的順序,我們可以提供一個有序的dict作為類的命名空間。如果它在Python 3中實現,我們將使用__prepare__返回類的命名空間dict

from collections import OrderedDict

class OrderedType(Type):
    @classmethod
    def __prepare__(metacls, name, bases, **kwargs):
        return OrderedDict()
    def __new__(cls, name, bases, namespace, **kwargs):
        result = Type.__new__(cls, name, bases, dict(namespace))
        result.members = tuple(namespace)
        return result

用法:

class OrderedMethodsObject(object, metaclass=OrderedType):
    def method1(self): pass
    def method2(self): pass
    def method3(self): pass
    def method4(self): pass

現在我們記錄了這些方法(和其他類屬性)的創建順序:

>>> OrderedMethodsObject.members
('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4')

注意,這個例子是從docs中改編而來的- 標準庫中的新枚舉就是這樣做的。

所以我們所做的是通過創建一個類來實例化一個元類。我們也可以像對待任何其他類一樣對待元類。它有一個方法解析順序:

>>> inspect.getmro(OrderedType)
(<class '__main__.OrderedType'>, <class '__main__.Type'>, <class 'type'>, <class 'object'>)

並且它大致正確repr(除非我們能找到表示我們函數的方法,否則我們不能再進行評估)。

>>> OrderedMethodsObject
OrderedType('OrderedMethodsObject', (object,), {'method1': <function OrderedMethodsObject.method1 at 0x0000000002DB01E0>, 'members': ('__module__', '__qualname__', 'method1', 'method2', 'method3', 'method4'), 'method3': <function OrderedMet
hodsObject.method3 at 0x0000000002DB02F0>, 'method2': <function OrderedMethodsObject.method2 at 0x0000000002DB0268>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'OrderedMethodsObject' objects>, '__doc__': None, '__d
ict__': <attribute '__dict__' of 'OrderedMethodsObject' objects>, 'method4': <function OrderedMethodsObject.method4 at 0x0000000002DB0378>})

類作為對象

在理解元類之前,您需要掌握Python中的類。 Python對Smalltalk語言借用的類有一個非常奇特的想法。

在大多數語言中,類只是描述如何生成對象的代碼片段。 在Python中也是如此:

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

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但是類比Python更多。 類也是對象。

是的,對象。

一旦使用關鍵字class ,Python就會執行它並創建一個OBJECT。 指示

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

在內存中創建一個名為“ObjectCreator”的對象。

這個對象(類)本身能夠創建對象(實例),這就是為什麼它是一個類

但是,它仍然是一個對象,因此:

  • 您可以將其分配給變量
  • 你可以復制它
  • 你可以添加屬性
  • 您可以將其作為函數參數傳遞

例如:

>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

動態創建類

由於類是對象,因此您可以像任何對像一樣動態創建它們。

首先,您可以使用類在函數中創建一個class

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

但它不是那麼有活力,因為你還是要自己寫全班。

由於類是對象,因此它們必須由某些東西生成。

使用class關鍵字時,Python會自動創建此對象。 但與Python中的大多數內容一樣,它為您提供了一種手動操作方法。

還記得功能type嗎? 一個很好的舊函數,可以讓您知道對象的類型:

>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

嗯, type具有完全不同的能力,它也可以動態創建類。 type可以將類的描述作為參數,並返回一個類。

(我知道,根據您傳遞給它的參數,相同的函數可以有兩個完全不同的用途,這很愚蠢。由於Python中的向後兼容性,這是一個問題)

type這種方式工作:

type(name of the class,
     tuple of the parent class (for inheritance, can be empty),
     dictionary containing attributes names and values)

例如:

>>> class MyShinyClass(object):
...       pass

可以通過以下方式手動創建:

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

您會注意到我們使用“MyShinyClass”作為類的名稱,並使用變量來保存類引用。 它們可以不同,但​​沒有理由使事情複雜化。

type接受字典以定義類的屬性。 所以:

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

可以翻譯成:

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

並用作普通類:

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

當然,你可以繼承它,所以:

>>>   class FooChild(Foo):
...         pass

將會:

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
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

在動態創建類之後,您可以添加更多方法,就像向正常創建的類對象添加方法一樣。

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

你會看到我們要去的地方:在Python中,類是對象,你可以動態地創建一個類。

這就是Python在使用關鍵字class時所做的事情,它通過使用元類來實現。

什麼是元類(最後)

元類是創建類的“東西”。

你定義類來創建對象,對嗎?

但我們了解到Python類是對象。

好吧,元類是創建這些對象的原因。 他們是班級的班級,你可以這樣畫出來:

MyClass = MetaClass()
my_object = MyClass()

您已經看到該type允許您執行以下操作:

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

這是因為函數type實際上是一個元類。 type是Python用於在幕後創建所有類的元類。

現在你想知道為什麼它是用小寫寫的,而不是Type

好吧,我想這是與str的一致性問題,創建字符串對象的類,以及創建整數對象的類。 type只是創建類對象的類。

您可以通過檢查__class__屬性來看到它。

一切,我的意思是一切,都是Python中的一個對象。 這包括整數,字符串,函數和類。 所有這些都是對象。 所有這些都是從一個類創建的:

>>> 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'>

現在,任何__class____class__是什麼?

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

因此,元類只是創建類對象的東西。

如果您願意,可以稱之為“班級工廠”。

type是Python使用的內置元類,但當然,您可以創建自己的元類。

__metaclass__屬性

在Python 2中,您可以在編寫類時添加__metaclass__屬性(請參閱Python 3語法的下一節):

class Foo(object):
    __metaclass__ = something...
    [...]

如果這樣做,Python將使用元類來創建類Foo

小心,這很棘手。

您首先編寫class Foo(object) ,但類對象Foo尚未在內存中創建。

Python將在類定義中查找__metaclass__ 。 如果找到它,它將使用它來創建對像類Foo 。 如果沒有,它將使用type來創建類。

多讀一遍。

當你這樣做時:

class Foo(Bar):
    pass

Python執行以下操作:

Foo是否有__metaclass__屬性?

如果是的話,在內存中創建一個類對象(我說一個類對象,留在這裡),使用名稱Foo ,使用__metaclass__

如果Python找不到__metaclass__ ,它將在MODULE級別查找__metaclass__ ,並嘗試執行相同的操作(但僅適用於不繼承任何內容的類,基本上是舊式類)。

然後,如果它根本找不到任何__metaclass__ ,它將使用Bar (第一個父)自己的元類(可能是默認type )來創建類對象。

這裡要小心,不會繼承__metaclass__屬性,父類的元類( Bar.__class__ )將是。 如果Bar使用__metaclass__屬性創建了帶有type() Bar (而不是type.__new__() ),則子類將不會繼承該行為。

現在最大的問題是,你能在__metaclass____metaclass__什麼?

答案是:可以創建一個類的東西。

什麼可以創造一個類? type ,或子類或使用它的任何東西。

Python中的元類3

在Python 3中更改了設置元類的語法:

class Foo(object, metaclass=something):
    [...]

即不再使用__metaclass__屬性,而是支持基類列表中的關鍵字參數。

然而,元類的行為基本保持不變

自定義元類

元類的主要目的是在創建類時自動更改類。

您通常對API執行此操作,您希望在其中創建與當前上下文匹配的類。

想像一個愚蠢的例子,你決定模塊中的所有類都應該用大寫字母寫出它們的屬性。 有幾種方法可以做到這一點,但一種方法是在模塊級別設置__metaclass__

這樣,將使用此元類創建此模塊的所有類,我們只需告訴元類將所有屬性轉換為大寫。

幸運的是, __metaclass__實際上可以是任何可調用的,它不需要是一個正式的類(我知道,其名稱中帶有'class'的東西不需要是一個類,去圖......但它很有幫助)。

因此,我們將從一個簡單的例子開始,使用一個函數。

# the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    """
      Return a class object, with the list of its attribute turned
      into uppercase.
    """

    # pick up any attribute that doesn't start with '__' and uppercase it
    uppercase_attr = {}
    for name, val in future_class_attr.items():
        if not name.startswith('__'):
            uppercase_attr[name.upper()] = val
        else:
            uppercase_attr[name] = val

    # let `type` do the class creation
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # this will affect all classes in the module

class Foo(): # global __metaclass__ won't work with "object" though
    # but we can define __metaclass__ here instead to affect only this class
    # and this will work with "object" children
    bar = 'bip'

print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True

f = Foo()
print(f.BAR)
# Out: 'bip'

現在,讓我們做同樣的事情,但是對於元類使用真正的類:

# remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type):
    # __new__ is the method called before __init__
    # it's the method that creates the object and returns it
    # while __init__ just initializes the object passed as parameter
    # you rarely use __new__, except when you want to control how the object
    # is created.
    # here the created object is the class, and we want to customize it
    # so we override __new__
    # you can do some stuff in __init__ too if you wish
    # some advanced use involves overriding __call__ as well, but we won't
    # see this
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type(future_class_name, future_class_parents, uppercase_attr)

但這不是真正的OOP。 我們直接調用type ,我們不會覆蓋或調用父__new__ 。 我們開始做吧:

class UpperAttrMetaclass(type):

    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):

        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        # reuse the type.__new__ method
        # this is basic OOP, nothing magic in there
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

你可能已經註意到額外的參數upperattr_metaclass 。 它沒有什麼特別之處: __new__總是接收它定義的類,作為第一個參數。 就像你有self的普通方法接收實例作為第一個參數,或者類方法的定義類。

當然,為了清楚起見,我在這裡使用的名稱很長,但是對於self ,所有的參數都有傳統的名稱。 所以真正的生產元類看起來像這樣:

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return type.__new__(cls, clsname, bases, uppercase_attr)

我們可以通過使用super來使它更乾淨,這將使繼承變得更容易(因為是的,你可以擁有元類,繼承自元類,繼承自類型):

class UpperAttrMetaclass(type):

    def __new__(cls, clsname, bases, dct):

        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val

        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

而已。 實際上沒有關於元類的更多信息。

使用元類的代碼複雜性背後的原因不是因為元類,而是因為你通常使用元類來依賴於內省,操縱繼承,諸如__dict__變量等來做扭曲的東西。

實際上,元類特別適用於製作黑魔法,因此也很複雜。 但它們本身很簡單:

  • 攔截班級創作
  • 修改課程
  • 返回修改後的類

為什麼要使用元類而不是函數?

由於__metaclass__可以接受任何可調用的,為什麼你會使用一個類,因為它顯然更複雜?

有幾個原因可以這樣做:

  • 目的很明確。 當您閱讀UpperAttrMetaclass(type) ,您知道將要遵循的內容
  • 你可以使用OOP。 Metaclass可以從元類繼承,覆蓋父方法。 元類甚至可以使用元類。
  • 如果指定了元類,但沒有使用元類函數,則類的子類將是其元類的實例。
  • 您可以更好地構建代碼。 你從不使用元類來處理像上面例子那樣簡單的事情。 它通常用於復雜的事情。 能夠製作多個方法並將它們組合在一個類中對於使代碼更易於閱讀非常有用。
  • 你可以掛鉤__new__ __init____init____call__ 。 這將允許你做不同的東西。 即使通常你可以在__new__完成所有__new__ ,但有些人使用__init__更舒服。
  • 這些被稱為元類,該死的! 它必須意味著什麼!

你為什麼要使用元類?

現在是個大問題。 為什麼要使用一些不起眼的容易出錯的功能?

好吧,通常你不會:

元類是更深刻的魔力,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轉換為數據庫字段的複雜鉤子。

Django通過公開一個簡單的API並使用元類,從這個API重新創建代碼來完成幕後的實際工作,從而使復雜的外觀變得簡單。

最後一個字

首先,您知道類是可以創建實例的對象。

事實上,類本身就是實例。 元類。

>>> class Foo(object): pass
>>> id(Foo)
142630324

一切都是Python中的對象,它們都是類的實例或元類的實例。

除了type

type實際上是它自己的元類。 這不是你可以在純Python中重現的東西,而是通過在實現級別上作弊來完成的。

其次,元類很複雜。 您可能不希望將它們用於非常簡單的類更改。 您可以使用兩種不同的技術更改類:

99%的時間你需要改變課程,你最好使用這些。

但是98%的情況下,你根本不需要改變課程。


tl;博士版

type(obj)函數可以獲取對象的類型。

type()一類是它的元類

要使用元類:

class Foo(object):
    __metaclass__ = MyMetaClass

type實際上是一個metaclass創建另一個類的類。大多數metaclass是。的子類type。所述metaclass接收new類作為其第一個參數,如下面所提到提供訪問與細節類對象:

>>> class MetaClass(type):
...     def __init__(cls, name, bases, attrs):
...         print ('class name: %s' %name )
...         print ('Defining class %s' %cls)
...         print('Bases %s: ' %bases)
...         print('Attributes')
...         for (name, value) in attrs.items():
...             print ('%s :%r' %(name, value))
... 

>>> class NewClass(object, metaclass=MetaClass):
...    get_choch='dairy'
... 
class name: NewClass
Bases <class 'object'>: 
Defining class <class 'NewClass'>
get_choch :'dairy'
__module__ :'builtins'
__qualname__ :'NewClass'

Note:

請注意,該類在任何時候都沒有實例化; 創建類的簡單行為觸發了執行metaclass


Python 3更新

(在這一點上)元類中有兩個關鍵方法:

  • __prepare__ ,和
  • __new__

__prepare__允許您提供OrderedDict在創建類時用作命名空間的自定義映射(例如)。您必須返回您選擇的任何名稱空間的實例。如果沒有實現__prepare__正常dict使用。

__new__ 負責最終課程的實際創建/修改。

一個簡單的,無所事事的額外元類想要:

class Meta(type):

    def __prepare__(metaclass, cls, bases):
        return dict()

    def __new__(metacls, cls, bases, clsdict):
        return super().__new__(metacls, cls, bases, clsdict)

一個簡單的例子:

假設您希望在您的屬性上運行一些簡單的驗證代碼 - 例如它必須始終為a int或a str。沒有元類,您的類看起來像:

class Person:
    weight = ValidateType('weight', int)
    age = ValidateType('age', int)
    name = ValidateType('name', str)

如您所見,您必須重複兩次屬性的名稱。這使得拼寫錯誤以及惱人的錯誤成為可能。

一個簡單的元類可以解決這個問題:

class Person(metaclass=Validator):
    weight = ValidateType(int)
    age = ValidateType(int)
    name = ValidateType(str)

這就是元類的外觀(不使用,__prepare__因為它不需要):

class Validator(type):
    def __new__(metacls, cls, bases, clsdict):
        # search clsdict looking for ValidateType descriptors
        for name, attr in clsdict.items():
            if isinstance(attr, ValidateType):
                attr.name = name
                attr.attr = '_' + name
        # create final class and return it
        return super().__new__(metacls, cls, bases, clsdict)

示例運行:

p = Person()
p.weight = 9
print(p.weight)
p.weight = '9'

生產:

9
Traceback (most recent call last):
  File "simple_meta.py", line 36, in <module>
    p.weight = '9'
  File "simple_meta.py", line 24, in __set__
    (self.name, self.type, value))
TypeError: weight must be of type(s) <class 'int'> (got '9')

注意:這個例子很簡單,它也可以用類裝飾器完成,但可能是一個實際的元類會做得更多。

'ValidateType'類供參考:

class ValidateType:
    def __init__(self, type):
        self.name = None  # will be set by metaclass
        self.attr = None  # will be set by metaclass
        self.type = type
    def __get__(self, inst, cls):
        if inst is None:
            return self
        else:
            return inst.__dict__[self.attr]
    def __set__(self, inst, value):
        if not isinstance(value, self.type):
            raise TypeError('%s must be of type(s) %s (got %r)' %
                    (self.name, self.type, value))
        else:
            inst.__dict__[self.attr] = value

Python類本身就是它們的元類的對象 - 例如 - 。

默認元類,在您將類確定為時應用:

class foo:
    ...

元類用於將一些規則應用於整個類集。例如,假設您正在構建一個ORM來訪問數據庫,並且您希望每個表中的記錄都是映射到該表的類(基於字段,業務規則等),可能使用元類例如,連接池邏輯,它由所有表的所有記錄類共享。另一個用途是支持外鍵的邏輯,它涉及多類記錄。

當你定義元類時,你是子類類型,並且可以覆蓋以下魔術方法來插入你的邏輯。

class somemeta(type):
    __new__(mcs, name, bases, clsdict):
      """
  mcs: is the base metaclass, in this case type.
  name: name of the new class, as provided by the user.
  bases: tuple of base classes 
  clsdict: a dictionary containing all methods and attributes defined on class

  you must return a class object by invoking the __new__ constructor on the base metaclass. 
 ie: 
    return type.__call__(mcs, name, bases, clsdict).

  in the following case:

  class foo(baseclass):
        __metaclass__ = somemeta

  an_attr = 12

  def bar(self):
      ...

  @classmethod
  def foo(cls):
      ...

      arguments would be : ( somemeta, "foo", (baseclass, baseofbase,..., object), {"an_attr":12, "bar": <function>, "foo": <bound class method>}

      you can modify any of these values before passing on to type
      """
      return type.__call__(mcs, name, bases, clsdict)


    def __init__(self, name, bases, clsdict):
      """ 
      called after type has been created. unlike in standard classes, __init__ method cannot modify the instance (cls) - and should be used for class validaton.
      """
      pass


    def __prepare__():
        """
        returns a dict or something that can be used as a namespace.
        the type will then attach methods and attributes from class definition to it.

        call order :

        somemeta.__new__ ->  type.__new__ -> type.__init__ -> somemeta.__init__ 
        """
        return dict()

    def mymethod(cls):
        """ works like a classmethod, but for class objects. Also, my method will not be visible to instances of cls.
        """
        pass

無論如何,這兩個是最常用的鉤子。元類化是強大的,並且上面是遠程接近和詳盡的元類別用途列表。


元類是一個類,它告訴我們應該如何(某些)創建其他類。

這是我看到元類作為我的問題的解決方案的情況:我有一個非常複雜的問題,可能已經以不同的方式解決了,但我選擇使用元類來解決它。由於其複雜性,它是我編寫的少數幾個模塊之一,其中模塊中的註釋超過了已編寫的代碼量。這裡是...

#!/usr/bin/env python

# Copyright (C) 2013-2014 Craig Phillips.  All rights reserved.

# This requires some explaining.  The point of this metaclass excercise is to
# create a static abstract class that is in one way or another, dormant until
# queried.  I experimented with creating a singlton on import, but that did
# not quite behave how I wanted it to.  See now here, we are creating a class
# called GsyncOptions, that on import, will do nothing except state that its
# class creator is GsyncOptionsType.  This means, docopt doesn't parse any
# of the help document, nor does it start processing command line options.
# So importing this module becomes really efficient.  The complicated bit
# comes from requiring the GsyncOptions class to be static.  By that, I mean
# any property on it, may or may not exist, since they are not statically
# defined; so I can't simply just define the class with a whole bunch of
# properties that are @property @staticmethods.
#
# So here's how it works:
#
# Executing 'from libgsync.options import GsyncOptions' does nothing more
# than load up this module, define the Type and the Class and import them
# into the callers namespace.  Simple.
#
# Invoking 'GsyncOptions.debug' for the first time, or any other property
# causes the __metaclass__ __getattr__ method to be called, since the class
# is not instantiated as a class instance yet.  The __getattr__ method on
# the type then initialises the class (GsyncOptions) via the __initialiseClass
# method.  This is the first and only time the class will actually have its
# dictionary statically populated.  The docopt module is invoked to parse the
# usage document and generate command line options from it.  These are then
# paired with their defaults and what's in sys.argv.  After all that, we
# setup some dynamic properties that could not be defined by their name in
# the usage, before everything is then transplanted onto the actual class
# object (or static class GsyncOptions).
#
# Another piece of magic, is to allow command line options to be set in
# in their native form and be translated into argparse style properties.
#
# Finally, the GsyncListOptions class is actually where the options are
# stored.  This only acts as a mechanism for storing options as lists, to
# allow aggregation of duplicate options or options that can be specified
# multiple times.  The __getattr__ call hides this by default, returning the
# last item in a property's list.  However, if the entire list is required,
# calling the 'list()' method on the GsyncOptions class, returns a reference
# to the GsyncListOptions class, which contains all of the same properties
# but as lists and without the duplication of having them as both lists and
# static singlton values.
#
# So this actually means that GsyncOptions is actually a static proxy class...
#
# ...And all this is neatly hidden within a closure for safe keeping.
def GetGsyncOptionsType():
    class GsyncListOptions(object):
        __initialised = False

    class GsyncOptionsType(type):
        def __initialiseClass(cls):
            if GsyncListOptions._GsyncListOptions__initialised: return

            from docopt import docopt
            from libgsync.options import doc
            from libgsync import __version__

            options = docopt(
                doc.__doc__ % __version__,
                version = __version__,
                options_first = True
            )

            paths = options.pop('<path>', None)
            setattr(cls, "destination_path", paths.pop() if paths else None)
            setattr(cls, "source_paths", paths)
            setattr(cls, "options", options)

            for k, v in options.iteritems():
                setattr(cls, k, v)

            GsyncListOptions._GsyncListOptions__initialised = True

        def list(cls):
            return GsyncListOptions

        def __getattr__(cls, name):
            cls.__initialiseClass()
            return getattr(GsyncListOptions, name)[-1]

        def __setattr__(cls, name, value):
            # Substitut option names: --an-option-name for an_option_name
            import re
            name = re.sub(r'^__', "", re.sub(r'-', "_", name))
            listvalue = []

            # Ensure value is converted to a list type for GsyncListOptions
            if isinstance(value, list):
                if value:
                    listvalue = [] + value
                else:
                    listvalue = [ None ]
            else:
                listvalue = [ value ]

            type.__setattr__(GsyncListOptions, name, listvalue)

    # Cleanup this module to prevent tinkering.
    import sys
    module = sys.modules[__name__]
    del module.__dict__['GetGsyncOptionsType']

    return GsyncOptionsType

# Our singlton abstract proxy class.
class GsyncOptions(object):
    __metaclass__ = GetGsyncOptionsType()

元類是類的類。 就像類定義了類的實例的行為一樣,元類定義了類的行為方式。 類是元類的實例。

雖然在Python中你可以為元類使用任意的callables(比如Jerub節目),實際上更有用的方法是使它成為一個真正的類本身。 type是Python中常用的元類。 如果您想知道,是的, type本身就是一個類,它是它自己的類型。 你將無法在Python中重新創建純type東西,但是Python會有所作為。 要在Python中創建自己的元類,你真的只想子type

元類最常用作類工廠。 就像你通過調用類來創建類的實例一樣,Python通過調用元類來創建一個新類(當它執行'class'語句時)。 結合正常的__init____new__方法,元類因此允許您在創建類時執行“額外的事情”,例如使用某個註冊表註冊新類,或者甚至完全用其他類替換該類。

執行class語句時,Python首先執行class語句的主體作為正常的代碼塊。 生成的命名空間(dict)保存了將要進行的類的屬性。 元類是通過在__metaclass__類(如果有)的__metaclass__屬性或__metaclass__全局變量中查看要被定義的類的基類(繼承元類)來確定的。 然後使用類的名稱,基數和屬性調用元類來實例化它。

但是,元類實際上定義了類的類型 ,而不僅僅是它的工廠,所以你可以用它們做更多的事情。 例如,您可以在元類上定義常規方法。 這些元類方法類似於類方法,因為它們可以在沒有實例的類上調用,但它們也不像類方法,因為它們不能在類的實例上調用。 type.__subclasses__()type元類的方法示例。 您還可以定義常規的“魔術”方法,如__add__ __iter____getattr__ __add____getattr__ ,以實現或更改類的行為方式。

這是比特和碎片的匯總示例:

def make_hook(f):
    """Decorator to turn 'foo' method into '__foo__'"""
    f.is_hook = 1
    return f

class MyType(type):
    def __new__(mcls, name, bases, attrs):

        if name.startswith('None'):
            return None

        # Go over attributes and see if they should be renamed.
        newattrs = {}
        for attrname, attrvalue in attrs.iteritems():
            if getattr(attrvalue, 'is_hook', 0):
                newattrs['__%s__' % attrname] = attrvalue
            else:
                newattrs[attrname] = attrvalue

        return super(MyType, mcls).__new__(mcls, name, bases, newattrs)

    def __init__(self, name, bases, attrs):
        super(MyType, self).__init__(name, bases, attrs)

        # classregistry.register(self, self.interfaces)
        print "Would register class %s now." % self

    def __add__(self, other):
        class AutoClass(self, other):
            pass
        return AutoClass
        # Alternatively, to autogenerate the classname as well as the class:
        # return type(self.__name__ + other.__name__, (self, other), {})

    def unregister(self):
        # classregistry.unregister(self)
        print "Would unregister class %s now." % self

class MyObject:
    __metaclass__ = MyType


class NoneSample(MyObject):
    pass

# Will print "NoneType None"
print type(NoneSample), repr(NoneSample)

class Example(MyObject):
    def __init__(self, value):
        self.value = value
    @make_hook
    def add(self, other):
        return self.__class__(self.value + other.value)

# Will unregister the class
Example.unregister()

inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()

print inst + inst
class Sibling(MyObject):
    pass

ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__

其他人已經解釋了元類如何工作以及它們如何適合Python類型系統。 以下是它們可用於什麼的示例。 在我編寫的測試框架中,我想跟踪定義類的順序,以便稍後我可以按此順序實例化它們。 我發現使用元類這樣做最容易。

class MyMeta(type):

    counter = 0

    def __init__(cls, name, bases, dic):
        type.__init__(cls, name, bases, dic)
        cls._order = MyMeta.counter
        MyMeta.counter += 1

class MyType(object):              # Python 2
    __metaclass__ = MyMeta

class MyType(metaclass=MyMeta):    # Python 3
    pass

然後,任何屬於MyType子類的東西都會獲得一個類屬性_order ,它記錄了類的定義順序。


我認為ONLamp對元類編程的介紹寫得很好,並且儘管已有幾年的歷史,卻給出了很好的主題介紹。

http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html (存檔於https://web.archive.org/web/20080206005253/http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html

簡而言之:類是創建實例的藍圖,元類是創建類的藍圖。 可以很容易地看出,Python類中也需要是第一類對象來啟用此行為。

我自己從未寫過,但我認為在Django框架中可以看到元類最好的用法之一。 模型類使用元類方法來啟用編寫新模型或表單類的聲明式樣式。 當元類創建類時,所有成員都可以自定義類。

剩下要說的是:如果你不知道什麼是元類,那麼你不需要它們的可能性是99%。





python-datamodel