python面向对象进阶之元类metaclass

柔情痞子 提交于 2020-03-09 12:17:15

一:知识储备

exec

exec:三个参数
 
参数一:字符串形式的命令
 
参数二:全局作用域(字典形式),如果不指定,默认为globals()
 
参数三:局部作用域(字典形式),如果不指定,默认为locals()

exec的应用:

#可以把exec命令的执行当成是一个函数的执行,会将执行期间产生的名字存放于局部名称空间中
g={
    'x':1,
    'y':2
}
l={}
 
exec('''
global x,z
x=100
z=200
 
m=300
''',g,l)
 
print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}

__call__方法:对象后面加括号,触发执行。

注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

class Foo:
  
    def __init__(self):
        pass
  
    def __call__(self, *args, **kwargs):
  
        print('__call__')
  
  
obj = Foo() # 执行 __init__
obj()       # 执行 __call__

__call__的应用:

# 知识储备__call__方法
class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)
 
obj = Foo()
obj(1,2,3,a=1,b=2,c=3)
# 结果:
# <__main__.Foo object at 0x000002AFE077B160>
# (1, 2, 3)
# {'a': 1, 'b': 2, 'c': 3}

__new__方法:

知识储备:
  产生的新对象 = object.__new__(继承object类的子类)
obj.__new__(cls)

 

二:引子(类也是对象)

  在理解元类之前,我们需要掌握Python中的类(class)。对于类是什么,Python有独特的看法,这借鉴于Smalktalk。

  在大部分语言中,类仅仅是描述如何去产生一个对象的代码片段,在Python中也一样。

>>> class ObjectCreator(object):
...   pass
...
 
>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

  但是类在Python不仅仅是这样,类也是对象。

  当你使用关键字class时,Python执行它并创建了一个对象,如下:

class Foo:
  pass
 
f1=Foo() #f1是通过Foo类实例化的对象

  python中一切皆是对象,类本身也是一个对象,当使用关键字class的时候,python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例),因而我们可以将类当作一个对象去使用,同样满足第一类对象的概念,可以:

  • 把类赋值给一个变量

  • 您能复制类

  • 把类作为函数参数进行传递

  • 把类作为函数的返回值

  • 在运行时动态地创建类 

上例可以看出f1是由Foo这个类产生的对象,而Foo本身也是对象,那它又是由哪个类产生的呢?

#type函数可以查看类型,也可以用来查看对象的类,二者是一样的
print(type(f1)) # 输出:<class '__main__.Foo'> 表示,obj 对象由Foo类创建
print(type(Foo)) # 输出:<type 'type'>

  例如:

>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
...       print(o)
...
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

2.1 动态的创建类

  因为类是对象,你能动态的创建他们,就像其他对象一样。

  首先,你可以在函数中使用class创建一个类,如下:

>>> def choose_class(name):
...     if name == 'foo':
...         class Foo(object):
...             pass
...         return Foo # return the class, not an instance
...     else:
...         class Bar(object):
...             pass
...         return Bar
...
>>> MyClass = choose_class('foo')
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

  但是这不够动态,因为你仍然需要去完整的定义这个类。

  因为类是对象,他们肯定能用其他方式生成。

  当你使用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能够接受一个类的描述作为参数,然后返回一个类。

  type还可以这样用

type(name of the class,
  tuple of the parent class (for inheritance, can be empty),
  dictionary containing attributes names and values)

  例如:

>>> class MyShinyClass(object):
...   pass

  能用这种方式手动创建,

>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

  你将注意到,我们使用”MyShinyClass“作为这个类的名称,同样作为变量的名称,并将类引用赋值给它。它们可能有点区别,但是没必要把事情搞复杂。

  type接受一个字典去定义类的属性,因此:

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

  能这样表达:

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

  而且被用来作为一个普通的类。

>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

  当然,你也能继承他,因此:

>>>   class FooChild(Foo):
...     pass

  等价于

>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

  最终,你需要添加给这个类添加一些方法。仅需要定义好函数,并将它赋值给一个属性即可。

>>> 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

  而且,甚至在类动态创建之后,你也能添加更多的方法,就像给一个普通创建的类对象添加方法一样。

>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
True

  如你所见:在Python中,类也是对象,而且你能动态地创建一个类。

  这就是当你使用class这个关键字时Python所做的,Python使用元类来完成这项工作。

 

三:什么是元类?

  元类是类的类,是类的模板,也是我们创建对象的东西。

  元类是用来控制如何创建类的,正如类是创建对象的模板一样,而元类的主要目的是为了控制类的创建行为

  元类的实例化的结果为我们用class定义的类,正如类的实例为对象(f1对象是Foo类的一个实例,Foo类是 type 类的一个实例)

  type是python的一个内建元类,用来直接控制生成类,python中任何class定义的类其实都是type类实例化的对象

 

class Mymeta(type):
 
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名的首字母必须大写')
        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
            raise TypeError('必须有注释,且注释不能为空')
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)
 
class Chinese(object,metaclass=Mymeta):
    '''
    有注释
    '''
    country = 'china'
 
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def talk(self):
        print('%s is talking'%self.name)
 
#实例化
# chinese = mymeta(class_name,class_bases,class_dic)

  元类是创建这些对象的东西,他们是类的类,我们可以用下面这种方式描述

MyClass = MetaClass()
my_object = MyClass()

  我们已经看到type能让我们这样做

MyClass = type('MyClass', (), {})

  这是因为type这个函数事实上是一个元类。type是Python在背后用来创建所有类的元类。

  现在你可能想知道,为什么type首字母要小写,而不是写成Type

  我猜,这与语言一致性有关,例如str是创建字符串对象的类,int是创建整数对象d的类,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__是什么呢?

>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

  因此,元类就是创建类对象的东东。

  如果你愿意,可以称它为"类工厂"。

  type是Python使用的内置的元类,当然,你也能创建自己的元类。

 

四:创建类的两种方式

方式一:使用class关键字

class Chinese(object):
    country='China'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def talk(self):
        print('%s is talking' %self.name)

方式二:手动模拟class创建类的过程:将创建类的步骤拆开,手动去创建

#准备工作:
 
#创建类主要分为三部分
  类名
  类的父类
  类体
 
 
#类名
class_name='Chinese'
#类的父类
class_bases=(object,)
#类体
class_body="""
country='China'
def __init__(self,name,age):
    self.name=name
    self.age=age
def talk(self):
    print('%s is talking' %self.name)
"""

  步骤一(先处理类体->名称空间):类体定义的名字都会存放于类的名称空间中(一个局部的名称空间),我们可以事先定义一个空字典,然后用exec去执行类体的代码(exec产生名称空间的过程与真正的class过程类似,只是后者会将__开头的属性变形),生成类的局部名称空间,即填充字典

class_dic={}
exec(class_body,globals(),class_dic)
 
 
print(class_dic)
#{'country': 'China', 'talk': <function talk at 0x101a560c8>, '__init__': <function __init__ at 0x101a56668>}

  步骤二:调用元类type(也可以自定义)来产生类Chinense

Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo,即我们用class定义的类Foo
 
 
print(Foo)
print(type(Foo))
print(isinstance(Foo,type))
'''
<class '__main__.Chinese'>
<class 'type'>
True

我们看到,type 接收三个参数:

  • 第 1 个参数是字符串 ‘Foo’,表示类名

  • 第 2 个参数是元组 (object, ),表示所有的父类

  • 第 3 个参数是字典,这里是一个空字典,表示没有定义属性和方法

补充:若Foo类有继承,即class Foo(Bar):.... 则等同于type('Foo',(Bar,),{})

4.1  __metaclass__ 属性

  当你定义一个类时,可以添加一个__metaclass__属性。

class Foo(object):
  __metaclass__ = something...
  [...]

  如果你这样做的话,Python将使用这个元类去创建类Foo

  小心,这有陷阱。

  你首先写了class Foo(object),但是这个类对象Foo在内存中并没有被创建。

  Python将在类定义中寻找__metaclass__如果Python发现了它,Python将使用它去创建类对象Foo,如果没有,Python将使用type去创建这个类。

重温几次。

当你定义:

class Foo(Bar):
  pass

  Python将做以下事情: 在Foo中有__metaclass__属性吗?

  如果有,就使用__mataclass__中定义的东东在内存中创建类对象,类名为Foo

  如果Python没有找到__metaclass__属性,它将在MODULE层寻找一个__metaclass__,去做相同的事情(对于类,不继承任何东西,基础的老式类)。

  然后如果Python不能找到任何的__metaclass__,它将使用Bar(第一个父类)自己的元类(可能是type)去创建类对象。

  这里小心__metaclass__属性将不会被继承,父类的元类(Bar.__class__)会被继承。如果Bar使用了一个用type(不是type.__new__())创建Bar__metaclass__属性,那么它的子类将会继承这个行为。

  现在最大的问题是,你能在__metaclass__中定义什么?

  答案就是,能够创建类的东东。

  什么能创建类呢?type,或者它的子类,或者用了它的任何东西。

 

五:自定义元类控制类的行为

5.1 自定义元类

  元类的主要目的是为了创建时自动地改变类。

  经常为了API这么做,API中需要创建类去匹配当前的上下文。

  想象一个非常蠢的例子,你决定你的模块中的所有类它们的属性应该大写。有好几种方式可以完成这件事,其中一种方式就是在模块层设置__metaclass__

  使用这种方式,模块内所有的类都会使用这个元类创建,而且我们必须告诉元类要将所有的属性转为大写。

  幸运的是,__metaclass__确实是可调用的,它不需要是一个正式的类(在名字中带有类,但是不必要是一个类,区分一下,但是这很有用)。

  接下来我们使用函数写个简单的例子。

# coding=utf-8
# 适用于python2
# 元类将自动获取到相同的你经常传给`type`的参数。
# 即参数列表与`type`的一致。
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    """
      将属性名转为大写后,返回一个类对象。
    """
 
    # 筛选出所有不以__开头的属性,转为大写。
    uppercase_attr = {}
    for name, val in future_class_attr.items():
        if not name.startswith('__'):
            uppercase_attr[name.upper()] = val
        else:
            uppercase_attr[name] = val
 
    # 使用type创建类
    return type(future_class_name, future_class_parents, uppercase_attr)
 
__metaclass__ = upper_attr # 这将影响这个模块内的所有类。
 
class Foo(): # 虽然全局的 __metaclass__ 对 “object”无效
    # 但是我们可以在这里定义 __metaclass__ 而不是仅仅影响这个类。
    # 这将影响“object”的children
    bar = 'bip'
 
print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True
 
f = Foo()
print(f.BAR)
# Out: 'bip'

  现在,我们用一个真实的类作为元类去做相同的事情。

# coding=utf-8
# 记住`type`事实上是一个类似于`str`和`int`的类
# 所以你能继承它
class UpperAttrMetaclass(type):
    # __new__ 方法在 __init__ 前执行,这个方法创建对象并返回。
    # __init__方法仅仅初始化作为参数传入的对象。
    # 你很少使用__new__方法,除非你想控制类是如何创建的。
    # 这里创建的对象是一个类,我们想自定义它,因此需要覆盖 __new__。
    # 你也能在__init__中做一些事情,如果愿意的话。
    # 一些高级用法还包括覆盖__call__方法,这里不使用。
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):
 
        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val
 
        return type(future_class_name, future_class_parents, uppercase_attr)

  事实上这并不OOP,我们直接调用了type函数,没有覆盖或者是调用父类的__new__,改一下:

# coding=utf-8
class UpperAttrMetaclass(type):
 
    def __new__(upperattr_metaclass, future_class_name,
                future_class_parents, future_class_attr):
 
        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val
 
        # 重用了type.__new__方法,这种写法是OOP的
        return type.__new__(upperattr_metaclass, future_class_name,
                            future_class_parents, uppercase_attr)

  你可能注意到额外的参数upperattr_metaclass,这没什么特别的:__new__方法总是接受定义的类作为第一个参数,就像普通方法接受实例作为第一个参数传入self,类方法传入定义类一样。

  当然,为了可读性,我在这里使用的名字太长了。但是就如self一样,所有的参数都有约定俗成的名字,因此一个真实的正式的metaclass应该像这样写:

class UpperAttrMetaclass(type):
 
    def __new__(cls, clsname, bases, dct):
 
        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val
 
        return type.__new__(cls, clsname, bases, uppercase_attr)

  我们使用super让代码看上去更清晰一些,

class UpperAttrMetaclass(type):
 
    def __new__(cls, clsname, bases, dct):
 
        uppercase_attr = {}
        for name, val in dct.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val
 
        return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

以上就是全部了,关于元类已经没有什么内容了。

使用元类的代码复杂的原因并不在于元类本身,而是因为你经常使用元类去做一些扭曲的事情,操纵继承,遍历属性(vars)例如__dict__等等。

事实上,元类在做一些黑科技时非常有用,因此往往是一些复杂的东西。但是就元类本身而言,是简单的。

  • 拦截类的创建。
  • 修改类。
  • 返回修改后的类。

5.2 自定义元类控制类的行为

  一个类没有声明自己的元类,默认他的元类就是type,除了使用元类type,用户也可以通过继承type来自定义元类(顺便我们也可以瞅一瞅元类如何控制类的行为,工作流程是什么)

步骤一:如果说People=type(类名,类的父类们,类的名称空间),那么我们定义元类如下,来控制类的创建

class Mymeta(type):  # 继承默认元类的一堆属性
    def __init__(self, class_name, class_bases, class_dic):
        if '__doc__' not in class_dic or not class_dic.get('__doc__').strip():
            raise TypeError('必须为类指定文档注释')
 
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')
 
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)
 
 
class People(object, metaclass=Mymeta):
    country = 'China'
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
    def talk(self):
        print('%s is talking' % self.name)

步骤二:如果我们想控制类实例化的行为,那么需要先储备知识__call__方法的使用

class People(object,metaclass=type):
    def __init__(self,name,age):
        self.name=name
        self.age=age
 
    def __call__(self, *args, **kwargs):
        print(self,args,kwargs)
 
 
# 调用类People,并不会出发__call__
obj=People('egon',18)
 
# 调用对象obj(1,2,3,a=1,b=2,c=3),才会出发对象的绑定方法obj.__call__(1,2,3,a=1,b=2,c=3)
obj(1,2,3,a=1,b=2,c=3)
#打印:<__main__.People object at 0x10076dd30> (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
 
#总结:如果说类People是元类type的实例,那么在元类type内肯定也有一个__call__,
会在调用People('egon',18)时触发执行,然后返回一个初始化好了的对象obj

步骤三:自定义元类,控制类的调用(即实例化)的过程

class Mymeta(type): #继承默认元类的一堆属性
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')
 
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)
 
    def __call__(self, *args, **kwargs):
        #self=People
        print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
 
        #1、实例化People,产生空对象obj
        obj=object.__new__(self)
 
 
        #2、调用People下的函数__init__,初始化obj
        self.__init__(obj,*args,**kwargs)
 
 
        #3、返回初始化好了的obj
        return obj
 
class People(object,metaclass=Mymeta):
    country='China'
 
    def __init__(self,name,age):
        self.name=name
        self.age=age
 
    def talk(self):
        print('%s is talking' %self.name)
 
 
 
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}

步骤四:

class Mymeta(type): #继承默认元类的一堆属性
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名首字母必须大写')
 
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)
 
    def __call__(self, *args, **kwargs):
        #self=People
        print(self,args,kwargs) #<class '__main__.People'> ('egon', 18) {}
 
        #1、调用self,即People下的函数__new__,在该函数内完成:1、产生空对象obj 2、初始化 3、返回obj
        obj=self.__new__(self,*args,**kwargs)
 
        #2、一定记得返回obj,因为实例化People(...)取得就是__call__的返回值
        return obj
 
class People(object,metaclass=Mymeta):
    country='China'
 
    def __init__(self,name,age):
        self.name=name
        self.age=age
 
    def talk(self):
        print('%s is talking' %self.name)
 
 
    def __new__(cls, *args, **kwargs):
        obj=object.__new__(cls)
        cls.__init__(obj,*args,**kwargs)
        return obj
 
 
obj=People('egon',18)
print(obj.__dict__) #{'name': 'egon', 'age': 18}

步骤五:基于元类实现单例模式,比如数据库对象,实例化时参数都一样,就没必要重复产生对象,浪费内存

class Mysql:
    __instance=None
    def __init__(self,host='127.0.0.1',port='3306'):
        self.host=host
        self.port=port
 
    @classmethod
    def singleton(cls,*args,**kwargs):
        if not cls.__instance:
            cls.__instance=cls(*args,**kwargs)
        return cls.__instance
 
 
obj1=Mysql()
obj2=Mysql()
print(obj1 is obj2) #False
 
obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True

 

应用:定制元类实现单例模式

class Mymeta(type):
    def __init__(self,name,bases,dic): #定义类Mysql时就触发
        self.__instance=None
        super().__init__(name,bases,dic)
 
    def __call__(self, *args, **kwargs): #Mysql(...)时触发
 
        if not self.__instance:
            self.__instance=object.__new__(self) #产生对象
            self.__init__(self.__instance,*args,**kwargs) #初始化对象
            #上述两步可以合成下面一步
            # self.__instance=super().__call__(*args,**kwargs)
 
        return self.__instance
class Mysql(metaclass=Mymeta):
    def __init__(self,host='127.0.0.1',port='3306'):
        self.host=host
        self.port=port
 
 
obj1=Mysql()
obj2=Mysql()
 
print(obj1 is obj2)

 

#单例模式
class MySQL:
    __instance = None  #__instance = obj1
 
    def __init__(self):
        self.host = '127.0.0.1'
        self.port = 3306
    @classmethod
    def singleton(cls):
        if not cls.__instance:
            obj =cls()
            cls.__instance = obj
        return cls.__instance
 
    def conn(self):
        pass
    def execute(self):
        pass
 
#obj1和obj2的内存地址是一样的,
# obj1 = MySQL()
# obj2 = MySQL()
# print(obj1)
# print(obj2)
# obj1 = MySQL.singleton()
# obj2 = MySQL.singleton()
# print(obj1)
# print(obj2)
# 结果:
# <__main__.MySQL object at 0x000002A1EF60CA58>
# <__main__.MySQL object at 0x000002A1EF60CA58>
 
 
#实现方式二,元类的方式
class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise TypeError('类名的首字母必须大写')
        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
            raise TypeError('必须有注释,且注释不能为空')
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)
        self.__instance =None
    def __call__(self, *args, **kwargs):
        if not self.__instance:
            obj = object.__new__(self)
            self.__init__(obj)
            self.__instance = obj
        return self.__instance
 
class Mysql(object,metaclass=Mymeta):
    '''必须有注释'''
    def __init__(self):
        self.host = '127.0.0.1'
        self.port = 3306
    def conn(self):
        pass
    def execute(self):
        pass
 
obj1 =Mysql()
obj2 =Mysql()
obj3 =Mysql()
print(obj1 is obj2 is obj3)
# True

5.3 为什么使用元类时用类不要函数?

  因为__metaclass__能够接受任何可调用的东西,为什么要去使用明显更为复杂的类呢?

这么做有几个原因:

  • 目的更明确,当你阅读UpperAttrMetaclass(type),你知道接下来会发生什么。
  • 更OOP。元类能够继承元类,覆盖父类的方法。元类甚至能使用元类。
  • 一个类的子类可以是它的元类的实例如果你指定了一个元类类(metaclass-class),而不是一个元类函数(metaclass-function)。
  • 能更好地组织代码。你从来没有像上面的例子这样试验性地使用元类。元类经常用于一些复杂场景。为了代码可读性,将好几个方法组织在一个类中的能力是非常重要的。
  • 你能覆盖__new____init____call__,这些方法将允许你做不同的事情。即时即经常只需要修改__new__,一些人觉得使用__init__更舒服。
  • 它们被称为元类,实际就应该和它的名称一致。

5.4 为什么使用元类

  现在最大的问题,为什么要使用这么晦涩的容易出错的特性?

  通常不要用:

  元类是深魔法,99%的用户都不需要关心它。如果你在想是否需要它们,就不要用(需要元类的人确切地知道需要它,无需解释)。
Python Guru Tim Peters

  元类主要的使用场景是创建API,一个典型的例子是Django的ORM。

  它允许你去这样定义:

class Person(models.Model):
  name = models.CharField(max_length=30)
  age = models.IntegerField()

  但是如果你这样做:

guy = Person(name='bob', age='35')
print(guy.age)

  它将不会返回一个IntegerFiled对象,它将返回一个int,而且甚至直接传给数据库。

  这是可能的,因为models.Model定义了__metaclass__而且进行了一些特殊处理,将你刚刚简单几句话定义的Person转变为数据库字段的复杂钩子。

  Django通过使用元类暴露简单的API,让一些复杂的事情看上去简单,通过这些API背后重新创建代码去做真实的事情。

5.5 最后一点

  首先,你知道类是能够创建实例的对象。

  事实上,类本身就是对象,元类也是。

>>> class Foo(object): pass
>>> id(Foo)
142630324

  Python中一切皆对象,而且他们也是类的实例或类的实例。

  除了type

  type确实是自己的元类,这只用Python是产生不了的,这是在实现层面做的。

  第二,元类是复杂的。你可能想去使用他们去做简单的类修改。你能使用2种其他的技术去做这件事。

  类修改99%的场景适合以上方式。

  但是98%的场景,根本不需要去修改类。

5.6 Python3补充

  Python3和Python2中元类使用有区别。

  以下是使用元类实现追踪类定义顺序的例子。

class MyMeta(type):
 
    counter = 0
 
    def __init__(cls, name, bases, dic):
        type.__init__(cls, name, bases, dic)
        cls._order = MyMeta.counter
        MyMeta.counter += 1
 
class MyType(object):              # Python 2
    __metaclass__ = MyMeta
 
class MyType(metaclass=MyMeta):    # Python 3
    pass

  Python3中元类有2个关键的方法。

  • __prepare__
  • __new__

__prepare__让你提供一个自定义的字典(例如OrderedDict)作为元类创建时的命名空间。无论选择什么命名空间,都必须返回一个实例。如果没有实现__prepare__,将会使用一个普通的dict

class Meta(type):
 
    def __prepare__(metaclass, cls, bases):
        return dict()
 
    def __new__(metacls, cls, bases, clsdict):
        return super().__new__(metacls, cls, bases, clsdict)

 

六:练习题

练习题一:在元类中控制把自定义类的数据属性都变成大写

class Mymetaclass(type):
    def __new__(cls,name,bases,attrs):
        update_attrs={}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith('__'):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k]=v
        return type.__new__(cls,name,bases,update_attrs)
 
class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龙的传人
    def walk(self):
        print('%s is walking' %self.name)
 
 
print(Chinese.__dict__)
'''
{'__module__': '__main__',
 'COUNTRY': 'China',
 'TAG': 'Legend of the Dragon',
 'walk': <function Chinese.walk at 0x0000000001E7B950>,
 '__dict__': <attribute '__dict__' of 'Chinese' objects>,                                        
 '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
 '__doc__': None}
'''

 

练习题二:在元类中控制自定义的类无需__init__方法

  1.元类帮其完成创建对象,以及初始化操作;

  2.要求实例化时传参必须为关键字形式,否则抛出异常TypeError: must use keyword argument

  3.key作为用户自定义类产生对象的属性,且所有属性变成大写

class Mymetaclass(type):
    # def __new__(cls,name,bases,attrs):
    #     update_attrs={}
    #     for k,v in attrs.items():
    #         if not callable(v) and not k.startswith('__'):
    #             update_attrs[k.upper()]=v
    #         else:
    #             update_attrs[k]=v
    #     return type.__new__(cls,name,bases,update_attrs)
 
    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError('must use keyword argument for key function')
        obj = object.__new__(self) #创建对象,self为类Foo
 
        for k,v in kwargs.items():
            obj.__dict__[k.upper()]=v
        return obj
 
class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龙的传人
    def walk(self):
        print('%s is walking' %self.name)
 
 
p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)

  在大多数编程语言中,类就是用来描述如何生成一个对象的代码块,在python中类也是一个对象,这个(类)对象自身拥有创建对象(类实例)的能力。

因为他的本质是一个对象:

  • 可以将它赋值给一个变量
  • 可以拷贝他
  • 可以增加属性
  • 可以作为参数进行传递
  • 可以在运行时动态的创建他们
  • 可以在函数中创建类,只需要使用class关键字即可

  当使用class关键字的时候,Python解释器会自动的创建这个对象,Python还提供了手动处理的方法:type()。

  type是一个生成类对象的类工厂,实际上也是一个类,专门构建对象的类称为元类:

__metaclass__属性

  可以为类添加一个__metaclass__属性,通过在基类的列表中指定metaclass关键字,例如:

class Foo(object):
    __metaclass__=something

  当解释器解析后class  Foo(object),类对象Foo并没有创建,Python会在类定义中寻找__metaclass__属性,用它创建,如果找到了,Python就会用它来创建Foo,没有就会使用type来创建。

class  Foo(Bar):
    pass

  如果Foo没有__metaclass__属性,会继续父类Bar中递归地继续寻找__metaclass__属性,尝试之前操作。

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!