# 元类
# 说python当中一切皆对象，
# 用class关键字定义的类其实本质也是一个对象。
# class Foo:
# pass
# 说Foo是一个对象的话，对象肯定是由一个类实例化而来的。
# 也就是说在class的时候，调class关键字的时候，必然是这个关键字去调了一个类的类，类的类就称之为元类。
# 就是调了一个元类加括号实例化，元类加括号的结果就是用class定义的类
# class Foo: # Foo = 元类()
# pass
# 所以说元类就是负责产生类的那一个类，是类的老祖宗。
# 1.什么是元类？
# 在python中一切皆对象，那么我们用class关键字定义的类本身也是一个对象
# 负责产生该对象的类称之为元类，即元类可以简称为类的类
# 2.为何要用元类？
# 什么情况下用元类？
# 元类是负责产生类的，可以控制类的产生过程，还可以控制对象的产生过程。
# 什么叫对象的产生过程？
# class Foo:
# pass
# Foo()
# 对Foo这个类的产生控制,以及对调用Foo的这个过程的控制，因为调用Foo的过程就是产生Foo对象的过程
# 3.如何用元类
# 3.1 需要储备几点知识
# 第一点知识： exec()这个内置函数
# exec()这个内置函数用来干什么的呢？
# 将一个字符串中的代码提出出来运行一下
# cmd = '''
# x=1
# y=2
# print('我爱老婆杨静，哈哈哈')
# '''
# local_dic = {}
# exec(cmd,)
# 模拟的就是执行python代码的过程，会产生一个名字，必然往名称空间里面去丢
# 名称空间的格式是以字典的形式展现的
# 所以造两个名称空间，一个全局名称空间
# 怎么查看全局的名称空间：
# print(globals())
# 造一个空字典
# local_dic = {}
# exec(第一个参数是你的字符串，第二个参数是你要引用的那个全局作用域（不需要定义个空字典就好了），第三个是local_dic)
# exec(cmd,{},local_dic)
# print(local_dic)
# 会发生什么是呢？
# exec会执行字符串中的代码，将执行过程中产生的名字都往local_dic = {}里面丢
# exec干了一件事：给你一段代码，只要执行过程中产生名字都丢到一个名称空间字典里面去。
# 函数也可以！！
# 函数体代码提取出来
# def func():
# x= 1
# y=2
# print('杨静爱老公张仁国，哈哈哈')
# cmd = '''
# x = 1
# y = 2
# print('杨静爱老公张仁国，哈哈哈')
# '''
# func_dic = {}
# exec(cmd,{},func_dic)
#
# print(func_dic)
# 类也可以！！
# 类体代码提取出来
# cmd = '''
# x=1
# def func():
# y = 2
# '''
# class_dic = {}
# exec(cmd,{},class_dic)
# print(class_dic)
# 类体执行过程中产生的名字都丢到名称空间里面去了
# 这是模拟了类创建过程中类定义阶段造名称空间那一步操作
# 用这个功能干嘛使？
# 可以用来模拟造名称空间这个过程。
# 3.2创建类过程当中有几个关键的要素
# 创建类的方法有两种
# 第一种class关键字去创建,用的是默认的元类：type
# class People():
# country = 'china'
# def __init__(self,name,age):
# self.name = name
# self.age = age
#
# def eat(self):
# print('%s is eating'%self.name)
# # 查看People的类是谁：
# print(type(People))
# # <class 'type'>
#
# print(People)
# obj = People('zrg',24)
# print(obj)
# obj.eat()
# print(type(obj))
# 大前提：如果说类也是对象的话，那么用class关键字去创建类的过程也是一个实例化的过程
# 该实例化的目的是为了得到一个类，调用的是元类
# 调用的元类又分为两种：
# 一种是默认的元类type
# 另一种是自定义的
# 默认的元类的造类的过程：
# 类的名字 class_name
# 类的基类 class_bases
# 类的名称空间 class_dic
#
# class_name = 'People' #类名必须是字符串形式
# class_bases = (object,) #不继承任何类默认就是object逗号才叫一个元组
# class_dic = {} #最关键的最难得，类的名称空间一个字典的形式
# 类的名称空间从何而来----->从类体的执行而来，而类体就是一堆字符串
# class_body = '''
# country = 'china'
# def __init__(self,name,age):
# self.name = name
# self.age = age
#
# def eat(self):
# print('%s is eating'%self.name)
# '''
# 要做的事根据类体代码得到字典让他里面有值，就用exec函数
# exec(class_body,{},class_dic)
# 查看造类的三要素
# print(class_name)
# print(class_bases)
# print(class_dic)
# type(类名，基类，类的名称空间)得的结果给一个变量名People1
# People1 = type(class_name,class_bases,class_dic)
# print(People1)
# obj1 = People1('yj',25)
# obj1.eat()
# 第二种 自定义元类
# 自定义的话就是把type换成自己写的类名字
# 定义自己的元类不一定所有的功能都要自己写，大部分都是源自type的所以继承
# class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义的类
# def __init__(self,class_name,class_bases,class_dic):
#控制逻辑
# if class_dic.get('__doc__') is None or len(class_dic.get('__doc__').strip()) == 0:
# raise TypeError('类中必须有文档注释，并且文档注释不能为空')
# if not class_name.istitle():
# raise TypeError('类名首字母必须大写')
# print(self) #现在是 People
# print(class_name)
# print(class_bases)
# print(class_dic)
# 上面的改写的功能是把父类的覆盖掉了，父类的可能还有些其他有用的代码
# 所以super括号括起来，自己的类名，逗号self就是People，然后括号__init__也需要把三个参数传进去
# 这是保险起见把父类的功能也重用一下
# super(Mymeta,self).__init__(class_name,class_bases,class_dic)
# 分析class的运行原理：
# 1.拿到一个字符串格式的类名 class_name
# 2.拿到一个类的基类们 class_bases
# 3.执行类体代码，拿到一个类的名称空间 class_dic
# 4.调用type(class_name,class_bases,class_dic)将得到的结果赋值给个变量名People
# People = type(class_name,class_bases,class_dic)
# class People(object,metaclass=Mymeta): # People = Mymeta(类名，基类们，名称空间)
#加文档注释 不写 为空都是不合法的
# '''这是一个People类'''
# country = 'china'
# def __init__(self,name,age):
# self.name = name
# self.age = age
# def eat(self):
# print('%s is eating'%self.name)
# print(People.__dict__) #看名称空间
# 文档注释是空
# {'__module__': '__main__', 'country': 'china', '__init__': <function People.__init__ at 0x000001E1BAFD9950>, 'eat': <function People.eat at 0x000001E1BAFD99D8>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
# 应用：自定义元类控制类的产生过程，类的产生过程其实就是元类的调用过程
# 3.3储备知识 __call__
# __开头__结尾 会在满足某种条件时自动触发执行
# class Foo:
# def __call__(self, *args, **kwargs):
# print('ok')
# print(self)
# print(args) #args就是传的位置参数
# print(kwargs) #kwargs就是传的关键字参数
#
# obj = Foo()
# # obj() #要想让obj这个对象变成一个可调用的对象，需要早该对象的类中定义一个方法__call__方法
# # 该方法会在调用对象是自动触发
# obj(1,2,3,x=1,y=2)
# 自定义元类控制类的产生过程
# 其实自定义类定义完了之后，还要去调用那个类，还想要去控制自定义类的那个调用过程
# 也就是自定义类创造对象的过程
# 4. 自定义元类来控制类的调用过程，即类的实例化过程
class Mymeta(type):
def __call__(self, *args, **kwargs):
# print(self) #self是People
# print(args)
# print(kwargs)
# 1.先造出一个People空对象
obj = self.__new__(self)
# 2.为该空对象初始化独有的属性
self.__init__(obj,*args,**kwargs)
# 3.返回一个初始化好的obj
return obj
class People(object,metaclass=Mymeta): # People = Mymeta(类名，基类们，名称空间)
# 加文档注释 不写 为空都是不合法的
'''这是一个People类'''
country = 'china'
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print('%s is eating'%self.name)
# 分析：调用People的目的
# 1.先造出一个People空对象
# 2.为该空对象初始化独有的属性
obj = People('zrg',age=24)
print(obj.__dict__)
print(obj.name)
obj.eat()
# 调对象就是调对象内的call方法，调对象拿到的返回值就是call方法的返回值
# 不写返回值就是一个None
