[转]深刻理解Python中的元类(metaclass)以及元类实现单例模式
使用元类
深刻理解Python中的元类(metaclass)以及元类实现单例模式
在看一些框架源代码的过程中碰到很多元类的实例,看起来很吃力很晦涩;在看python cookbook中关于元类创建单例模式的那一节有些疑惑。因此花了几天时间研究下元类这个概念。通过学习元类,我对python的面向对象有了更加深入的了解。这里将一篇写的非常好的文章基本照搬过来吧,这是一篇在Stack overflow上很热的帖子,我看http://blog.jobbole.com/21351/这篇博客对其进行了翻译。
一、理解类也是对象
在理解元类之前,你需要先掌握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 # 你可以打印一个类,因为它其实也是一个对象 #输出:<class '__main__.ObjectCreator'> Idef 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() #输出:<__main__.ObjectCreator object at 0x108551310>
二、动态地创建类
1、通过return class动态的构建需要的类
因为类也是对象,你可以在运行时动态的创建它们,就像其他任何对象一样。首先,你可以在函数中创建类,使用class关键字即可。
def choose_class(name): if name == 'foo': class Foo(object): pass return Foo # 返回的是类,不是类的实例 else: class Bar(object): pass return Bar MyClass = choose_class('foo') print MyClass # 函数返回的是类,不是类的实例 #输出:<class '__main__.Foo'> print MyClass() # 你可以通过这个类创建类实例,也就是对象 #输出:<__main__.Foo object at 0x1085ed950
2、通过type函数构造类
但这还不够动态,因为你仍然需要自己编写整个类的代码。由于类也是对象,所以它们必须是通过什么东西来生成的才对。当你使用class关键字时,Python解释器自动创建这个对象。但就和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(类名, 父类的元组(针对继承的情况,可以为空),包含属性的字典(名称和值))
比如下面的代码:
class MyShinyClass(object): pass
可以手动通过type创建,其实
MyShinyClass = type('MyShinyClass', (), {}) # 返回一个类对象 print MyShinyClass #输出:<class '__main__.MyShinyClass'> print MyShinyClass() # 创建一个该类的实例 #输出:<__main__.MyShinyClass object at 0x1085cd810>
你会发现我们使用“MyShinyClass”作为类名,并且也可以把它当做一个变量来作为类的引用。
接下来我们通过一个具体的例子看看type是如何创建类的,范例:
1、构建Foo类 #构建目标代码 class Foo(object): bar = True #使用type构建 Foo = type('Foo', (), {'bar':True}) 2.继承Foo类 #构建目标代码: class FooChild(Foo): pass #使用type构建 FooChild = type('FooChild', (Foo,),{}) print FooChild #输出:<class '__main__.FooChild'> print FooChild.bar # bar属性是由Foo继承而来 #输出:True 3.为Foochild类增加方法 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
可以看到,在Python中,类也是对象,你可以动态的创建类。这就是当我们使用关键字class时Python在幕后做的事情,而这就是通过元类来实现的。
三、元类
1、什么是元类
通过上文的描述,我们知道了Python中的类也是对象。元类就是用来创建这些类(对象)的,元类就是类的类,你可以这样理解为:
MyClass = MetaClass() #元类创建 MyObject = MyClass() #类创建实例 实际上MyClass就是通过type()来创创建出MyClass类,它是type()类的一个实例;同时MyClass本身也是类,也可以创建出自己的实例,这里就是MyObject
函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢?好吧,我猜这是为了和str保持一致性,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'> 对于任何一个__class__的__class__属性又是什么呢? a.__class__.__class__ #输出:<type 'type'> age.__class__.__class__ #输出:<type 'type'> foo.__class__.__class__ #输出:<type 'type'> b.__class__.__class__ #输出:<type 'type'>
因此,元类就是创建类这种对象的东西, type就是Python的内建元类,当然了,你也可以创建自己的元类。
2、__metaclass__属性
你可以在写一个类的时候为其添加__metaclass__属性,定义了__metaclass__就定义了这个类的元类。
class Foo(object): #py2 __metaclass__ = something… class Foo(metaclass=something): #py3 __metaclass__ = something…
例如:当我们写如下代码时 :
class Foo(Bar): pass
在该类并定义的时候,它还没有在内存中生成,知道它被调用。Python做了如下的操作:
1)Foo中有__metaclass__这个属性吗?如果是,Python会在内存中通过__metaclass__创建一个名字为Foo的类对象(我说的是类对象,请紧跟我的思路)。
2)如果Python没有找到__metaclass__,它会继续在父类中寻找__metaclass__属性,并尝试做和前面同样的操作。
3)如果Python在任何父类中都找不到__metaclass__,它就会在模块层次中去寻找__metaclass__,并尝试做同样的操作。
4)如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。
现在的问题就是,你可以在__metaclass__中放置些什么代码呢?
答案就是:可以创建一个类的东西。那么什么可以用来创建一个类呢?type,或者任何使用到type或者子类化type的东西都可以。
三、自定义元类
元类的主要目的就是为了当创建类时能够自动地改变类。通常,你会为API做这样的事情,你希望可以创建符合当前上下文的类。假想一个很傻的例子,你决定在你的模块里所有的类的属性都应该是大写形式。有好几种方法可以办到,但其中一种就是通过设定__metaclass__。采用这种方法,这个模块中的所有类都会通过这个元类来创建,我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。
__metaclass__实际上可以被任意调用,它并不需要是一个正式的类。所以,我们这里就先以一个简单的函数作为例子开始。
1、使用函数当做元类
# 元类会自动将你通常传给‘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)#返回一个类 class Foo(object): __metaclass__ = upper_attr bar = 'bip'
print hasattr(Foo, 'bar') # 输出: False print hasattr(Foo, 'BAR') # 输出:True f = Foo() print f.BAR # 输出:'bip'
2、使用class来当做元类
由于__metaclass__必须返回一个类。
# 请记住,'type'实际上是一个类,就像'str'和'int'一样。所以,你可以从type继承 # __new__ 是在__init__之前被调用的特殊方法,__new__是用来创建对象并返回之的方法,__new_()是一个类方法 # 而__init__只是用来将传入的参数初始化给对象,它是在对象创建之后执行的方法。 # 你很少用到__new__,除非你希望能够控制对象的创建。这里,创建的对象是类,我们希望能够自定义它,所以我们这里改写__new__ # 如果你希望的话,你也可以在__init__中做些事情。还有一些高级的用法会涉及到改写__call__特殊方法,但是我们这里不用,下面我们可以单独的讨论这个使用 class UpperAttrMetaClass(type): def __new__(upperattr_metaclass, 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) return type(future_class_name, future_class_parents, uppercase_attr)#返回一个对象,但同时这个对象是一个类
但是,这种方式其实不是OOP。我们直接调用了type,而且我们没有改写父类的__new__方法。现在让我们这样去处理:
class UpperAttrMetaclass(type): def __new__(upperattr_metaclass, 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.__new__方法 # 这就是基本的OOP编程,没什么魔法。由于type是元类也就是类,因此它本身也是通过__new__方法生成其实例,只不过这个实例是一个类. return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)
你可能已经注意到了有个额外的参数upperattr_metaclass,这并没有什么特别的。类方法的第一个参数总是表示当前的实例,就像在普通的类方法中的self参数一样。当然了,为了清晰起见,这里的名字我起的比较长。但是就像self一样,所有的参数都有它们的传统名称。因此,在真实的产品代码中一个元类应该是像这样的:
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 type.__new__(cls, name, bases, uppercase_attr)
如果使用super方法的话,我们还可以使它变得更清晰一些。
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)
class Trick(object): __metaclass__ = UpperAttrMetaClass bar = 12 money = 'unlimited' print Trick.BAR print Trick.MONEY
四、使用原来创建ORM的实例
我们通过创建一个类似Django中的ORM来熟悉一下元类的使用,通常元类用来创建API是非常好的选择,使用元类的编写很复杂但使用者可以非常简洁的调用API。
#我们想创建一个类似Django的ORM,只要定义字段就可以实现对数据库表和字段的操作。 class User(Model): # 定义类的属性到列的映射: id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password')
例如:
# 创建一个实例: u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库: u.save()
接下来我么来实现这么个功能:
class Person(object): def __new__(cls, *args,**kwargs): print '__new__() - {cls}'.format(cls=cls) return object.__new__(cls, *args, **kwargs) def __init__(self): print("__init__ called") def __call__(self): print('__call__ called') p1 = Person() p2 = Person() print p1 print p2 print(p1()) print('Foo~~~~~~~~~~~~ ') class Singleton(type): def __new__(cls, name,bases,attrs): print 'Singleton __new__() - {cls}'.format(cls=cls) #if not hasattr(cls,"_instance"): # cls._instance = super(Singleton, cls).__new__(cls, name, bases,attrs) #return cls._instance attrs["_instance"] = None return super(Singleton,cls).__new__(cls,name,bases,attrs) def __call__(self, *args, **kwargs): print "Singleton __call__",self if self._instance is None: self._instance = super(Singleton,self).__call__(*args, **kwargs) return self._instance class Foo(object): __metaclass__ = Singleton def __init__(self,name): print('Foo __init__ called') self.name = name def __str__(self): return self.name foo = Foo('Foolish') foo2 = Foo('Foolish2') print(foo) print(foo2) #print foo is foo2demo
假如我们通过元类的__new__方法来也可以实现,但显然没有通过__init__来实现优雅,因为我们不会为了为实例增加一个属性而重写__new__方法。所以这个形式不推荐。
class Singleton(type): def __new__(cls, name,bases,attrs): print "__new__" attrs["_instance"] = None return super(Singleton,cls).__new__(cls,name,bases,attrs) def __call__(self, *args, **kwargs): print "__call__" if self._instance is None: self._instance = super(Singleton,self).__call__(*args, **kwargs) return self._instance class Foo(object): __metaclass__ = Singleton foo1 = Foo() foo2 = Foo() print Foo.__dict__ print foo1 is foo2 # True # 输出 # __new__ # __call__ # __call__ # {'__module__': '__main__', '__metaclass__': <class '__main__.Singleton'>, '_instance': <__main__.Foo object at 0x103e07ed0>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None} # True
- 深刻理解Python中的元类(metaclass)以及元类实现单例模式
- 深刻理解Python中的元类(metaclass)以及元类实现单例模式
- 深刻理解Python中的元类(metaclass)以及元类实现单例模式
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深入学习Django源码基础1 - 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- python——深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)
- 深刻理解Python中的元类(metaclass)(转)
- [转] 深刻理解Python中的元类(metaclass)
- python笔记:深刻理解Python中的元类(metaclass)