14 元类

1、知识储备  exec(object[, globals[, locals]])

exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。

参数
object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。
如果object是一个code对象，那么它只是被简单的执行。

globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。

locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
返回值

exec 返回值永远为 None。

>>>exec('print("Hello World")')
Hello World
# 单行语句字符串
>>> exec("print ('runoob.com')")
runoob.com
 
#  多行语句字符串
>>> exec ("""for i in range(5):
...     print ("iter time: %d" % i)
... """)
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()

结果：
60
33
34

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

exec('''
global x,z
x=100        ‘’‘   ’‘’里面的是字符串 g 全局作用域   l 局部作用域
z=200

m=300
''',g,l)

print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}

2、引子（类也是对象）

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

3、元类

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

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

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

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

4、创建类的两种方式

4.1、方式一：使用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)

 4.2、方式二： 就是手动模拟class创建类的过程）：将创建类的步骤拆分开，手动去创建

语法
以下是 type() 方法的语法:

1
class type(name, bases, dict)
参数
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典，类内定义的命名空间变量。
返回值
一个参数返回对象类型, 三个参数，返回新的类型对象。

#准备工作：

#创建类主要分为三部分

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

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

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

5.1、创建类

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

class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
        if not class_name.istitle():
            raise  TypeError('类名的首字母必须大写')


        # print(class_name)  # 类名
        # print(class_bases) # 类的父类 
        print(class_dic)     # 类的名称空间
        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(f"{self.name} is talking")

5.2、控制类的实例化行为----知识储备__call__

一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。

我们把 Person 类变成一个可调用对象：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print ('My name is %s...' % self.name)
        print ('My friend is %s...' % friend)
现在可以对 Person 实例直接调用：

>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...
单看 p('Tim') 你无法确定 p 是一个函数还是一个类实例，所以，在Python中，函数也是对象，对象和函数的区别并不显著。

#步骤二：如果我们想控制类实例化的行为，那么需要先储备知识__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

 5.3、自定义元类，控制类的调用（即实例化）的过程

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

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}

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

class MySQL:
    __instance = None   # 第一次实例化后  __instance = obj
    def __init__(self):
        self.host = '127.0.0.1'
        self.port = 3306
    @classmethod
    def singlethon(cls):
        if not cls.__instance:
            obj = cls()
            cls.__instance = obj
        return cls.__instance
    def conn(self):
        pass
    def execute(self):
        pass
obj1 = MySQL.singlethon()
obj2 = MySQL.singlethon()

print(obj1 is obj2) #True

 

刚开始：class MySQL--->__instance = None---->def __init__(self)----->@classmethod---->obj1 = MySQL.singlethon()--->if not cls.__instance:

obj = cls()--->self.host = '127.0.0.1'----->self.port = 3306------->cls.__instance = obj----->return cls.__instance--->obj2 = MySQL.singlethon()---->

if not cls.__instance:---->return cls.__instance---->print(obj1 is obj2)

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()
print(obj1 is obj2)

 

 

 6、练习题---callable()

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

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('__'): # 如果v不可调用(意思是数据属性)，并且k的首写不等于__: 执行（首字母大写的操作）update_attrs[k.upper()]=v
                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__) # 类的所有属性

# 类的__dict__属性和类对象的__dict__属性

知识点：Python callable() 函数

callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True

语法
callable()方法语法：

callable(object)
参数
object -- 对象
返回值
可调用返回 True，否则返回 False。

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