首页 > 编程语言 > 详细

python中Metaclass的理解

时间:2019-02-22 20:12:07      阅读:153      评论:0      收藏:0      [点我收藏+]

  今天在学习《python3爬虫开发实战》中看到这样一段代码3

 1 class ProxyMetaclass(type):
 2     def __new__(cls, name, bases, attrs):
 3         count = 0
 4         attrs[__CrawlFunc__] = []
 5         for k, v in attrs.items():
 6             if crawl in k:
 7                 attrs[__CrawlFunc__].append(k)
 8                 count += 1
 9         attrs[__CrawlFunc__] = count
10         return type.__new__(cls, name, bases, attrs)
11 
12 class Crawler(object, metaclass=ProxyMetaclass)

从来没有见过创建类的时候,传入一个metaclass参数。于是通过查找资料得知,Metacalss为python中的元类。

简单的讲,元类创建了Python中所有的对象。

我们说Python是一种动态语言,而动态语言和静态语言最大的不同,就是函数和类不是编译时定义的,而是运行时动态创建的

比方说我们要定义一个HelloWorld的class,就写一个helloworld.py模块:

class HelloWorld(object):
    def helloworld(self):
        print(‘Hello World!‘)

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

>>> from helloworld import HelloWorld
>>> h = HelloWorld()
>>> h.helloworld()
Hello, world!
>>> print(type(HelloWorld))
<class type>
>>> print(type(h))
<class helloworld.HelloWorld>

type()函数用来查看一个类型或变量的类型,HelloWorld是一个class,它的类型就是type,而h是一个实例,它的类型就是class Helloworld

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

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

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

>>> def helloworld_outside(self): # 先定义函数
...     print(Hello World!)
...
>>> HelloWorld = type(HelloWorld, (object,), dict(helloworld=helloworld_outside)) # 创建HelloWorld class
>>> h = HelloWorld()
>>> h.helloworld()
Hello, world!
>>> print(type(HelloWorld))
<class type>
>>> print(type(h))
<class __main__.HelloWorld>

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

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

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

正常情况下,我们都用class Xxx...来定义类,但是,type()函数也允许我们动态创建出类来,也就是说,动态语言本身支持运行期动态创建类,这和静态语言有非常大的不同,要在静态语言运行期创建类,必须构造源代码字符串再调用编译器,或者借助一些工具生成字节码实现,本质上都是动态编译,会非常复杂。

metaclass

除了使用type()动态创建类以外,要控制类的创建行为,还可以使用metaclass

metaclass,直译为元类,简单的解释就是:

当我们定义了类以后,就可以根据这个类创建出实例,所以:先定义类,然后创建实例。

但是如果我们想创建出类呢?那就必须根据metaclass创建出类,所以:先定义metaclass,然后创建类

所以,metaclass允许你创建类或者修改类。换句话说,你可以把类看成是metaclass创建出来的“实例”。

metaclass是Python面向对象里最难理解,也是最难使用的魔术代码。正常情况下,你不会碰到需要使用metaclass的情况,所以,以下内容看不懂也没关系,因为基本上你不会用到。

我们先看一个简单的例子,这个metaclass可以给我们自定义的MyList增加一个add方法:

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 MyList(list, metaclass=ListMetaclass):
    pass

下面是运行结果,测试一下MyList是否可以调用add()方法:

>>> L = MyList()
>>> L.add(1)
>> L
[1]

通过这个例子我们可以看到,自定义我们的MyList分两步:

1. 创建Metaclass,用来创建/修改类

2. 创建实际的MyList Class

首先我们来看第一步,创建Metaclass:

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

  • 类名的定义:定义ListMetaclass,按照默认习惯,metaclass的类名总是以Metaclass结尾,以便清楚地表示这是一个metaclass
  • Metaclass的父类:Metaclass是类的模板,所以必须从`type`类型派生:
  • 选择__new__函数作为实现"修改类"的函数
    • 函数__new__(cls, name,bases,attrs)中,"cls"类似于类中其他函数的self参数,例如__init__(self),只不过self代表创建的对象,而cls代表类本身(__init__作为实例初始化的函数,需要把实例本身作为参数传进去,这样我们才能保证被修改的是实例;同理,__new__函数需要把类本身作为参数传进去,才能保证被初始化的是当前类); name代表类的名称;bases代表当前类的父类集合;attrs代表当前类的属性,是狭义上属性和方法的集合,可以用字典dict的方式传入
    • 对__new__的定义def __new__(cls, name,bases,attrs),实际上,“new”方法在Python中是真正的构造方法(创建并返回实例),通过这个方法可以产生一个”cls”对应的实例对象所以说”new”方法一定要有返回,要把创建的实例对象返回回去。在此,我们把对类的修改放到__new__方法中,然后返回修改过后的实例对象。另外,很简单的道理,选择type.__new__函数作为return的值,是因为我们的ListMetaclass继承自type,因此应该返回class type的__new__函数创建的对象。
class MyList(list, metaclass=ListMetaclass):
    pass

有了ListMetaclass,下一个问题是如何使用ListMetaclass?

首先我们需要先谈一谈Python创建class的机制:

当创建class的时候,python会先检查当前类中有没有__metaclass__,如果有,就用此方法创建对象;如果没有,则会一级一级的检查父类中有没有__metaclass__,用来创建对象。创建的这个“对象”,就是当前的这个类。如果当前类和父类都没有,则会在当前package中寻找__metaclass__方法,如果还没有,则会调用自己隐藏的的type函数来创建对象

值得注意的是,如果我们在做类的定义时,在class声明处传入关键字metaclass=ListMetaclass,那么如果传入的这个metaclass有__call__函数,这个__call__函数将会覆盖掉MyList class的__new__函数。这是为什么呢?请大家回想一下,当我们实例化MyList的时候,用的语句是L1=MyList(),而我们知道,__call__函数的作用是能让类实例化后的对象能够像函数一样被调用。也就是说MyList是ListMetaclass实例化后的对象,而MyList()调用的就是ListMetaclass的__call__函数。另外,值得一提的是,如果class声明处,我们是让MyList继承ListMetaclass,那么ListMetaclass的__call__函数将不会覆盖掉MyList的__new__函数。

因此,我们在定义类的时候还要指示使用ListMetaclass来定制类(即在MyList class定义时,在class声明处传入关键字参数metaclass=ListMetaclass):我们传入关键字参数metaclass后,python会在当前class里创建属性__metaclass__,因此它指示Python解释器在创建MyList时,要通过ListMetaclass.__new__()来创建,在ListMetaclass.__new__()中,我们可以修改类的定义,比如,加上新的方法,然后,返回修改后的定义。

Ok,下面测试一下MyList是否可以调用add()方法:

>>> L = MyList()
>>> L.add(1)
>> L
[1]

而普通的list没有add()方法:

>>> L2 = list()
>>> L2.add(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: ‘list‘ object has no attribute ‘add‘

动态修改有什么意义?直接在MyList定义中写上add()方法不是更简单吗?正常情况下,确实应该直接写,通过metaclass修改纯属变态。

但是,总会遇到需要通过metaclass修改类定义的。ORM就是一个典型的例子。

ORM全称“Object Relational Mapping”,即对象-关系映射,就是把关系数据库的一行映射为一个对象,也就是一个类对应一个表,这样,写代码更简单,不用直接操作SQL语句。

python中Metaclass的理解

原文:https://www.cnblogs.com/yc3110/p/10420315.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!