Day 5-8 自定义元类控制类的实例化行为

__call__方法:

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

 class Foo:

     def __init__(self):
         pass

     def __call__(self, *args, **kwargs):  # 在类中,使用__call__方法,表示实例化的对象可以被调用,也可以传参数进来.
         print(args)
         print(kwargs)

 obj = Foo()  #obj是由Foo类实例化得来的.那么Foo也是可以被调用的.那么Foo的类的内部也应该有一个__call__的方法.
那么Foo的类是元类type,那么type内部肯定也有一个__call__方法

 #Foo是由元类实例化得来的,所以元类内部也有一个__call__方法,会在调用Foo的时候触发执行
 #Foo(1,2,3)等价于 Foo__call__(Foo,1,2,3)
 obj(1,2,3,x=99,y=100)   # 传参到__call__方法中,相当于obj.__call__(obj, 1,2,3,x=99,y=100)  
打印输出: (1, 2, 3) {'x': 99, 'y': 100}

自定义元类控制类的实例化行为:

 class Mymeta(type):  # 继承默认元类的一堆属性
     def __init__(self,class_name, class_body, class_dic):
         if not class_name.istitle():
             raise TypeError("类名首字母必须大写!")

         if "__doc__" not in class_dic or not class_dic["__doc__"].strip():
             raise TypeError("必须有注释,且注释不能为空!")

         super().__init__(class_name, class_body, class_dic)

     def __call__(self, *args, **kwargs):#Chinese.__call__(Chinese,"jack",18)
         # print("__call__ in Mymeta")
         print(self)     # Chinese
         print(args)     # "jack",18
         print(kwargs)   #{}
         #实际上是在__call__做了3件事
         #1.创建一个空对象
         obj = object.__new__(self) # self =Chinese
         #2.初始化对象
         self.__init__(obj, *args, **kwargs)
         #3.返回对象
         return obj

 class Chinese(object, metaclass=Mymeta):
     """
     休息休息
     """
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def tell(self):
         print("name:%s,age:%s" % (self.name, self.age))

 obj1 = Chinese("jack",18) # Chinese.__call__(Chinese,"jack",18) 相当于调用mymeta下的__call__方法.

单例模式:

 # 单例模式

 class MySql:
     __instance =None
     def __init__(self):
         self.host = "127.0.0.1"
         self.port = ""

     @classmethod
     def singeton(cls):
         if not cls.__instance :  # 检测如果__instance没有值.为None!如果一个对象中的元素是None,not 对象,则返回False
             # print("s",cls.__instance)
             obj =cls()          # 就实例化一个对象
             cls.__instance =obj # 把实例化对象的值赋给cls__instance
         return cls.__instance

 sql1 = MySql.singeton()
 sql2 = MySql.singeton()
 print(sql1 is sql2)
 print(id(sql1))
 print(id(sql2))
 """
  # 由于sql1和sql2都是由MySql实例化得来的,而且它们的参数都是一样的.这样实例化对象,太浪费内存空间了.
我们之前学过a = 1, b =a
  其实a,b都指向了1的内存地址.那么我们在实例化相同参数的对象时,也可以使用这种方法.