元类（metaclass）

时间  2019-11-16
标签 metaclass 繁體版
原文   原文链接

1、储备知识exec

　　储备知识exec：有下面三个参数python

　　参数一：字符串形式的命令
　　参数二：全局做用域（字典形式），若是不指定默认使用globals()
　　参数三：局部做用域(字典形式)，若是不指定默认就使用locals()mysql

# 格式：exec(object, globals, locals)
# 能够把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}
exec(object, globals, locals)

2、类也是对象，一切皆对象

class Foo:
      pass

f1=Foo() #f1是经过Foo类实例化的对象

　　python一切皆对象，类自己也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会建立一个对象(这里的对象指的是类而非类的实例)，于是咱们能够将类看成一个对象去使用，一样知足第一类对象的概念，对象能够怎么用？
　　一、均可以被引用，x=obj（类赋值给一个变量）
　　二、均可以看成函数的参数传入（类做为函数参数进行传递）
　　三、均可以看成函数的返回值（把类做为函数的返回值）
　　四、均可以看成容器类的元素，l=[func, time, obj, 1] （在运行时动态地建立类）
　　换句话说，符合上述条件就是一个对象，若是类Foo自己就是对象，那须要探究Foo是由哪一个类产生的。sql

#type函数能够查看类型，也能够用来查看对象的类，两者是同样的
print(type(f1)) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类建立
print(type(Foo)) # 输出：<type 'type'>

3、元类概念

　　元类是类的类，是类的模板数据库

　　元类做用：是控制如何建立类的，正如类是建立对象的模板同样，而元类的主要目的是为了控制类的建立行为。app

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

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

4、建立类的两种方式

一、使用class关键字

class Chinese:  # 这个类实际上是元类实例化的一个对象
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print('%s is talking' % self.name)

二、手动模拟class建立类的过程

　　将建立类的步骤拆分开，手动去建立。学习

#准备工做：

#建立类主要分为三部分

　　1 类名

　　2 类的父类

　　3 类体


#类名
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过程相似，只是后者会将__开头的属性变形），生成类的局部名称空间，即填充字典。spa

class_dic={}
exec(class_body,globals(),class_dic)

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

步骤二：调用元类type（也能够自定义）来产生类Chinese

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接收三个参数：3d

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

  • 第 2 个参数是元组 (object, )，表示全部的父类

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

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

5、自定义元类控制类的行为

　　一个类没有声明本身的元类，默认他的元类就是type，除了使用元类type，用户也能够经过继承type来自定义元类（顺便咱们也能够瞅一瞅元类如何控制类的行为，工做流程是什么）

egon5步学会元类：

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

步骤一：若是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__方法，才能控制类实例化行为

　　__call__()的做用是使实例可以像函数同样被调用，同时不影响实例自己的生命周期（__call__()不影响一个实例的构造和析构）。

　　__call__()能够用来改变实例的内部成员的值。

class Foo:
    pass

obj=Foo()
obj()
# 没有__call__方法前，obj() 报错：TypeError: 'Foo' object is not callable（不可调用）



class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)
    pass

obj=Foo()
obj(1, 2, 3, a=1, b=2, c=3)
"""
<__main__.Foo object at 0x101eb6390>
(1, 2, 3)
{'a': 1, 'b': 2, 'c': 3}
"""
__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类实例化行为

　　总结：若是说类People是元类type的实例，那么在元类type内确定也有一个__call__，会在调用People('egon',18)时触发执行，而后返回一个初始化好了的对象obj。

步骤三：自定义元类，控制类的调用（即实例化）的过程

class Mymeta(type):   # 自定义元类，大多数属性依然是继承的type
    def __init__(self, class_name, class_bases, class_dic):
        # print(class_name)  # 类名：Chinese
        # print(class_bases)  # 基类：(<class 'object'>,)
        # print(class_dic)  # 类的名称空间：{'__module__': '__main__', '__qualname__': 'Chinese', 'country': 'China', '__init__': <function Chinese.__init__ at 0x101f201e0>, 'talk': <function Chinese.talk at 0x101f20378>}

        # 自订制控制类的行为
        if not class_name.istitle():  # istitle()判断首字母大写
            raise TypeError('类名的首字母必须大写')# 主动报错的关键字是raise

        if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
            raise TypeError("必须有注释，且注释不能为空")

        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类功能

    def __call__(self, *args, **kwargs):  # obj = Chinese('egon',age=18)
        print(self)  # self = Chinese
        print(args)   # args = ('egon',)
        print(kwargs)   # kwargs = {'age': 18}

        # 第一件事：实例化先造一个空对象obj
        obj = object.__new__(self)
        # 第二件事：初始化obj
        self.__init__(obj, *args, **kwargs)
        # 第三件事：返回obj
        return obj

class Chinese(object, metaclass=Mymeta):  # 元类为Mymeta的类的建立可受人控制
    """
    中国人的类
    """
    country = 'China'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print('%s is talking' % self.name)

# obj = Chinese('egon', 18)  # Chinese.__call__(Chinese, 'egon', 18)

obj = Chinese('egon', age=18)   # 实例化的行为
"""
<class '__main__.Chinese'>
('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) {}

        #一、调用self，即People下的函数__new__，在该函数内完成：一、产生空对象obj 二、初始化 三、返回obj
        obj=self.__new__(self,*args,**kwargs)

        #二、必定记得返回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}
__new__函数

步骤五：基于元类实现单例模式,好比数据库对象,实例化时参数都同样,就不必重复产生对象,浪费内存

方式一：

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 = MySQL()
# obj2 = MySQL()
#
# print(obj1)
# print(obj2)

obj1 = MySQL.singleton()
obj2 = MySQL.singleton()
obj3 = MySQL.singleton()

print(obj1 is obj3)
"""
True
"""
定义一个类方法实现单例模式

方式二：

class Mymeta(type):
    def __init__(self, class_name, class_bases, class_dic):
        if not class_name.istitle():  # istitle()判断首字母大写
            raise TypeError('类名的首字母必须大写')  # 主动报错的关键字是raise

        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):  # obj = Chinese('egon',age=18)
        if not self.__instance:
            obj=object.__new__(self)  # self:Mysql
            self.__init__(obj)
            self.__instance=obj
        return self.__instance

class Mysql(object, metaclass=Mymeta):
    """
    mysql
    """
    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"
定制元类实现单例模式

方式三：

#settings.py文件内容以下
HOST='1.1.1.1'
PORT=3306

import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance

    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False
定义一个装饰器实现单例模式
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程