Python中的元类编程入门指引


Posted in Python onApril 15, 2015

回顾面向对象编程

让我们先用 30 秒钟来回顾一下 OOP 到底是什么。在面向对象编程语言中,可以定义 类,它们的用途是将相关的数据和行为捆绑在一起。这些类可以继承其 父类的部分或全部性质,但也可以定义自己的属性(数据)或方法(行为)。在定义类的过程结束时,类通常充当用来创建 实例(有时也简单地称为 对象)的模板。同一个类的不同实例通常有不同的数据,但“外表”都是一样 — 例如, Employee 对象 bob 和 jane 都有 .salary 和 .room_number ,但两者的房间和薪水都各不相同。

一些 OOP 语言(包括 Python)允许对象是 自省的(也称为 反射)。即,自省对象能够描述自己:实例属于哪个类?类有哪些祖先?对象可以用哪些方法和属性?自省让处理对象的函数或方法根据传递给函数或方法的对象类型来做决定。即使没有自省,函数也常常根据实例数据进行划分,例如,到 jane.room_number 的路线不同于到 bob.room_number 的路线,因为它俩在不同的房间。利用自省, 还可以在安全地计算 jane 所获奖金的同时,跳过对 bob 的计算,例如,因为 jane 有 .profit_share 属性,或者因为 bob 是子类 Hourly(Employee) 的实例。

元类编程(metaprogramming)的回答

以上概述的基本 OOP 系统功能相当强大。但在上述描述中有一个要素没有受到重视:在 Python(以及其它语言)中,类本身就是可以被传递和自省的对象。正如前面所讲到的,既然可以用类作为模板来生成对象,那么用什么 作为模板来生成类呢?答案当然是 元类(metaclass)。

Python 一直都有元类。但元类中所涉及的方法在 Python 2.2 中才得以更好地公开在人们面前。Python V2.2 明确地不再只使用一个特殊的(通常是隐藏的)元类来创建每个类对象。现在程序员可以创建原始元类 type 的子类,甚至可以用各种元类动态地生成类。当然,仅仅因为 可以在 Python 2.2 中操作元类,这并不能说明您可能想这样做的原因。

而且,不需要使用定制元类来操作类的生成。一种不太费脑筋的概念是 类工厂:一种普通的函数,它可以 返回在函数体内动态创建的类。用传统的 Python 语法,您可以编写:
清单 1. 老式的 Python 1.5.2 类工厂

Python 1.5.2 (#0, Jun 27 1999, 11:23:01) [...]
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> def class_with_method(func):
...   class klass: pass
...   setattr(klass, func.__name__, func)
...   return klass
...
>>> def say_foo(self): print 'foo'
...
>>> Foo = class_with_method(say_foo)
>>> foo = Foo()
>>> foo.say_foo()
foo

工厂函数 class_with_method() 动态地创建一个类,并返回该类,这个类包含传递给该工厂 的方法/函数。在返回该类之前,在函数体内操作类自身。 new 模块提供了更简洁的编码方式,但其中的选项与 类工厂体内定制代码的选项不同,例如:
清单 2. new 模块中的类工厂

>>> from new import classobj
>>> Foo2 = classobj('Foo2',(Foo,),{'bar':lambda self:'bar'})
>>> Foo2().bar()
'bar'
>>> Foo2().say_foo()
foo

在所有这些情形中,没有将类( Foo 和 Foo2 )的行为直接编写为代码, 而是用动态参数在运行时调用函数来创建类的行为。这里要强调的一点是,不仅 实例可以动态地创建,而且 类本身也可以动态地创建。

元类:寻求问题的解决方案?

    元类的魔力是如此之大,以至于 99% 的用户曾有过的顾虑都是不必要的。如果您想知道是否需要它们,则可以不用它们(那些实际需要元类的人们确实清楚自己需要它们,不需要解释原因)。— Python 专家 Tim Peters

(类的)方法象普通函数一样可以返回对象。所以从这个意义上讲,类工厂可以是类,就象它们可以是函数一样容易,这是显然的。尤其 是 Python 2.2+ 提供了一个称为 type 的特殊类,它正是这样的类工厂。当然,读者会认识到 type() 不象 Python 老版本的内置函数那样“野心勃勃”— 幸运的是,老版本的 type() 函数的行为是由 type 类维护的(换句话说, type(obj) 返回对象 obj 的类型/类)。作为类工厂的新 type 类,其工作方式与函数 new.classobj 一直所具有的方式相同:
清单 3. 作为类工厂元类的 type

>>> X = type('X',(),{'foo':lambda self:'foo'})
>>> X, X().foo()
(<class '__main__.X'>, 'foo')

但是因为 type 现在是(元)类,所以可以自由用它来创建子类:
清单 4. 作为类工厂的 type 后代

>>> class ChattyType(type):
...   def __new__(cls, name, bases, dct):
...     print "Allocating memory for class", name
...     return type.__new__(cls, name, bases, dct)
...   def __init__(cls, name, bases, dct):
...     print "Init'ing (configuring) class", name
...     super(ChattyType, cls).__init__(name, bases, dct)
...
>>> X = ChattyType('X',(),{'foo':lambda self:'foo'})
Allocating memory for class X
Init'ing (configuring) class X
>>> X, X().foo()
(<class '__main__.X'>, 'foo')

富有“魔力”的 .__new__() 和 .__init__() 方法很特殊,但在概念上,对于任何其它类,它们的工作方式都是一样的。 .__init__() 方法使您能配置所创建的对象; .__new__() 方法使您能定制它的分配。当然,后者没有被广泛地使用,但对于每个 Python 2.2 new 样式的类(通常通过继承而不是覆盖),都存在该方法。

需要注意 type 后代的一个特性;它常使第一次使用元类的人们“上圈套”。按照惯例,这些方法的第一个参数名为 cls ,而不是 self ,因为这些方法是在 已生成的类上进行操作的,而不是在元类上。事实上,关于这点没什么特别的;所有方法附加在它们的实例上,而且元类的实例是类。非特殊的 名称使这更明显:
清单 5. 将类方法附加在所生成的类上

>>> class Printable(type):
...   def whoami(cls): print "I am a", cls.__name__
...
>>> Foo = Printable('Foo',(),{})
>>> Foo.whoami()
I am a Foo
>>> Printable.whoami()
Traceback (most recent call last):
TypeError: unbound method whoami() [...]

所有这些令人惊讶但又常见的做法以及便于掌握的语法使得元类的使用更容易,但也让新用户感到迷惑。对于其它语法有几个元素。但这些新变体的解析顺序需要点技巧。类可以从其祖先那继承元类 — 请注意,这与将元类 作为祖先 不一样(这是另一处常让人迷惑的地方)。对于老式类,定义一个全局 _metaclass_ 变量可以强制使用定制元类。但大多数时间,最安全的方法是,在希望通过定制元类来创建类时,设置该类的 _metaclass_ 类属性。必须在类定义本身中设置变量,因为 如果稍后(在已经创建类对象之后)设置属性 ,则不会使用元类。例如:
清单 6. 用类属性设置元类

>>> class Bar:
...   __metaclass__ = Printable
...   def foomethod(self): print 'foo'
...
>>> Bar.whoami()
I am a Bar
>>> Bar().foomethod()
foo

用这种“魔力”来解决问题

至此,我们已经了解了一些有关元类的基本知识。但要使用元类,则比较复杂。使用元类的困难之处在于,通常在 OOP 设计中,类其实 做得不多。对于封装和打包数据和方法,类的继承结构很有用,但在具体 情形中,人们通常使用实例。

我们认为元类在两大类编程任务中确实有用。

第一类(可能是更常见的一类)是在设计时不能 确切地知道类需要做什么。显然,您对它有所了解,但某个特殊的细节 可能取决于稍后才能得到的信息。“稍后”本身有两类:(a)当应用程序使用库模块时;(b)在运行时,当某种情形存在时。这类很接近于通常所说的“面向方面的编程(Aspect-Oriented Programming,AOP)”。我们将展示一个我们认为非常别致的示例:
清单 7. 运行时的元类配置

% cat dump.py
#!/usr/bin/python
import sys
if len(sys.argv) > 2:
  module, metaklass = sys.argv[1:3]
  m = __import__(module, globals(), locals(), [metaklass])
  __metaclass__ = getattr(m, metaklass)
class Data:
  def __init__(self):
    self.num = 38
    self.lst = ['a','b','c']
    self.str = 'spam'
  dumps  = lambda self: `self`
  __str__ = lambda self: self.dumps()
data = Data()
print data
% dump.py
<__main__.Data instance at 1686a0>

正如您所期望的,该应用程序打印出 data 对象相当常规的描述(常规的实例对象)。但如果将 运行时参数传递给应用程序,则可以得到相当不同的结果:
清单 8. 添加外部序列化元类

% dump.py gnosis.magic MetaXMLPickler
<?xml version="1.0"?>
<!DOCTYPE PyObject SYSTEM "PyObjects.dtd">
<PyObject module="__main__" class="Data" id="720748">
<attr name="lst" type="list" id="980012" >
 <item type="string" value="a" />
 <item type="string" value="b" />
 <item type="string" value="c" />
</attr>
<attr name="num" type="numeric" value="38" />
<attr name="str" type="string" value="spam" />
</PyObject>

这个特殊的示例使用 gnosis.xml.pickle 的序列化样式,但最新的 gnosis.magic 包还包含元类序列化器 MetaYamlDump 、 MetaPyPickler 和 MetaPrettyPrint 。而且, dump.py “应用程序”的用户可以从任何定义了任何期望的 MetaPickler 的 Python 包中利用该“MetaPickler”。出于此目的而 编写合适的元类如下所示:
清单 9. 用元类添加属性

class MetaPickler(type):
  "Metaclass for gnosis.xml.pickle serialization"
  def __init__(cls, name, bases, dict):
    from gnosis.xml.pickle import dumps
    super(MetaPickler, cls).__init__(name, bases, dict)
    setattr(cls, 'dumps', dumps)

这种安排的过人之处在于应用程序程序员不需要了解要使用哪种序列化 — 甚至不需要了解是否 在命令行添加序列化或其它一些跨各部分的能力。

也许元类最常见的用法与 MetaPickler 类似:添加、删除、重命名或替换所产生类中定义的方法。在我们的示例中,在创建类 Data (以及由此再创建随后的每个实例)时,“本机” Data.dump() 方法被应用程序之外的某个方法所替代。


使用这种“魔力”来解决问题的其它方法

存在着这样的编程环境:类往往比实例更重要。例如, 说明性迷你语言(declarative mini-languages)是 Python 库,在类声明中直接表示了它的程序逻辑。David 在其文章“ Create declarative mini-languages”中研究了此问题。在这种情形下,使用元类来影响类创建过程是相当有用的。

一种基于类的声明性框架是 gnosis.xml.validity 。 在此框架下,可以声明许多“有效性类”,这些类表示了一组有关有效 XML 文档的约束。这些声明非常接近于 DTD 中所包含的那些声明。例如,可以用以下代码来配置一篇“dissertation”文档:
清单 10. simple_diss.py gnosis.xml.validity 规则

from gnosis.xml.validity import *
class figure(EMPTY):   pass
class _mixedpara(Or):   _disjoins = (PCDATA, figure)
class paragraph(Some):  _type = _mixedpara
class title(PCDATA):   pass
class _paras(Some):    _type = paragraph
class chapter(Seq):    _order = (title, _paras)
class dissertation(Some): _type = chapter

如果在没有正确组件子元素的情形下尝试实例化 dissertation 类,则会产生一个描述性异常;对于每个 子元素,亦是如此。当只有一种明确的方式可以将参数“提升”为正确的类型 时,会从较简单的参数来生成正确的子元素。

即使有效性类常常(非正式)基于预先存在的 DTD,这些类的实例也还是将自己打印成简单的 XML 文档片段,例如:
清单 11. 基本的有效性类文档的创建

>>> from simple_diss import *
>>> ch = LiftSeq(chapter, ('It Starts','When it began'))
>>> print ch
<chapter><title>It Starts</title>
<paragraph>When it began</paragraph>
</chapter>

通过使用元类来创建有效性类,我们可以从类声明中生成 DTD(我们在这样做的同时,可以向这些有效性类额外添加一个方法):
清单 12. 在模块导入期间利用元类

>>> from gnosis.magic import DTDGenerator, \
...             import_with_metaclass, \
...             from_import
>>> d = import_with_metaclass('simple_diss',DTDGenerator)
>>> from_import(d,'**')
>>> ch = LiftSeq(chapter, ('It Starts','When it began'))
>>> print ch.with_internal_subset()
<?xml version='1.0'?>
<!DOCTYPE chapter [
<!ELEMENT figure EMPTY>
<!ELEMENT dissertation (chapter)+>
<!ELEMENT chapter (title,paragraph+)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT paragraph ((#PCDATA|figure))+>
]>
<chapter><title>It Starts</title>
<paragraph>When it began</paragraph>
</chapter>

包 gnosis.xml.validity 不知道 DTD 和内部子集。那些概念和能力完全由元类 DTDGenerator 引入进来,对 gnosis.xml.validity 或 simple_diss.py 不做 任何更改。 DTDGenerator 不将自身的 .__str__() 方法替换进它产生的类 — 您仍然可以打印简单的 XML 片段 — 但元类可以方便地修改这种富有“魔力”的方法。

元带来的便利

为了使用元类以及一些可以在面向方面的编程中所使用的样本元类,包 gnosis.magic 包含几个实用程序。其中最 重要的实用程序是 import_with_metaclass() 。 在上例中所用到的这个函数使您能导入第三方的模块,但您要用定制元类而不是用 type 来创建所有模块类。无论您想对第三方模块赋予什么样的新能力,您都可以在创建的元类内定义该能力(或者从其它地方一起获得)。 gnosis.magic 包含一些可插入的序列化元类;其它一些包可能包含跟踪能力、对象持久性、异常日志记录或其它能力。

import_with_metclass() 函数展示了元类编程的几个性质:
清单 13. [gnosis.magic] 的 import_with_metaclass()

def import_with_metaclass(modname, metaklass):
  "Module importer substituting custom metaclass"
  class Meta(object): __metaclass__ = metaklass
  dct = {'__module__':modname}
  mod = __import__(modname)
  for key, val in mod.__dict__.items():
    if inspect.isclass(val):
      setattr(mod, key, type(key,(val,Meta),dct))
  return mod

在这个函数中值得注意的样式是,用指定的元类生成普通的类 Meta 。但是,一旦将 Meta 作为祖先添加之后,也用定制元类来生成它的后代。原则上,象 Meta 这样的类 既可以带有元类生成器(metaclass producer) 也可以带有一组可继承的方法 — Meta 类的这两个方面是无关的。

Python 相关文章推荐
python数据结构树和二叉树简介
Apr 29 Python
简单解析Django框架中的表单验证
Jul 17 Python
Python设计模式编程中Adapter适配器模式的使用实例
Mar 02 Python
详解python 发送邮件实例代码
Dec 22 Python
Python面向对象之接口、抽象类与多态详解
Aug 27 Python
对python产生随机的二维数组实例详解
Dec 13 Python
详解Python3除法之真除法、截断除法和下取整对比
May 23 Python
Python 实用技巧之利用Shell通配符做字符串匹配
Aug 23 Python
Python基本语法之运算符功能与用法详解
Oct 22 Python
通过python 执行 nohup 不生效的解决
Apr 16 Python
python图片验证码识别最新模块muggle_ocr的示例代码
Jul 03 Python
python生成xml时规定dtd实例方法
Sep 21 Python
在Python中进行自动化单元测试的教程
Apr 15 #Python
pygame学习笔记(6):完成一个简单的游戏
Apr 15 #Python
pygame学习笔记(5):游戏精灵
Apr 15 #Python
pygame学习笔记(4):声音控制
Apr 15 #Python
Python的Django框架使用入门指引
Apr 15 #Python
python中xrange用法分析
Apr 15 #Python
pygame学习笔记(3):运动速率、时间、事件、文字
Apr 15 #Python
You might like
关于在php.ini中添加extension=php_mysqli.dll指令的说明
2007/06/14 PHP
javascript下过滤数组重复值的代码
2007/09/10 Javascript
jQuery 的全选(全非选)即取得被选中的值使用介绍
2013/11/12 Javascript
javascript获取URL参数与参数值的示例代码
2013/12/20 Javascript
在JavaScript中使用timer示例
2014/05/08 Javascript
js使用DOM设置单选按钮、复选框及下拉菜单的方法
2015/01/20 Javascript
js实现大转盘抽奖游戏实例
2015/06/24 Javascript
Jquery简单分页实现方法
2015/07/24 Javascript
jQuery代码实现发展历程时间轴特效
2015/07/30 Javascript
jquery实现最简单的滑动菜单效果代码
2015/09/12 Javascript
jQuery循环遍历子节点并获取值的方法
2016/04/14 Javascript
基于Node.js的JavaScript项目构建工具gulp的使用教程
2016/05/20 Javascript
基于JavaScript Array数组方法(新手必看篇)
2016/08/20 Javascript
JavaScript构建自己的对象示例
2016/11/29 Javascript
Javascript中call,apply,bind方法的详解与总结
2016/12/12 Javascript
微信小程序 商城开发(ecshop )简单实例
2017/04/07 Javascript
微信小程序使用navigateTo数据传递的实例
2017/09/26 Javascript
JavaScript html5 canvas实现图片上画超链接
2017/10/20 Javascript
vue better-scroll插件使用详解
2018/01/25 Javascript
Vue.js 十五分钟入门图文教程
2018/09/12 Javascript
微信小程序数据统计和错误统计的实现方法
2019/06/26 Javascript
[00:27]DOTA2次级职业联赛 - Lilith战队宣传片
2014/12/01 DOTA
[05:03]2018DOTA2亚洲邀请赛主赛事首日回顾
2018/04/04 DOTA
python实现上传样本到virustotal并查询扫描信息的方法
2014/10/05 Python
Python利用Nagios增加微信报警通知的功能
2016/02/18 Python
Python正则替换字符串函数re.sub用法示例
2017/01/19 Python
Python socket模块ftp传输文件过程解析
2019/11/05 Python
Django连接数据库并实现读写分离过程解析
2019/11/13 Python
HTML5 虚拟键盘出现挡住输入框的解决办法
2017/02/14 HTML / CSS
国际领先的在线时尚服装和配饰店:DressLily
2019/03/03 全球购物
营业经理岗位职责
2013/11/10 职场文书
创意活动策划书
2014/01/15 职场文书
初婚未育证明
2014/01/15 职场文书
师德先进个人事迹材料
2014/12/19 职场文书
浅谈redis缓存在项目中的使用
2021/05/20 Redis
maven依赖的version声明控制方式
2022/01/18 Java/Android