python元类编程

元类编程

当我们希望动态的产生类的时候，就需要用到元类编程的手段。要掌握此技术，需要明白以下几个基本内容：

1. metaclass
2. type
3. __new__
4. __call__

python的类的产生

在python 中，所有东西都是对象(object)，包括python的类(class)，也是一个对象。查看一个对象的类，可以用对象的__class__属性

class Foo(object):
  def hello(self):
     print('hello')
f=Foo()
print(f.__class__) #＝> __main__.Foo
print(Foo.__class__) #==> type

从上面运行结果可以看到，Foo的类是type。所以‘类’的初始化是由 “type类”来做。

type

type是一个python内置类，所以看不到代码，但可看到定义：

class type(object):
    
    def __call__(self, *args, **kwargs): # real signature unknown
        pass

    def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        pass

 	#省略其它部分

type 有两种用法,一是查询某个对象的类：

#type(object) -> the object's type,e.g.
type("string") # ==>Out[2]: str

另一个则是用来产生一个类，传入三个参数: 类名，基类，属性与方法字典：

# type(class_name, bases, attrs) ,e.g.
def fn(self):
  print("hello")
Foo=type("Foo",(object,),{'hello':fn})
f=Foo()
f.hello() #=> hello

python 解释器运行时，发现上述class Foo的定义后，其实就是翻译成：

Foo=type("Foo",(object,),{'hello':fn})

metaclass 元类

元类就是用来产生类的类，通过以上讲解，应该明白type类就是一个元类。
我们还可以继承type类，用自定义的元类可做到：

1. 影响类的定义过程，比如为类自动增加一些方法和属性
2. 影响定义出来的类的实例化过程，比如为该类的每个实例都做些特殊处理
   例子:

class MetaBase(type):
   def __new__(mcs, name, bases=None, attrs=None):
       print('1.创建类时，先调用__new__，分配定义类所需的内存')
       return super().__new__(mcs, name, bases, attrs)

   def __init__(cls, what, bases=None, attrs=None):
       print('2:然后，调用__init__，完成定义')
       return super().__init__(what, bases, attrs)

   def __call__(cls, *args, **kwargs):
       print('实例化定义后的类时，会调用__call__')
       return super().__call__(*args, **kwargs)


def fn(self, name='world'):
   print('hello {}' % name)


def init_fn(self):
   print('init_fn')


AClass = MetaBase("AClass", (object,), dict(hello=fn, __init__=init_fn))
a = AClass()

运行结果：

1.创建类时，先调用__new__，分配定义类所需的内存
2:然后，调用__init__，完成定义
实例化定义后的类时，会调用__call__
init_fn

为讲清楚上面的例子的运行结果，需要讲一下两个魔法函数：__new__ 与 __call__

__new__

python 对象在实例化的第一步，是分配内存，分配内存就是__new__的责任。为type子类的实例分配内存的事，只能由 type.__new__来干，所以上述例子中最后调用的是type.__new__ ，该函数返回的是一个分配好内存的实例，该函数的四个参数分别是：类，名称，基类，属性

  def __new__(mcs, name, bases=None, attrs=None):

__call__

在一个类上定义了__call__方法后，该类的实例就可当作函数来调用

class CallableObject():
  def __call__(self):
    print("hello, I'm like a function!")
fn = CallableObject()
fn()

运行结果

hello, I'm like a function!

在之前的类子中，因为AClass 的类是MetaBase, 而BetaBase定义了__call__，所以当创建AClass实例时，打印出了

实例化定义后的类时，会调用__call__

metaclass 语法糖

在python 3.7 中，可以在申明类的时候，指定 metaClass

class Foo(object,metaclass=MetaBase):
  def hello(self):
     print('hello')

在python2 中，是写成：

class Foo(object):
  __metaclass__= MetaBase  
  def hello(self):
     print('hello')