Python 元类详解 __new__、__init__、__call__、__metacalss__

了解元类之前,先了解几个魔术方法: __new__、__init__、__call__

__new__: 对象的创建,是一个静态方法,第一个参数是cls。(想想也是,不可能是self,对象还没创建,哪来的self)
__init__ : 对象的初始化, 是一个实例方法,第一个参数是self。
__call__ : 对象可call,注意不是类,是对象。

class Bar(object):
    def __new__(cls, *args):
        self = super(Bar, cls).__new__(cls)
        #self = super().__new__(cls) #py3
        print '__new__'
        return self

    def __init__(self, *args):
        print '__init__'
        self.name = args[0]

    def __call__(self, *args):
        print '__call__', args
#执行
b = Bar('haha')
print b.name
b()

# 结果
__new__
__init__
hah
__call__ ()

__new____init__ 详解

__new__方法先被调用,返回一个实例对象,接着 __init__ 被调用。
从输出结果来看,__new__方法的返回值就是类的实例对象,这个实例对象会传递给 __init__ 方法中定义的 self 参数,以便实例对象可以被正确地初始化。

如果 __new__ 方法不返回值(或者说返回 None)那么 __init__ 将不会得到调用,这个也说得通,因为实例对象都没创建出来,调用__init__也没什么意义,此外,Python 还规定,__init__ 只能返回 None 值,否则报错,这个留给大家去试。

__init__方法可以用来做一些初始化工作,比如给实例对象的状态进行初始化

def __init__(self, *args):
    self.name = args[0]

另外,__init__方法中除了self之外定义的参数,都将与__new__方法中除cls参数之外的参数是必须保持一致或者等效。因为Bar(x, y)传参的时候是先给到__new__(), 然后再传递给init

另外:
__new__方法在类定义中不是必须写的,如果没定义,默认会调用object.__new__去创建一个对象。如果定义了,就是override,可以custom创建对象的行为。

聪明的读者可能想到,既然__new__可以custom对象的创建,那我在这里做一下手脚,每次创建对象都返回同一个,那不就是单例模式了吗?没错,就是这样。可以观摩《飘逸的python - 单例模式乱弹

定义单例模式时,因为自定义的__new__重载了父类的__new__,所以要自己显式调用父类的new,即object.__new__(cls, *args, **kwargs),或者用super()。
不然就不是extend原来的实例了,而是替换原来的实例。

所以:
上面的__new__()方法我们是重写父类object的方法, 所以我们必须至少执行
object.__new__(cls, *args, **kwargs) 或者
super(Bar, cls).__new__(cls)
这两个是等效的, 用super()可以不用hardcode父类名字。

__call__ 详解

实例化后的对象,再当函数一样执行就会执行到这个__call__函数

b = Bar('hah')
b()
#  输出
__call__ 

总结
在python中,类的行为就是这样,__new__、__init__、__call__等方法不是必须写的,会默认调用,如果自己定义了,就是override,可以custom。既然override了,通常也会显式调用进行补偿以达到extend的目的。

元类

Python中的类还远不止如此。类同样也是一种对象。是的,没错,就是对象。只要你使用关键字class,Python解释器在执行的时候就会创建一个对象。下面的代码段:

class ObjectCreator(object):
…       pass

将在内存中创建一个对象,名字就是ObjectCreator。这个对象(类)自身拥有创建对象(类实例)的能力,而这就是为什么它是一个类的原因。但是,它的本质仍然是一个对象,于是乎你可以对它做如下的操作:

  1. 你可以将它赋值给一个变量
  2. 你可以拷贝它
  3. 你可以为它增加属性
  4. 你可以将它作为函数参数进行传递
>>> print ObjectCreator     # 你可以打印一个类,因为它其实也是一个对象
<class '__main__.ObjectCreator'>
>>> def echo(o):
…       print o
…
>>> echo(ObjectCreator)                 # 你可以将类做为参数传给函数
<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 # 你可以将类赋值给一个变量
>>> print ObjectCreatorMirror()
<__main__.ObjectCreator object at 0x8997b4c>

type有一种完全不同的能力,它也能动态的创建类。type可以接受一个类的描述作为参数,然后返回一个类。(我知道,根据传入参数的不同,同一个函数拥有两种完全不同的用法是一件很傻的事情,但这在Python中是为了保持向后兼容性)

type可以像这样工作:

type(类名, 父类的元组(针对继承的情况,可以为空),包含属性的字典(名称和值))

比如下面的代码:

class Hello(object):
    def hello(self, name='world'):
        print('Hello, %s.' % name)

当Python解释器载入hello模块时,就会依次执行该模块的所有语句,执行结果就是动态创建出一个Hello的class对象,测试如下:

>>> from hello import Hello
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<type 'type'>
>>> print(type(h))
<class 'hello.Hello'>

type()函数可以查看一个类型或变量的类型,Hello是一个class,它的类型就是type,而h是一个实例,它的类型就是class Hello。

我们说class的定义是运行时动态创建的,而创建class的方法就是使用type()函数。

type()函数既可以返回一个对象的类型,又可以创建出新的类型,比如,我们可以通过type()函数创建出Hello类,而无需通过class Hello(object)...的定义:

>>> def fn(self, name='world'): # 先定义函数
...     print('Hello, %s.' % name)
...
>>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
>>> h = Hello()
>>> h.hello()
Hello, world.
>>> print(type(Hello))
<type 'type'>
>>> print(type(h))
<class '__main__.Hello'>

要创建一个class对象,type()函数依次传入3个参数:

  1. class的名称;
  2. 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法;
  3. class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上。

通过type()函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class定义的语法,然后调用type()函数创建出class。

正常情况下,我们都用class Xxx...来定义类,但是,type()函数也允许我们动态创建出类来,也就是说,动态语言本身支持运行期动态创建类。

你可以看到,在Python中,类也是对象,你可以动态的创建类。这就是当你使用关键字class时Python在幕后做的事情,而这就是通过元类来实现的。

元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象,不是吗?但是我们已经学习到了Python中的类也是对象。好吧,元类就是用来创建这些类(对象)的,元类就是类的类,你可以这样理解 为

这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢?好吧,我猜这是为了和str保持一致性,str是用来创建字符串对象的类,而int是用来创建整数对象的类。type就是创建类对象的类。你可以通过检查class属性来看到这一点。Python中所有的东西,注意,我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象,而且它们都是从一个类创建而来。

>>> a = 1
>>> b = 'hello'
>>> a.__class__
<type 'int'>
>>> b.__class__
<type 'str'>

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

上面看得出,哪怕int ,str的类,他们的__class__都是<type 'type'>, 说明他们都是由type元类实例化出来的对象,所以说元类(type)就是类的类

因此,元类就是创建类这种对象的东西。如果你喜欢的话,可以把元类称为“类工厂”(不要和工厂类搞混了:D) type就是Python的内建元类,当然了,你也可以创建自己的元类。

__metaclass__

你可以在写一个类的时候为其添加metaclass属性。

class Foo(object):
    __metaclass__ = something…

如果你这么做了,Python就会用元类来创建类Foo。小心点,这里面有些技巧。你首先写下class Foo(object),但是类对象Foo还没有在内存中创建。Python会在类的定义中寻找metaclass属性,如果找到了,Python就会用它来创建类Foo,如果没有找到,就会用内建的type来创建这个类。把下面这段话反复读几次。当你写如下代码时 :

class Foo(Bar):
    pass

Python做了如下的操作:

Foo中有__metaclass__这个属性吗?如果是,Python会在内存中通过__metaclass__创建一个名字为Foo的类对象(我说的是类对象,请紧跟我的思路)。如果Python没有找到__metaclass__,它会继续在Bar(父类)中寻找__metaclass__属性,并尝试做和前面同样的操作。如果Python在任何父类中都找不到__metaclass__,它就会在模块层次中去寻找__metaclass__,并尝试做同样的操作。如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。

现在的问题就是,你可以在__metaclass__中放置些什么代码呢?答案就是:可以创建一个类的东西。那么什么可以用来创建一个类呢?type,或者任何使用到type或者子类化type的东东都可以。

我们这里就先以一个简单的函数作为例子开始。

# 元类会自动将你通常传给‘type’的参数作为自己的参数传入
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    '''返回一个类对象,将属性都转为大写形式'''
    #  选择所有不以'__'开头的属性
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
    # 将它们转为大写形式
    uppercase_attr = dict((name.upper(), value) for name, value in attrs)

    # 通过'type'来做类对象的创建
    return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr  #  这会作用到这个模块中的所有类

class Foo(object):
    # 我们也可以只在这里定义__metaclass__,这样就只会作用于这个类中
    bar = 'bip'
print hasattr(Foo, 'bar')
# 输出: False
print hasattr(Foo, 'BAR')
# 输出:True

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

案例讲解:

  1. __metaclass__没有定义在类里面,而是在模块里面,所以这个根据上面的寻址规则,本类->父类->模块 这里的定义会让模块所有类都使用这个__metaclass__
  2. 使用upper_attr来创建类,它要么包含了type(), 要么直接用type(), 要么子类化type(), 这里是使用了type()
  3. 创建类的元类type()会依次传入3个参数:
    • class的名称;
    • 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法;
    • class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上。
      所以我们看到传到upper_attr()会有三个参数, future_class_name, future_class_parents, future_class_attr,分别代表上面的参数。

4.然后我们处理完类属性,把他们转成大小后,调用return type(future_class_name, future_class_parents, uppercase_attr) 完成创建类的过程。

  1. 说到底还是要使用type() 来创建类,只不过我们在默认的创建前拦截掉了,然后加入我们自己处理,比如属性转大写

当然了,用函数赋值给__metaclass__是可以的,但是不够OOP
现在让我们再做一次,这一次用一个真正的class来当做元类:

class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)

但就元类本身而言,它们其实是很简单的:

  1. 拦截类的创建
  2. 修改类
  3. 返回修改之后的类

为什么要用metaclass类而不是函数?

由于__metaclass__可以接受任何可调用的对象,那为何还要使用类呢,因为很显然使用类会更加复杂啊?这里有好几个原因:

1) 意图会更加清晰。当你读到UpperAttrMetaclass(type)时,你知道接下来要发生什么。
2) 你可以使用OOP编程。元类可以从元类中继承而来,改写父类的方法。元类甚至还可以使用元类。
3) 你可以把代码组织的更好。当你使用元类的时候肯定不会是像我上面举的这种简单场景,通常都是针对比较复杂的问题。将多个方法归总到一个类中会很有帮助,也会使得代码更容易阅读。
4) 你可以使用__new__, __init__以及__call__这样的特殊方法。它们能帮你处理不同的任务。就算通常你可以把所有的东西都在__new__里处理掉,有些人还是觉得用__init__更舒服些。
5) 重点如果使用函数像第一个方法,必须显式调用type.__new__()方法,如果是下面的子类继承type类OOP的方式,则不用

例子:单利模式

先看一个单例:使用__metalcass__

class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

class Foo():
    __metaclass__ = Singleton

f = Foo()
f2=Foo()
# 输出f == f2 他们是同一个实例化对象

详细讲解这个单例模式是什么流程:

  1. 首先,我们在Foo里面定义了__metaclass__= Singleton,这个Singleton是type的子类,这里如果不写__metaclass__=Singleton默认会是__metaclass__= type, 创建类的时候,还是调用type.__new__方法。因为Foo就是type创建的实例。这里Singleton只是扩展了type,某些方法,但大部分功能还是继承type的,__new__这里没有重写,说明还是使用的type.__new__来创建这个Foo
  2. 既然我们子类Singleton 没有重写type的__new__, __init__方法,那么就说明在创建Foo这个类(对于type来说是实例对象)的时候,还是使用默认的方式!
  3. 我们在Singleton重写了__call__方法,也就是重写了type的这个方法,那么这个方法会在什么时候发挥作用呢?我们知道__call__是实例在像函数一样调用的时候,会触发的 比如f = Foo(), f(5) 这个f(5)就会调用Foo类的__call__方法。 而在我们Foo()获取单例的时候,实际上Foo也是type的实例,Foo虽然是类,它同时也是type的实例所以Foo()生成Foo的实例的同时,触发了Foo的类type的__call__方法!
  4. 所以就在这时,触发了它的元类也就是Singleton的__call__(如果没有定义__metaclass__,就会默认调用type.__call)方法,这个__call__方法判断了是否单例。注意Singleton重写了__call__方法以后,一定要重新调用原来的默认的type.__call__()方法, 所以也就看到了
    foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)实际上就是type在调用__call__()

一开始误解很久的地方:

  1. 我以为__metaclass__=Singleton 在创建类Foo的时候调用Singleton() 就会马上执行它的__call__()方法,其实不然,可以直接把Singleton想象成在执行默认的type(),还是像原来的方式通过type.__new__() type.__init__()来创建类。
  2. 当然了既然Singleton是type的子类,也是它的实例,所以Singleton(), 也是会执行type.__call__()方法拉,这个方法应该就是返回Singleton的实例了。 也就是创建完的Foo类
  3. Singleton为什么要用__call()__ 用__new()__可以么?看下面
class Singleton(type):
    def __new__(cls, future_class_name, future_class_parents, future_class_attrs):
        print '__new__', cls, future_class_name, future_class_parents, future_class_attrs
        attrs = [(k, v) for k, v in future_class_attrs.items() if not k.startswith('__')]
        new_attrs = dict([(k.upper(), v)for k, v in attrs])
        print new_attrs
        return super(Singleton, cls).__new__(cls, future_class_name, future_class_parents, new_attrs)

    def __call__(foo_cls, *args, **kwargs):
        if not hasattr(foo_cls, '_instance'):
            foo_cls._instance = super(Singleton, foo_cls).__call__(*args, **kwargs)
        return foo_cls._instance

f = Foo()
print hasattr(f, 'bar') # False
print hasattr(f, 'BAR') # True
f.GET_NAME() # haha
print f.bar  # error
print f.BAR # hello world

解答元类__new__和 __call__的区别

  1. type.__new__()就是用来生成的!所以只会调用一次,因为类Foo只需要一个!所以__new__是用来再创建类的时候,做拦截,加入一些我们自己的逻辑,比如这里我把所有类方法,类属性转成了大写!
  2. __call__则是每次类调用的时候也就是Foo()会触发,每次都会触发。

圈重点了

使用__new__写单例

class Singleton(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls, *args, **kwargs)
        return cls._instance

class Foo(Singleton):
    a = 1

这个流程比较清晰了:

  1. 定义Foo的时候没有定义__metaclass__ 所以由默认方式type()来创建
  2. Foo()创建实例的时候,首先执行__new__()方法,创建实例,就再此时拦截掉默认的创建实例方法
    object.__new()__ 我们加入判断类是否有这个单例的属性,有则直接返回,没有则先用object.__new__创建,然后返回

例子:ORM

ORM提供简单接口给用户调用

class User(Model):
    # 这些定义的类变量
    id = IntegerField('id')
    name = StringField('name')
    email = StringField('email')
    password = StringField('password')

user = User(name="lisalian", email="lisalian@qq.com")
user.password = '123456'
user.save()

定义好一个User表的类,然后传入参数,user.save()就能完成插入数据库的功能

首先来定义Field类,它负责保存数据库表的字段名和字段类型:

class Field(object):
    def __init__(self, column, column_type):
        self.column = column
        self.column_type = column_type

    def __str(self):
        return '<%s:%s>' % (self.__class__.__name__, self.column)

在Field的基础上,进一步定义各种类型的Field,比如StringField,IntegerField等等:

class IntegerField(Field):
    def __init__(self, column):
        super(IntegerField, self).__init__(column, 'int')

class StringField(Field):
    def __init__(self, column):
        super(StringField, self).__init__(column, 'varchar')

__meataclass__的编写:


class MetaModel(type):
    def __new__(cls, name, bases, attrs):
        """这个__metaclass__同样适用于Model,只不过它也适用于子类User
            如果是创建Model类,则跳过__maping__的处理
        """
        if name == "Model":
            return super(MetaModel, cls).__new__(cls, name, bases, attrs)

        __maping__ = {}
        for k, v in attrs.iteritems():
            if isinstance(v, Field):
                print 'find field %s' % v.column
                __maping__[k] = v

        attrs['__maping__'] = __maping__
        attrs['__table__'] = name
        for k in __maping__.keys():
            attrs.pop(k)

        # 显式调用__new__() 是要传cls参数,
        # 平常我们不是显示调用才不需要self, cls这样的参数
        return super(MetaModel, cls).__new__(cls, name, bases, attrs)

以及Model基类

class Model(object):
    __metaclass__ = MetaModel

    field_dict = {}
    def __init__(self, **kw):
        self.field_dict.update(kw)
        # 如果Model(dict)这样定义的话就这样执行,这样Model就是dict的子类,一个字典
        #super(Model, self).__init__(self, **kw)

    # 实例对象设置新属性时调用
    def __setattr__(self, name, value):
        self.field_dict[name] = value

    # 实例对象调用不存在属性时调用
    def __getattr__(self, name):
        try:
            return self.field_dict[name]
        except KeyError:
            raise AttributeError('Model object has no attributes %s' % name)

    """save 方法定义在Model这里,就可以让所有继承了Model的数据表
        都有save()
       save方法作用是获取子类的实例的各个字段值,拼凑出insert的SQL
       那么问题来了:怎么获取子类的实例的字段,子类的字段都是随便定义的
       不是Model这里继承过去,Model不能知道有什么字段

       这个save方法被继承于User,最后执行也是再User里面执行
       所以在定义User类的时候,就生成一些字段的映射关系,这就要利用元类了
    """
    def save(self):
        args = []
        params = []
        fields = []
        for k, v in self.__maping__.iteritems():
            fields.append(k)
            args.append(self.field_dict.get(k, None))
            params.append('?')

        print fields
        print params
        print args
        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params))
        print sql

详解ORM:

  1. User()类定义的字段,就是数据表的字段,每个字段对应着一个Field实例。
  2. User继承了Model的方法和元类,save()和__metaclass__
    3.__metaclass__最重要的功能就是,在创建类的时候,把定义再User类里面的字段关系,转成一个字段__mapping__保存到User类里面,这样使用save()方法的时候才能获取到这些映射关系。不然你直接定义的各个字段在save的时候,根本获取不到。

参考:

深刻理解Python中的元类(metaclass)
飘逸的python - 单例模式乱弹
stackoverflow 单例
使用元类

推荐阅读更多精彩内容

  • 转至元数据结尾创建: 董潇伟,最新修改于: 十二月 23, 2016 转至元数据起始第一章:isa和Class一....
    40c0490e5268阅读 1,365评论 0 9
  • Python 面向对象Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对...
    顺毛阅读 3,882评论 4 16
  • 爱学习爱写作爱逻辑
    乐学福阅读 87评论 0 0
  • 七月的书单之一就是《小狗钱钱》。它非常出名是因为它是一本儿童财商启蒙书,同时也是很多理财小白入门的推荐书籍。 但是...
    童童小瑾书阅读 1,236评论 2 5
  • "想去远方旅行呀!" 有这样想法的时候,大多都是没有假期、有其他事情、有很多障碍等等去不了远方旅行的情况...
    静雅_李阅读 138评论 0 0