面向对象之元类（metaclass）

class Newclass():   # class定义一个类，类名为：Newclass
# 下面的代码都是类体代码，也就是类的属性们
    def __init__(self, name, age):
        self.name = name
        self.age = age
    coutry = 'China'
    def task(self):
        print('%s is sleeping' % self.name)

t1 = Newclass('sgt', 30)  # 调用类，实例化t1这个对象

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

    coutry = 'China'

    def task(self):
        print('%s is sleeping' % self.name)

t1 = Newclass('sgt', 30) 

# 我们来分别打印一下实例化出的对象t1和创建的类Newclass的类型：
print(type(t1))
print(type(Newclass))
# 结果是：
# <class '__main__.Newclass'>   
# <class 'type'>      
# 我们可以推出：                   
# t1是调用Newclass产生的
# Newclass是调用type产生的

# 引入函数exec（object, globals, locals）
exec用法：
object：类体代码，包含一系列python代码的字符串
globals:全局作用域（字典形式），如果不指定，默认为globals()
locals：局部名称空间（类的名称空间）
可以把exec命令的执行当成是一个函数的执行，会将执行期间产生的名字存放于局部名称空间中

# 不依赖class关键字创建一个自定义类
类名class_name= 'Newcalss'
继承的类们：class_bases = (object,)
类体代码：class_body = '''
def __init__(self, name, age):
    self.name = name
    self.age = age
coutry = 'China'
def task(self):
    print('%s is sleeping' % self.name)

''' exec(class_body,{},class_dic) 

# 创建一个名称空间，将类体代码放入class_dict中，这个class_dict就代表exec创建的名称空间 
# 调用type得到自定义的类： 
Newclass = type(class_name, class_bases, class_dict)

class MyMeta(type):  # 只有继承了type的类才能称之为一个元类，否则就是普通的类
    pass

class Newclass(object,metaclass=MyMeta):  # 继承基类object，为Newclass指定元类为MyMeta
    def __init__(self, name, age):
        self.name = name
        self.age = age

    coutry = 'China'

    def task(self):
        print('%s is sleeping' % self.name)

class MyMeta(type):  # 只有继承了type的类才能称之为一个元类，否则就是普通的类
    def __init__(self, class_name, class_bases, class_dict):
        super().__init__(class_name, class_bases, class_dict)

        if class_name.islower():    #  给类名做限制，必须为驼峰体，否则抛异常
            raise TypeError('类名必须为驼峰体')
        # 给类中注释的存在性加以限制，必须要有注释且不能为空，否则抛异常
        if '__doc__' not in class_dict or len(class_dict['__doc__'].strip(' \n')) == 0:
            raise TypeError('类必须要求有文档注释，且不能为空')

class Newclass(object,metaclass=MyMeta):  # 继承基类object，为Newclass指定元类为MyMeta
    '''
    这是Newclass类的注释
    '''
    def __init__(self, name, age):
        self.name = name
        self.age = age

    coutry = 'China'

    def task(self):
        print('%s is sleeping' % self.name)

class Newclass():
    coutry = 'China'
    def task(self):
        print('%s is sleeping' % self.name)

    def __call__(self, *args, **kwargs):
        print('__call__被调用了>>>', self)
        print('__call__被调用了>>>', args)
        print('__call__被调用了>>>', kwargs)
t1 = Newclass()

## 要想让t1这个对象可调用，需要在该对象的类中定义一个__call__方法，
#       该方法会在对象t1在调用时候自动触发
## 调用t1的返回值就是__call__方法的返回值
res = t1('a', 'b', 8, name = 'jason', age = 18)

# 右键运行结果：
__call__被调用了>>> <__main__.Newclass object at 0x000001AD69359828>  
__call__被调用了>>> ('a', 'b', 8)
__call__被调用了>>> {'name': 'jason', 'age': 18}

class MyMeta(type):
    def __init__(self, class_name, class_bases, class_dict):
        super().__init__(class_name, class_bases, class_dict)

    def __call__(self, *args, **kwargs):
        print(self)    # <class '__main__.Newclass'>
        print(args)    # ('sgt', 18)
        print(kwargs)  # {}
        return 123

class Newclass(object,metaclass=MyMeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    coutry = 'China'
    def task(self):
        print('%s is sleeping' % self.name)

t1 = Newclass('sgt', 18)
print(t1)  # 123

class MyMeta(type):
    def __init__(self, class_name, class_bases, class_dict):
        super().__init__(class_name, class_bases, class_dict)

    def __call__(self, *args, **kwargs):
        # 1 调用__new__产生一个空对象obj:
        obj = self.__new__(self)  # __new__会产生空对象的名称空间
        # 这里self.__new__是通过self(类Newclass)来调用__new__方法，通过属性查找默认在基类object中
        # 括号里self的意思是创建类Newclass的对象的名称空间。
        # 2 调用__init__初始化空对象obj
        self.__init__(obj, *args, **kwargs) # 注意这里的第一个参数是obj，因为我们初始化的是我么创建的空对象
        # 3 返回初始化好的对象obj
        return obj
class Newclass(object,metaclass=MyMeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    coutry = 'China'
    def task(self):
        print('%s is sleeping' % self.name)

t1 = Newclass('sgt', 18)   # 实例化对象
print(t1.__dict__)  # {'name': 'sgt', 'age': 18}  # 查看实例化对象的结果

class MyMeta(type):
    def __init__(self, class_name, class_bases, class_dict):
        super().__init__(class_name, class_bases, class_dict)

    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)  # 在初始化完的对象返回之前进行修改
        res = {k.upper(): v for k, v in obj.__dict__.items()}  # 将对象的属性名大写
        return res

class Newclass(object,metaclass=MyMeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    coutry = 'China'
    def task(self):
        print('%s is sleeping' % self.name)

t1 = Newclass('sgt', 18)
print(t1)  # {'NAME': 'sgt', 'AGE': 18}

class MyMeta(type):  
    n = 444
    def __call__(self, *args, **kwargs): 
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        return obj

class Bar(object):
    n = 333

class Foo(Bar):
    n = 222

class Newclass(Foo,metaclass=MyMeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    n = 111
    coutry = 'China'
    def task(self):
        print('%s is sleeping' % self.name)

print(Newclass.n)
# 自下而上依次注释各个类中的n=xxx，然后重新运行程序，
# 发现n的查找顺序为Newclass->Foo->Bar->object->MyMeta->type

# 查找顺序：
# 1、先对象层：Newclass->Foo->Bar->object
# 2、然后元类层：MyMeta->type