元类：
python中一切皆对象，意味着：
1. 都可以被引用，如 x = obj
2. 都可以被当做函数的参数传入
3. 都可以被当做函数的返回值
4. 都可以当做容器类的元素（列表、字典、元祖、集合），如： l = [func,time,obj,1]
换句话说，只要能满足上述4点，它就是对象；例如，类也是对象（类也是由type实例化产生的）
class Foo: pass class Bar: pass print(type(Foo)) print(type(Bar)) # 运行结果： # <class ‘type‘> # <class ‘type‘>
定义： 产生类的类称之为元类，默认所有用class定义的类，他们的元类都是type
定义类的两种方式：
方式一：class方法（class方式也是利用了type这个元类）
方式二：直接利用type这个元类的方法
定义类的三要素： 类名、类的基类、类的名称空间
"""利用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) """利用type自己定义一个类""" class_name = "Chinese" # 类名 class_base = (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) """ class_dict = {} # 类的名称空间 exec(class_body,globals(),class_dict) # 执行类体的代码，并把类体的值放入到 class_dict中作为其名称空间 print(class_dict) # 打印结果： # {‘country‘: ‘China‘, ‘__init__‘: <function __init__ at 0x000000D574701E18>, ‘talk‘: <function talk at 0x000000D57487BD90>} # 定义类 Chinese1 = type(class_name,class_base,class_dict) # 这样就定义出了一个类 print(Chinese) print(Chinese1) # 打印结果： # <class ‘__main__.Chinese‘> # <class ‘__main__.Chinese‘> obj = Chinese("neo",18) obj1 = Chinese1("egon",22) print(obj,obj.name,obj.age) print(obj1,obj1.name,obj1.age) # 打印结果： # <__main__.Chinese object at 0x000000F1D54B67B8> neo 18 # <__main__.Chinese object at 0x000000F1D54B6710> egon 22
自定义元类控制类的行为：
利用class定义类（如上面的 Chinese）时，完整的写法其实是： class Chinese(object,metaclass = type) # metaclass = type的含义是 元类是type ； “class Chinese：” 这行代码在执行（即定义Chinese类）时，其实是 Chinese = type(...) ，也就是 type这个元类在实例化。
如下代码：
"""不以type作为元类，而以自己定义的类作为元类，来控制类的行为""" """第二步的分析：创建 Mymeta 元类""" class Mymeta(type): # class 是调用type这个元类； type元类里面已经定义了很多的方法，而我只是重新定义其中一小部分代码，所以我创建的元类需要继承type，从而Mymeta能够调用type的其他方法 """ Chinese 的元类是这个Mymeta，在定义Chinese类的时候需要实例化Mymeta， 如： Chinese = Mymeta（class_name,class_bases,class_dict) 需要往Mymeta中传入定义类的三要素，所以 Mymeta中需要有 __init__ 方法 """ def __init__(self,class_name,class_bases,class_dict): # 这个实例化的__init__ 肯定有这三个参数：class_name,class_bases,class_dict super(Mymeta,self).__init__(class_name,class_bases,class_dict) # type 的 __init__ 方法中有很多的功能，自己创建的元类 Mymeta 首先需要继承type的__init__ ， 同时再定义自己的方法 print(class_name) print(class_bases) print(class_dict) """第一步的分析：不以type作为元类，而以我自己创建的类 Mymeta 作为元类；所以我需要先定义一个元类 Mymeta""" class Chinese(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) # 类体代码会以字典的形式传入到class_dict中作为 Chinese类的名称空间 # 运行结果： # Chinese # (<class ‘object‘>,) # {‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘Chinese‘, ‘country‘: ‘China‘, ‘__init__‘: <function Chinese.__init__ at 0x00000075D7EDBD90>, ‘talk‘: <function Chinese.talk at 0x00000075D7EDBE18>} """执行上述代码，直接就执行了 Mymeta 中 __init__ 的三个print，是因为 class Chinese(object,metaclass=Mymeta) 就是Mymeta在进行实例化，而实例化时会自动调用 __init__"""
补充知识点： raise TypeError("类型错误") # raise 是主动抛出异常，程序就不往下走了
自定义元类控制类的行为示例2：（类名首字母大写）
class Mymeta(type): def __init__(self,class_name,class_bases,class_dict): """目标功能：如果类名的首字母没有大写，直接报错""" if not class_name.istitle(): # .istitle() 用于判断字符串首字母是否大写，返回bool值 raise TypeError("类名首字母必须大写") # 首字母没有大写，直接抛出异常，程序终止 super(Mymeta,self).__init__(class_name,class_bases,class_dict) class chinese(metaclass=Mymeta): # 首字母没有大写 # 元类是 Mymeta pass # 执行结果： # 直接报错 # TypeError: 类名首字母必须大写
自定义元类控制类的行为示例2：（类体中需要有注释且注释不能为空）
补充知识： 类的名称空间中有一个key 是 “__doc__”，它的含义是“类里面的注释”
class Mymeta(type): def __init__(self,class_name,class_base,class_dict): if "__doc__" not in class_dict or not class_dict["__doc__"].strip(): # class_dict 中没有"__doc__"这个key 或者 class_dict["__doc__"]为空 # 空字符串和None自带bool值为False raise TypeError("必须有注释，且注释不能为空") super().__init__(class_name,class_base,class_dict) class chinese(metaclass=Mymeta): pass # 运行结果： # 报错 # TypeError: 必须有注释，且注释不能为空
自定义元类控制类的实例化行为：
补充知识点： __call__ 方法： 让对象（如 people）也能有 people()的方法。（此方法是给对象用的）
class Foo: def __call__(self, *args, **kwargs): # 能让对象变成一个可调用对象 # obj()能触发 __call__ print(self) print(args) print(kwargs) obj = Foo() # 同理，Foo()能这样调用， Foo的那个元类（type）里面也有 __call__ 方法 obj(1,2,3,a="A",b="AB") # obj也能用类似于类Foo()的方法 # 运行结果： # <__main__.Foo object at 0x000000D889D0A240> # (1, 2, 3) # {‘a‘: ‘A‘, ‘b‘: ‘AB‘}
"""
元类type内部也应该有一个 __call__ 方法， 会在调用Foo时触发执行
Foo(1,2,x=1) 即相当于 Foo.__call__(Foo,1,2,x=1) 同时，类的调用也是一个实例化的过程
"""
自定义元类控制类的实例化：
class Mymeta(type): def __init__(self,class_name,class_bases,class_dict): if not class_name.istitle(): raise TypeError("类的首字母必须大写") if "__doc__" not in class_dict or not class_dict["__doc__"].strip(): raise TypeError("类中必须有注释且注释不能为空")
super(Mymeta,self).__init__(class_name,class_bases,class_dict) """现在我自己定义一个__call__ 方法""" def __call__(self, *args, **kwargs): print("=====>>") class Chinese(object,metaclass=Mymeta): """ xx """ def __init__(self,name,age): self.name = name self.age = age def talk(self): print("%s is talking" %self.name) # obj = Chinese("neo",22) # Chinese能这样调用说明Mymeta中默认有 __call__ 方法 obj = Chinese("neo",22) # Chinese("neo",22) 在实例化的过程中会自动调用我重新定义的__call__ ， 即 Chinese.__call__(Chinese,"neo",22) print(obj) # 运行结果： # =====>> # None """ 正常情况下，类实例化时会有3个过程发生： 1. 先造出一个空对象 2. 根据__init__把空对象初始化 3. 得到一个返回值 """ # 所以我上面在Mymeta中自定义的__call__ 是不规范的
下面对 Mymeta 中的 __call__ 方法进行修改，并说明类在实例化时自动调用其__init__方法的机制：
class Mymeta(type): def __init__(self,class_name,class_bases,class_dict): # 这个__init__ 控制的是 类（Mymeta）的实例化 if not class_name.istitle(): raise TypeError("类的首字母必须大写") if "__doc__" not in class_dict or not class_dict["__doc__"].strip(): raise TypeError("类中必须有注释且注释不能为空") super(Mymeta,self).__init__(class_name,class_bases,class_dict) def __call__(self, *args, **kwargs): # 它控制的是类（Chinese）的调用 print("=====>>") # 第一步： 先造一个空对象obj obj = object.__new__(self) # object.__new__(cls)的作用是新建一个 cls类 的对象 # 第二步： 把空对象obj初始化 self.__init__(obj,*args,**kwargs) # Chinese调用自己的 __init__ # 把新建的obj这个对象传入到 Chinese类的__init__ 中 # 这行的 *args和**kwargs的含义是： __call__中的*args和**kwargs是怎么接收的，就怎么原封不动的传给这行代码中的*args和*kwargs # 第三步： 返回obj return obj """ 以上也是类（Chinese）在实例化时__init__被触发自动动用的原因，因为 __call__ 被自动调用，而 __call__ 中又手动调用了 类（Chinese）中的 __init__ """ class Chinese(object,metaclass=Mymeta): """ Chinese中的 __init__ 在被 Mymeta 中的 __call__ 调用时，*args中的"neo"当做位置参数传给 name，**kwargs中的 age=22 当作关键字参数传给 age """ def __init__(self,name,age): self.name = name self.age = age def talk(self): print("%s is talking" %self.name) obj = Chinese("neo",age=22) print(obj.__dict__) # 运行结果： # =====>> # {‘name‘: ‘neo‘, ‘age‘: 22}
自定义元类控制类的实例化行为的应用：
单例模式： 如果生成的多个对象里面的属性完全一样，就没必要实例化多次，让这多个对象使用同一块内存空间就行
单例模式实现方式一 ：
"""单例模式：让实例化的的对象共用同一个内存地址""" class Mysql: __instance = None # 设置一个隐藏属性，用于储存实例化的对象 def __init__(self): self.host = "127.0.0.1" self.port = 3306 @classmethod def singleton(cls): if not cls.__instance: # __instance 为 None时，说明还没有实例化过 obj = cls() # 实例化得到一个对象 cls.__instance = obj # 把实例化的对象赋值给 __instance return cls.__instance def con(self): pass def execute(self): pass obj1 = Mysql.singleton() obj2 = Mysql.singleton() obj3 = Mysql.singleton() print(obj1) print(obj2) print(obj3) # 运行结果： # <__main__.Mysql object at 0x000000E52BF366D8> # <__main__.Mysql object at 0x000000E52BF366D8> # <__main__.Mysql object at 0x000000E52BF366D8>
单例模式实现方式二： 元类的方式
"""通过自定义元类控制类的实例化过程：单例模式的 __call__ 方法""" class Mymeta(type): __instance = None # 定义一个隐藏属性用于储存实例化的对象 def __init__(self,class_name,class_bases,class_dict): if not class_name.istitle(): raise TypeError("首字母必须大写，且只能首字母大写") super().__init__(class_name,class_bases,class_dict) def __call__(self, *args, **kwargs): if not self.__instance: # 如果没有经过实例化 obj = object.__new__(self) # 创建一个 self 的新对象 self.__init__(obj) # 对新创建的 self的对象执行 Mysql中的 __init__ 方法（实例化） self.__instance = obj # 把实例化后的对象赋值给 __instance return self.__instance class Mysql(metaclass=Mymeta): def __init__(self): self.host = "127.0.0.1" self.port = 3306 def con(self): pass def execute(self): pass obj1 = Mysql() obj2 = Mysql() obj3 = Mysql() print(obj1) print(obj2) print(obj3) # 运行结果： # <__main__.Mysql object at 0x0000001965AC67B8> # <__main__.Mysql object at 0x0000001965AC67B8> # <__main__.Mysql object at 0x0000001965AC67B8>
