metaclass详解 什么是Python中的元类?




7 Answers

类作为对象

在理解元类之前,您需要掌握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%的情况下,你根本不需要改变课程。

python metaclass是什么

什么是元类,我们用它们做什么?




元类的一个用途是自动向实例添加新属性和方法。

例如,如果你看看Django模型 ,他们的定义看起来有点令人困惑。 看起来好像只是定义了类属性:

class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

但是,在运行时,Person对象充满了各种有用的方法。 查看source了解一些神奇的元素。




我认为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 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



元类是一个类,它告诉我们应该如何(某些)创建其他类。

这是我看到元类作为我的问题的解决方案的情况:我有一个非常复杂的问题,可能已经以不同的方式解决了,但我选择使用元类来解决它。由于其复杂性,它是我编写的少数几个模块之一,其中模块中的注释超过了已编写的代码量。这里是...

#!/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()



tl;博士版

type(obj)函数可以获取对象的类型。

type()一类是它的元类

要使用元类:

class Foo(object):
    __metaclass__ = MyMetaClass



type()函数可以返回对象的类型或创建新类型,

例如,我们可以使用type()函数创建一个Hi类,而不需要使用类Hi(object):

def func(self, name='mike'):
    print('Hi, %s.' % name)

Hi = type('Hi', (object,), dict(hi=func))
h = Hi()
h.hi()
Hi, mike.

type(Hi)
type

type(h)
__main__.Hi

除了使用type()动态创建类之外,您还可以控制类的创建行为并使用元类。

根据Python对象模型,类是对象,因此该类必须是另一个特定类的实例。默认情况下,Python类是类型类的实例。也就是说,type是大多数内置类的元类和用户定义类的元类。

class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)

class CustomList(list, metaclass=ListMetaclass):
    pass

lst = CustomList()
lst.add('custom_list_1')
lst.add('custom_list_2')

lst
['custom_list_1', 'custom_list_2']

当我们在元类中传递关键字参数时,Magic将生效,它表示Python解释器通过ListMetaclass创建CustomList。new(),此时,我们可以修改类定义,例如,添加一个新方法然后返回修改后的定义。






Related