python核心高级学习总结6------面向对象进阶之元类

2017-07-22

元类引入

在多数语言中，类就是一组用来描述如何生成对象的代码段，在python中同样如此，但是在python中把类也称为类对象，是的，你没听错，在这里你只要使用class关键字定义了类，其解释器在执行时就会创建一个对象，但是这个对象比较特殊，它可以创建自己的实例对象（像其他语言一样）。你可以对它进行下面的操作：

你可以将它赋值给一个变量
你可以拷贝它
你可以为它增加属性
你可以将它作为函数参数进行传递

动态创建类

听起来python在这方面跟一些语言的差别了吧，没错它还可以在运行时动态地创建它们，你可以在函数中创建类，用class关键字即可。

def choose_class(name):  
  if name == 'foo':  
  class Foo(object):  
  pass  
  return Foo # 返回的是类， 不是类的实例  
  else:  
  class Bar(object):  
  pass  
  return Bar

如果你想知道python中的变量或者数值的类型，你可以用万能而强大的type,如下（注意它们的返回值）

>>> print type(1) #数值的类型  
<type 'int'>  
>>> print type("1") #字符串的类型  
<type 'str'>  
>>> print type(ObjectCreator()) #实例对象的类型  
<class '__main__.ObjectCreator'>  
>>> print type(ObjectCreator) #类的类型  
<type 'type'>

使用type创建类

创建格式：type(类名, 由类名称组成的元组（针对继承的情况，可以为空），包含属性的字典（名称和值） )

可以像这样创建：

Test2 = type("Test2",(),{}) #定了⼀个Test2类  
In [5]: Test2() #创建了⼀个Test2类的实例对象  
Out[5]: <__main__.Test2 at 0x10d406b38>

上面等价于

class Test2:  
    pass

使用type创建带有属性的类

Foo = type('Foo', (), {'bar':True})

可以翻译为

>>> class Foo(object):  
… bar = True

这个类跟普通创建的类一样使用，如继承这个类，你可以用下面的方法

>>> FooChild = type('FooChild', (Foo,),{})  
>>> print FooChild  
<class '__main__.FooChild'>  
>>> print FooChild.bar # bar属性是由Foo继承⽽来  
True

同样等价于

>>> class FooChild(Foo):  
… pass

注意：添加的属性都是类属性，第二个参数是继承自哪儿，采用元组的形式，也要知道在python中元组中只有一个参数表示方法只能是（xx,），而不能是（xx）

使用type创建带有方法的类

如果你想为你的类增加方法，那么你创建一个签名函数，然后添加其为属性赋值即可。

添加实例方法

In [46]: def echo_bar(self): #定义了⼀个普通的函数  
...: print(self.bar)  
...:  
In [47]: FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})  
In [48]: hasattr(Foo, 'echo_bar') #判断Foo类中， 是否有echo_bar这个属性  
Out[48]: False  
In [49]:  
In [49]: hasattr(FooChild, 'echo_bar') #判断FooChild类中， 是否有echo_bar这个  
Out[49]: True  
In [50]: my_foo = FooChild()  
In [51]: my_foo.echo_bar()  
True

添加类方法

In [42]: @classmethod  
...: def testClass(cls):  
...: print(cls.bar)  
...:  
In [43]:  
In [43]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,"testClass":testClass})  
In [44]:  
In [44]: fooclid = Foochild()  
In [45]: fooclid.testClass()  
True

添加静态方法

In [36]: @staticmethod  
...: def testStatic():  
...: print("static method ....")  
...:  
In [37]: Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar,“testStatic”:testStatic})  
In [38]: fooclid = Foochild()  
In [39]: fooclid.testStatic  
Out[39]: <function __main__.testStatic>  
In [40]: fooclid.testStatic()  
static method ....  
In [41]: fooclid.echo_bar()  
True

看到这么多实现动态类的方法，你该明白python是怎么做到的，在这里就涉及到元类，元类就是用来创建类的东西，而创建类就是为了创建类的实例对象，所以可以这样理解，元类就是为了创建类对象的，而type实际上就是一个元类，传统类的元类就是types.classType,在 python中元类的介绍中也介绍了元类，有兴趣的读者可以去看看。SO,结论就是Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，并且它们都是从一个类创建而来，这个类就是type。

metaclass属性

你也可以定义自己的元类，用到的就是上面的属性，首先，你可以在定义⼀个类的时候为其添加metaclass属性。

class Foo(object):  
    __metaclass__ = something…  
    #...省略...

那么当python解释器看到下面代码时

class Foo(Bar):  
    pass

做了如下的操作：

Foo中有metaclass这个属性吗？如果是， Python会通过metaclass创建⼀个名字为Foo的类(对象)
如果Python没有找到metaclass，它会继续在Bar（⽗类）中寻找metaclass属性，并尝试做和前⾯同样的操作。
如果Python在任何⽗类中都找不到metaclass，它就会在模块层次中去寻找metaclass，并尝试做同样的操作。
如果还是找不到metaclass,Python就会⽤内置的type来创建这个类对象。
在这个metaclass中可以放一些什么代码呢？——可以做任何涉及到类操作的事情，用type或者其子类来完成。
下面是用自定义类来当做元类

#coding=utf-8  
class UpperAttrMetaClass(type):  
    # __new__ 是在__init__之前被调用的特殊方法  
    # __new__是用来创建对象并返回之的方法  
    # __init__只是用来将传递的参数初始化给对象  
    # 你很少用到__new__， 除非你希望能够控制对象的创建  
    # 这时， 创建的对象是类，我们希望能够自定义它， 所以我们这次改写__new__  
    # 如果你希望的话， 你也可以在__init__中做些事情  
    # 还有一些高级的用法会涉及到改写__call__特殊方法  
    def __new__(cls, future_class_name, future_class_parents, future_clas  
        #遍历属性字典， 把不是__开头的属性名字变为大写  
        newAttr = {}  
        for name,value in future_class_attr.items():  
            if not name.startswith("__"):  
                newAttr[name.upper()] = value  
        # 方法1： 通过'type'来做类对象的创建  
        # return type(future_class_name, future_class_  
        parents, newAttr)  
        # 方法2： 复用type.__new__方法  
        # 这就是基本的OOP编程， 没什么魔法  
        # return type.__new__(cls, future_class_name,         future_class_parent  
        #方法3： 使用super方法  
        return super(UpperAttrMetaClass, cls).__new__(cls, future_class_n  
#python2的用法  
class Foo(object):  
    __metaclass__ = UpperAttrMetaClass  
    bar = 'bip'  
# python3的用法  
# class Foo(object, metaclass = UpperAttrMetaClass):  
    # bar = 'bip'  
print(hasattr(Foo, 'bar'))  
# 输出: False  
print(hasattr(Foo, 'BAR'))  
# 输出:True

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

其实简单地来讲，python中的元类用处一般就是下面三个

拦截类的创建
修改类
返回修改之后的类

哈哈，我想说的是对于元类咱们99%的人不会用到。