小编典典

简而言之，这意味着对对象的使用没有任何限制。它与任何其他对象相同。

第一类对象是可以动态创建、销毁、传递给函数、作为值返回并具有编程语言中其他变量的所有权利的实体。

根据语言，这可能意味着：

• 可表示为匿名文字值
• 可存储在变量中
• 可存储在数据结构中
• 具有内在身份（独立于任何给定名称）
• 与其他实体具有可比性
• 可作为参数传递给过程/函数
• 作为过程/函数的结果可返回
• 在运行时可构造
• 可打印
• 可读
• 可在分布式进程之间传输
• 可存储在正在运行的进程之外
  

来源。

然而，在 C++ 中，函数本身并不是一流的对象：

• 您可以覆盖“（）”运算符，从而可以拥有一个对象函数，这是一等的。
• 函数指针是第一类。
• boost bind、lambda 和 function 确实提供了一流的功能

在 C++ 中，类不是第一类对象，而是这些类的实例。在 Python 中，类 和
对象都是第一类对象。（有关作为对象的类的更多详细信息，请参阅此答案。

作为对象的类

在了解元类之前，您需要掌握 Python 中的类。Python 对什么是类有一个非常奇特的想法，这是从 Smalltalk 语言中借来的。

在大多数语言中，类只是描述如何生成对象的代码片段。在 Python 中也是如此：

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

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

但是类不仅仅是 Python 中的类。类也是对象。

是的，对象。

只要您使用关键字class，Python 就会执行它并创建一个对象。该指令

>>> 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, bases, attrs)

在哪里：

• name: 类名
• bases: 父类的元组（用于继承，可以为空）
• attrs: 包含属性名称和值的字典

例如：

>>> 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创建字符串对象int的类和创建整数对象的类的一致性问题。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'>

现在， any 是__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 执行以下操作：

中是否有__metaclass__属性Foo？

如果是，请在内存中创建一个类对象（我说的是类对象，请留在我这里），其名称Foo使用__metaclass__.

如果 Python 找不到__metaclass__，它将__metaclass__在 MODULE 级别查找 a ，并尝试做同样的事情（但仅适用于不继承任何东西的类，基本上是旧式类）。

然后，如果它根本找不到任何__metaclass__东西，它将使用Bar‘s（第一个父级）自己的元类（可能是默认的type）来创建类对象。

注意这里的__metaclass__属性不会被继承，父类（Bar.__class__）的元类会被继承。如果Bar使用使用（而不是）创建的属性，__metaclass__子类将不会继承该行为。Bar``type()``type.__new__()

现在最大的问题是，你能放__metaclass__什么？

答案是可以创建类的东西。

什么可以创建一个类？type，或任何子类或使用它的东西。

Python 3 中的元类

Python 3 中设置元类的语法已更改：

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

即__metaclass__不再使用该属性，取而代之的是基类列表中的关键字参数。

然而，元类的行为基本保持不变。

在 Python 3 中添加到元类的一件事是，您还可以将属性作为关键字参数传递给元类，如下所示：

class Foo(object, metaclass=something, kwarg1=value1, kwarg2=value2):
    ...

阅读下面的部分，了解 Python 如何处理这个问题。

自定义元类

元类的主要目的是在创建类时自动更改它。

您通常为 API 执行此操作，您希望在其中创建与当前上下文匹配的类。

想象一个愚蠢的例子，你决定模块中的所有类的属性都应该用大写字母写。有几种方法可以做到这一点，但一种方法是__metaclass__在模块级别进行设置。

这样，这个模块的所有类都将使用这个元类创建，我们只需要告诉元类将所有属性都转为大写即可。

幸运的是，__metaclass__实际上可以是任何可调用的，它不需要是一个正式的类（我知道，名称中带有“类”的东西不需要是一个类，去看看......但它很有帮助）。

所以我们将从一个简单的例子开始，使用一个函数。

# 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_attrs):
    """
      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_attrs = {
        attr if attr.startswith("__") else attr.upper(): v
        for attr, v in future_class_attrs.items()
    }

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

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

让我们检查：

>>> hasattr(Foo, 'bar')
False
>>> hasattr(Foo, 'BAR')
True
>>> Foo.BAR
'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_attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in future_class_attrs.items()
        }
        return type(future_class_name, future_class_parents, uppercase_attrs)

让我们重写上面的内容，但是现在我们知道它们的含义，使用更短和更真实的变量名称：

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type(clsname, bases, uppercase_attrs)

您可能已经注意到额外的参数cls。它没有什么特别之处：__new__总是接收它定义的类，作为第一个参数。就像您self对接收实例作为第一个参数的普通方法或类方法的定义类一样。

但这不是正确的 OOP。我们type直接调用，我们没有覆盖或调用父级的__new__. 让我们这样做：

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return type.__new__(cls, clsname, bases, uppercase_attrs)

我们可以通过 using 使其更简洁super，这将简化继承（因为是的，您可以拥有元类，从元类继承，从类型继承）：

class UpperAttrMetaclass(type):
    def __new__(cls, clsname, bases, attrs):
        uppercase_attrs = {
            attr if attr.startswith("__") else attr.upper(): v
            for attr, v in attrs.items()
        }
        return super(UpperAttrMetaclass, cls).__new__(
            cls, clsname, bases, uppercase_attrs)

哦，在 Python 3 中，如果您使用关键字参数进行此调用，如下所示：

class Foo(object, metaclass=MyMetaclass, kwarg1=value1):
    ...

它在元类中转换为 this 以使用它：

class MyMetaclass(type):
    def __new__(cls, clsname, bases, dct, kwargs1=default):
        ...

而已。元类真的没有更多的东西了。

使用元类的代码复杂性背后的原因不是因为元类，而是因为您通常使用元类来做一些扭曲的事情，依赖于自省、操作继承、vars 等__dict__。

事实上，元类对于做黑魔法特别有用，因此也很复杂。但就其本身而言，它们很简单：

• 拦截类创建
• 修改类
• 返回修改后的类

为什么要使用元类类而不是函数？

既然__metaclass__可以接受任何可调用的，为什么要使用一个类，因为它显然更复杂？

这样做有几个原因：

• 意图很明确。当你阅读时UpperAttrMetaclass(type)，你知道接下来会发生什么
• 您可以使用 OOP。元类可以继承元类，覆盖父方法。元类甚至可以使用元类。
• 如果您指定了元类类，则类的子类将是其元类的实例，但不使用元类函数。
• 您可以更好地构建代码。您永远不会将元类用于像上面的示例这样微不足道的事情。它通常用于复杂的事情。能够创建多个方法并将它们分组到一个类中对于使代码更易于阅读非常有用。
• 你可以挂上__new__,__init__和__call__。这将使您可以做不同的事情，即使通常您可以全部完成__new__，但有些人使用起来更舒服__init__。
• 这些被称为元类，该死！一定是什么意思！

为什么要使用元类？

现在是个大问题。为什么要使用一些晦涩易错的功能？

好吧，通常你不会：

元类是更深层次的魔法，99% 的用户都不应该担心它。如果你想知道你是否需要它们，你就不需要（真正需要它们的人肯定知道他们需要它们，并且不需要解释为什么）。

Python 大师蒂姆·彼得斯

元类的主要用例是创建 API。一个典型的例子是 Django ORM。它允许您定义如下内容：

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

但如果你这样做：

person = Person(name='bob', age='35')
print(person.age)

它不会返回IntegerField对象。它将返回一个int，甚至可以直接从数据库中获取。

这是可能的，因为models.Model定义__metaclass__并且它使用了一些魔法，将Person您刚刚使用简单语句定义的内容转换为数据库字段的复杂挂钩。

Django 通过公开一个简单的 API 并使用元类，从这个 API 重新创建代码来完成幕后的真正工作，让复杂的事情看起来很简单。

最后一个字

首先，您知道类是可以创建实例的对象。

好吧，事实上，类本身就是实例。元类。

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

Python 中的一切都是对象，它们要么是类的实例，要么是元类的实例。

除了type.

type实际上是它自己的元类。这不是你可以在纯 Python 中重现的东西，而是通过在实现级别上作弊来完成的。

其次，元类很复杂。您可能不想将它们用于非常简单的类更改。您可以使用两种不同的技术更改类：

• 猴子补丁
• 类装饰器

99% 的时间你需要改变班级，你最好使用这些。

但是 98% 的情况下，您根本不需要更改班级。

这是 Javascript 第一类函数的示例：

// f: function that takes a number and returns a number
// deltaX: small positive number
// returns a function that is an approximate derivative of f
function makeDerivative( f, deltaX )
{
    var deriv = function(x)
    { 
       return ( f(x + deltaX) - f(x) )/ deltaX;
    }
    return deriv;
}
var cos = makeDerivative( Math.sin, 0.000001);
// cos(0)     ~> 1
// cos(pi/2)  ~> 0

来源。

不是第一类对象的实体称为第二类对象。C++ 中的函数是二等的，因为它们不能被动态创建。

关于编辑：

编辑。当一个人说“一切都是对象”（就像在 Python 中一样）时，他真的是指“一切都是一流的”吗？

术语对象可以松散地使用，并不意味着是一流的。将整个概念称为“一流实体”可能更有意义。但在 Python
中，他们的目标是让一切都成为一流的。我相信发表你的言论的人的意图是一流的。