python面向对象：元类

一 知识储备

exec:三个参数

参数一：字符串形式的命令

参数二：全局作用域（字典形式）

参数三：局部作用域（字典形式）

　　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}

　　

二  引子（类也是对象）

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

　　

三 什么是元类？

 元类是类的类，是类的模板

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

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

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

四 创建类的两种方式

方式一：使用class关键字

class Chinse(object):
    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, home, 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)

　　

步骤二：调用元类type（也可以自定义）来产生类Chinense

Foo = type(class_name, class_bases, class_dic)  # 实例化type，得到对象Foo，即我们用class定义的类Foo


print(Foo)
print(type(Foo))
print(isinstance(Foo, type))

　　

我们看到，type接收三个参数：

• 第1个参数时字符串‘Foo’， 表示类名
• 第2个参数时元组（object，）表示所有的父类
• 第3个参数时字典，这里是一个空字典，表示没有定义属性和方法

补充：若Foo类有继承，即class Foo（Bar）。。。则等同于type（‘Foo‘，（Bar，），{}）

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

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

　　5步带你学会元类：

# 步骤一：如果People=type(类名，类的父类们，类的名称空间),那么我们定义元类如下,来控制类的创建
class Mymeta(type):  # 继承默认元类的一堆属性
    def __init__(self, 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):
        # country = 'China'

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

    def __call__(self, *args, **kwargs):
        print(self, args, kwargs)

    def talk(self):
        print('%s is talking' % self.name)
#
# # 调用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 0x0000000009CCD3C8> (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):
        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, 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):
        print(self, args, kwargs)

        # 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__)

# 步骤五：基于元类实现单例模式，比如数据库对象，实例化时参数都一样，就没有必要重复产生对象，浪费内存
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 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__)

　　

练习题二：在元类中控制自定义的类无需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__)