Python高级语法-贯彻回顾-元类（4.99.1）

@

目录

• 1.为什么要掌握元类
• 2.正文
• 关于作者

1.为什么要掌握元类

在django中编写models的时候遇到了元类的相关操作
并且在mini-web框架编写的时候也遇到了相关的问题
意识到深入理解元类非常的重要所以补票重学

学习且引用来自博客：https://www.cnblogs.com/intimacy/p/8119449.html

2.正文

python中一切都是对象，类也是对象
那么意味着，类可以执行以下操作

• 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.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

因为类是对象，那么意味着可以动态的生成
粗略的以为，在java等语言中，类使用来定义一个对象的，也就是用来定义起亚数据类型的，私以为不可以更改。但是python好像就可以更改类的源代码，导致你想在运行的时候重新规定一下类中的属性和方法也是可以的，比如下面的代码传入foo参数的时候在内存中定义一个class对象，但是传入其他的时候就不定义

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # 返回Foo类,而不是对象
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # 方法返回类,不返回对象
<class '__main__.Foo'>
>>> print(MyClass()) # 可以通过方法返回的类创建对象
<__main__.Foo object at 0x89c6d4c>

但这似乎不是动态创建的，因为我们写了一段代码来生成他，然后python解释器遇到class关键字的时候就自动给我们程序创建了一个类对象，那么如何自己创建一个，使用type

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

type在我们学习python的历程中可以知道是用来判断数据类型的，但是type确实可以用来创建一个类对象，格式如下

type(类对象的名称, 元组形式的所有父类对象 (继承用，可以为空),包含属性名和属性值的字典)

>>> class MyShinyClass(object):
...       pass
-------------------------------------------------------------------
>>> MyShinyClass = type('MyShinyClass', (), {}) # 返回一个类对象
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # 通过返回的类对象创建一个对象
<__main__.MyShinyClass object at 0x8997cec>

上面两部分代码实现的功能是一样的
再如

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

这两部分代码的功能也是一样的，所以让我们再次熟悉一下type创建类对象的使用方法，第一个参数为类的名字，第二个参数为多继承使用的元组，第三个参数为一个列表，用来定义类中的方法和属性

>>> 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中，类就是对象，你能在运行中动态的创建类

那么metaclass是啥呢
metaclass是创建class的东西，定义类的目的，就是为了创建一个对象，但是我们已经知道了，python中类就是一个对象，那么metaclass就是创建这种对象（类）的东西，他们是用来描述类的，可以理解为

MyClass = MetaClass()
MyObject = MyClass()
#使用metaclass创建了一个类对象，在使用这个类对象去创建其他的对象

我们已经知道，type可以为我们创建一个对象
是因为方法type实际上是一个metaclass，type就是python用来创建其他类的metaclass， 你可以通过__class__属性来验证这一点 也就是说type就是用来创建其他class的class，在Python中一切皆对象，一切皆对象，包括int str function(方法) class(类)，所有一切都是对象，而且他们都是有某一个类创建

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

所以一个metaclass就是用来创建类对象的东西，你可以称之为“类工厂”。而type就是Python內建的metaclass(类工厂)，当然你能定义你自己的metaclass

在python中创建一个对象之前，回去找metaclass，如果没有指定的话就使用type来创建类对象

Python会：
    1、在Foo中有没有指定__metaclass__属性
    2、如果找到，就会通过__metaclass__指定的东西创建Foo类对象(注意此处是类对象)
    3、如果找不到，就会去MODULE(模块)级别去找，并创建Foo类对象(但只适用于没有继承任何父类的类,基本上就是老式类)
    4、如果都找不到，就会通过Bar(第一个父类)的metaclass(很有可能是type)来创建Foo类对象,
    5、这里要注意__metaclass__不会被继承，而父类的__class__(Bar.__class__)会被子类继承.即：如果Bar用了__metaclass__属性通过type()而不是type.__new__()创建Bar类对象,那么子类不会继承这种行为。
现在问题是：可以将什么指定给__metaclass__。
答案是：能创建类的东西。
什么能创建类呢？type type的子类 和所有使用type的

自定义metaclass

metaclass的主要作用就是创建类时使类发生变化
通常做API时才会用到，就是创建和上下文相吻合的类(这句翻的太烂)。
举个例子：你决定所有模块下的类的属性都要大写，有很多种方法实现此需求，其中一种就是在module级别设置__metaclass__属性。
这样一来，此模块下所有类都通过指定的metaclass创建，你只需要告诉metaclass将所有属性大写即可。
幸运的是__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_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'

现在使用一个类做metaclass来实现

# 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)

上面代码说的new方法是在init方法之前调用的，new方法是创建一个对象并返回他，init方法只是通过传入参数初始化一个对象，我们几乎用不到new方法，如果你不是想去控制类对象如何生成

上面的方式不是很"面向对象"，因为我们直接调用了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，所有的参数也有简短的名字，所以一个真正的metaclass会像下面这样：

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)

实际上，metaclass在做黑魔法时尤其 有用，也就是做复杂的事情。至于metaclass本身，还是很简单的：
    1、拦截类的生成
    2、修改类
    3、返回修改后的类

为什么用metaclass而不用方法呢？
既然__metaclass__能接收一切可被调用的东西,为什么要用class呢，class可是比方法复杂的多啊！！！
主要是以下几个原因：
1、目的更明确。你看到UpperAttrMetaclass(type),就知道是什么意思
2、能用"面向对象编程"，metaclass可以继承metaclass可以重写父类方法，甚至可以使用其他metaclass。
3、某个类如果你指定了metaclass，则它的子类是这个metaclass的实例，但如果指定了metaclass为function则不是(一个类不能是某个方法的实例)。
4、代码结构会更好。上面使用metaclass的例子已经非常简单了，通过使用metaclass的情况都是比较复杂的。将所有方法组织在一个class中，能使你的代码更易读。
5、可以在__new__,__init__和__call__中做你想做的事，虽然你能都在__new__写，但有些人还是习惯在__init_中实现。
6、叫metaclass，该死的，这名字还是有些意义的。

• metaclass的主要用于创建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__，而指向的metaclass将你定义的简单的Person类变为数据库中的一个字段。
    利用metaclass，Django暴露一套API使得复杂的事情看起来很简单，而在幕后做真正的工作。

最后：
首先，类就是能创建实例的对象。实际上，类是metaclass的实例

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

在Python中一切都是对象(实例)，他们不是类的实例就是metaclass的实例。
除了type。type的metaclass是自己，实际上在纯Python中是不能创建type的，而是通过在Python的实现层作弊实现的。
其次，metaclass是很复杂的。如果你只要对类做一点点调整，就不要使用metaclass，你可以用另外两种技术来实现：
    猴子补丁(monkey patching)
    装饰器
当你需要对类做调整，99%的情况下你可以通过以上两种方式实现。
但是98%的情况是：你完全不需要对类做调整

关于作者

个人博客网站
个人GitHub地址
个人公众号：