# 思考：
#     Python 中对象是由实例化类得来的，那么类又是怎么得到的呢？
# 疑问：
#     python 中一切皆对象，那么类是否也是对象？如果是，那么它又是那个类实例化而来的呢？

class student(object):def __init__(self):passjmz = student()print(type(jmz))  # <class '__main__.student'>   实例化student 得来的
print(type(student))    # <class 'type'>   

# 说明student类 是实例化type得来的。但任然是类
# 总结：  元类即类的类。  type 就是Python中的默认元类# 元类===》类====》对象 （对象是实例化类得来的，类是实例化元类得来的）

# type用法一： 查看对象的类
class dog(object):def __init__(self):passdef eat(self):print('dog eating...')dog1 = dog()
dog1.eat()          # dog eating...
print(type(dog1))   # <class '__main__.dog'>
print(dog.__dict__)
# {'__module__': '__main__', '__init__': <function dog.__init__ at 0x00000000021B9950>, 'eat': <function dog.eat at 0x00000000021B99D8>, '__dict__': <attribute '__dict__' of 'dog' objects>, '__weakref__': <attribute '__weakref__' of 'dog' objects>, '__doc__': None}# type 用法二： 创建动态类
def __init__(self):pass
def eat(self):print("cat eating...")
cat = type('cat',(object,),{"__init__":__init__,"eat":eat})cat1 = cat()
cat1.eat()          # cat eating...
print(type(cat1))  # <class '__main__.cat'>
print(cat.__dict__)
# {'__init__': <function __init__ at 0x00000000004D1EA0>, 'eat': <function eat at 0x00000000022D9A60>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'cat' objects>, '__weakref__': <attribute '__weakref__' of 'cat' objects>, '__doc__': None}

# 分析：
#     1、dog 类 与cat类功能基本一致，只是实现方式不同，一个使用了class 定义了类，一个使用了type产生了一个类
#     2、dog类与cat类实例化方式一样，
#     3、产生对象后的调用对象方法一样
#     4、__dict__ 类的内容基本一致# 总结：
#     class 关键字的底层实现就是做了与type方法一样的事

#1 拿到类名class_name="cat"
#2 拿到基类们class_bases=(object,)
#3 拿到名称空间 class_dic={...}
#4 调用元类产生cat类，
cat=type(class_name,class_bases,class_dic)

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmzclass Mymeta(type):   # 继承type元类def __init__(self,class_name,class_bases,class_dict):if not class_name.istitle():raise TypeError('类的名称首字母必须大写')if not class_dict.get('__doc__'):raise TypeError('类的定义必须要有参数')super(Mymeta, self).__init__(class_name, class_bases, class_dict)# 使用mateclass
class People(object,metaclass=Mymeta):       # ===》 People = type("People",(object,),{名称空间})'''这是一个关于人的类'''def __init__(self,name,sex):self.name = nameself.sex = sexdef do(self,thing):print("%s 正在做%s"%self.name,thing)

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmzclass Mymeta(type):   # 继承type元类def __init__(self,class_name,class_bases,class_dict):  # class_name="People",class_bases=(object,),class_dict={名称空间}if not class_name.istitle():raise TypeError('类的名称首字母必须大写')if not class_dict.get('__doc__'):raise TypeError('类的定义必须要有参数')super(Mymeta, self).__init__(class_name, class_bases, class_dict)# 使用mateclass
class People(object,metaclass=Mymeta):       # ===》 People = type("People",(object,),{名称空间})'''这是一个关于人的类'''def __init__(self,name,sex):self.name = nameself.sex = sexdef do(self,thing):print("%s 正在做%s"%self.name,thing)

class teacher(object):__addr ="上海校区"def __init__(self,name):self.name = namedef select_class(self):passdef __call__(self, *args, **kwargs):   # 对象当成方法调用时会触发类的__call__ 方法执行print("对象调用触发")print(args)print(kwargs)egon = teacher('egon')
egon(23,"男",school = "oldboy")
# 对象调用触发
# (23, '男')
# {'school': 'oldboy'}

class Mymeta(type):def __call__(self, *args, **kwargs):print("我是元类的__call__ 方法，类被调用时触发")print(args)print(kwargs)class Student(object,metaclass=Mymeta):   # Student = type("Student",(object,),{})passStudent('jmz',18,school="交大")
# 我是元类的__call__ 方法，类被调用时触发
# ('jmz', 18)
# {'school': '交大'}

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmzclass Mymeta(type):  def __init__(self,class_name,class_bases,class_dict):if not class_name.istitle:raise TypeError("类的首字母必须大写")if not class_dict.get("__doc__"):raise TypeError("类的创建需写入注释说明")super(Mymeta,self).__init__(class_name,class_bases,class_dict)def __call__(self, *args, **kwargs):   # __call__  是由类调用的，所以self 就是类本身# 1、 产生一个空对象# 2、 将参数传入类的__init___方法中
obj = object.__new__(self)   # 产生一个空对象,, __new__ 是object 的静态方法self.__init__(obj,*args,**kwargs)  # 调用类的__init__ 方法，self 就是类return objclass Student(object,metaclass=Mymeta):'''这是学生类'''__school = "上海交大"def __init__(self,name,age):self.name = nameself.age = agedef get_school(self):return self.__schooljmz = Student("jmz",24)
print(jmz.__dict__)
print(jmz.get_school())
# {'name': 'jmz', 'age': 24}
# 上海交大

# 上文解释：
   1、元类的__call__ 方法是由类被调用触发的（即类（），就会触发），2、类是实例化元类产生的，也可以说是元类产生的对象就是类，触发元类的__call__ 方法就是由类这个对象调用触发的，所以元类中的self 就是类。3、将参数传入类的__init__ 方法其实就是将参数传入元类中self的__init__方法。4、调用类的__init__ 方法与调用静态方法相同，该传的参数都要传

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmzclass mysql(object):__instance = Nonedef __init__(self):pass@classmethoddef get_instance(cls,*args,**kwargs):if not cls.__instance:cls.__instance = cls(*args,**kwargs)return cls.__instancemysql = mysql.get_instance()
print(mysql)
# <__main__.mysql object at 0x00000000022D7BE0>
mysql = mysql.get_instance()
print(mysql)
# <__main__.mysql object at 0x00000000022D7BE0># 说明两个返回的内容地址是一样的，说明只实例化了一次。

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Author Jmzclass Mymeta(type):__instance = Nonedef __init__(self,class_name,class_bases,class_dict):if not class_name.istitle:raise TypeError("类的首字母必须大写")if not class_dict.get("__doc__"):raise TypeError("类的创建需写入注释说明")super(Mymeta,self).__init__(class_name,class_bases,class_dict)def __call__(self, *args, **kwargs):   # __call__  是由类调用的，所以self 就是类本身# 1、 产生一个空对象# 2、 将参数传入类的__init___方法中if not self.__instance:obj = object.__new__(self)   # 产生一个空对象,, __new__ 是object 的静态方法self.__init__(obj,*args,**kwargs)  # 调用类的__init__ 方法，self 就是类self.__instance = objreturn self.__instanceclass Student(object,metaclass=Mymeta):'''学生类'''def __init__(self,name,age,school):self.name = nameself.age = ageself.school = schooldef learn(self,thing):print("%s 正在学习%s"%(self.name,thing))class Teacher(object,metaclass=Mymeta):'''老师类'''def __init__(self,name,age):self.name = nameself.age = agedef teach(self,):print("%s 正在教书中。。。"%self.name)jmz = Student("jmz",23,"北大")
jmz1 = Student("jmz1",23,"北大")print(id(jmz),id(jmz1))
# 38853264 38853264
egon = Teacher("egon",24)
egon1 = Teacher("egon1",24)
print(id(egon),id(egon1))
# 31578992 31578992# 解释
# 1、student 类和 teacher类都是调用元类产生的，不同的类调用元类就好产生不同的内容地址。不同的类也只会定义一次（正常的）
# 2、 对象的产生是有调用了元类的__call__ 方法产生的，所以每次调用都返回相同的对象（单例）。

元类，单例实现