Python之路(第二十八篇) 面向对象进阶：类的装饰器、元类

一、类的装饰器

类作为一个对象，也可以被装饰。

例子

  def wrap(obj):
      print("装饰器-----")
      obj.x = 1
      obj.y = 3
      obj.z = 5
      return obj
  ​
  @wrap  #将Foo类作为一个参数传入装饰器函数wrap，返回同时返回该对象，把新对象重新命名为Foo
  #即 Foo = wrap(Foo)
  class Foo:
      pass
  ​
  #执行结果：
  #装饰器-----
  ​
  print(Foo.__dict__) #输出结果可以看到，新的Foo类新增了x,y,z属性

　　

函数可以作为一个对象，也有__dict__方法

  def wrap(obj):
      print("装饰器-----")
      obj.x = 1
      obj.y = 3
      obj.z = 5
      return obj
  ​
  @wrap #test = wrap(test)
  def test():
      print("test-----")
  test.x = 10  #test的x属性被重新赋值
  print(test.__dict__) #输出结果可以看到，test作为一个函数也有__dict__方法，
  # 新的test函数新增了x,y,z属性

　　

类的装饰器应用

例子

  class Type:
  ​
      def __init__(self,key,except_type):  #People对象的key,和期望的数据类型
          self.key = key
          self.except_type = except_type
  ​
      def __get__(self, instance, owner):
          return isinstance.__dict__[self.key]
  ​
      def __set__(self, instance, value):
          print("instance---",instance)
          if not isinstance(value,self.except_type):
              print("您输入的类型不是%s"%self.except_type)
              raise TypeError
          instance.__dict__[self.key] = value
  ​
      def __delete__(self, instance):
          isinstance.__dict__.pop(self.key)
  ​
  def deco(**kwargs):
      def wrapper(obj):      #类的装饰器
          for key,val in kwargs.items():
              setattr(obj,key,Type(key,val))  #设置people类对象的每个参数的描述符
          return obj
      return wrapper
  ​
  @deco(name=str,age=int)
  class People:
  ​
      def __init__(self,name,age):
          self.name = name
          self.age = age
  ​
  ​
  p = People("nick",18)
  print(p.__dict__)

　　

二、自定义property

装饰器也可以是一个类，在自定义property中要使用一个类作为装饰器

例子

  class LazyProperty:
  ​
      def __init__(self, func):
          self.func = func
  ​
      def __get__(self, instance, owner):
          print("执行__get__")
          if not instance:  # 如果是用原类.属性来调用，，这时instance（对象）值为None,直接返回描述符对象
              return self
          res = self.func(instance)  # 执行传入的函数属性，并把原对象作为参数传入
          return res
  ​
  ​
  class Room:
  ​
      def __init__(self, name, length, width):
          self.name = name
          self.length = length
          self.width = width
  ​
      @LazyProperty  # 这里相当于执行了area  = LazyProperty(area)，这里的azyProperty(area)其实是非数据描述符，
      # 新的area已经是经过类LazyProperty装饰过的函数地址
      def area(self):
          return self.length * self.width
  ​
  ​
  r = Room("nick", 18, 10)
  print(r.area)  # 执行对象的方法，先在对象的属性字典里寻找，没有则在非数据描述符里寻找，找到非数据描述符里的__get__方法。

　　

实现延迟计算功能，即实现计算一次再次调用不再进行计算

  class LazyProperty:
  ​
      def __init__(self, func):
          self.func = func
  ​
      def __get__(self, instance, owner):
          print("执行__get__")
          if not instance:  # 如果是用原类.属性来调用，，这时instance（对象）值为None,直接返回描述符对象
              return self
          value = self.func(instance)  # 执行传入的函数属性，并把原对象作为参数传入
          setattr(instance,self.func.__name__,value) #将每次调用的函数属性名字和值存入对象的__dict__，
          # self.func.__name__是获取被调用函数属性的名字
          return value
  ​
  ​
  class Room:
  ​
      def __init__(self, name, length, width):
          self.name = name
          self.length = length
          self.width = width
  ​
      @LazyProperty  # 这里相当于执行了area  = LazyProperty(area)，这里的azyProperty(area)其实是非数据描述符，
      # 新的area已经是经过类LazyProperty装饰过的函数地址
      def area(self):
          return self.length * self.width
  ​
  ​
  r = Room("nick", 18, 10)
  print(r.__dict__)
  print(r.area)  # 执行对象的方法，先在对象的属性字典里寻找，没有则在非数据描述符里寻找，找到非数据描述符里的__get__方法。
  print(r.__dict__)

　　

三、property补充

一个静态属性property本质就是实现了get，set，delete三种方法

用语法糖可以实现property的类似属性的设置和删除，与一般的属性设置删除没有区别

  class People:
  ​
      def __init__(self):
          self.study = "8h"
  ​
      @property
      def study(self):
          print("获取study，执行描述符的__get__方法")
          return self.val
          # return self.study  #无线递归
  ​
      @study.setter
      def study(self,value):
          print("执行__set__方法")
          self.val = value
  ​
      @study.deleter
      def study(self):
          print("执行__delete__方法")
          del self.val
  ​
  p = People()
  print(p.study)  #获取对象的study属性 ，self.study实际上是存在self.val里
  p.study = "10h"  #执行property描述符的__set__方法,设置对象的属性，
  print(p.__dict__)
  del p.study  #执行property描述符的__delete_方法，删除对象的属性
  print(p.__dict__)

　　

四、元类

exec()函数

exec：三个参数

参数一：字符串形式的命令

参数二：全局作用域（字典形式），如果不指定，默认就是用全局 globals()

参数三：局部作用域（字典形式），如果不指定，默认就是用局部 locals()

exec会在指定的局部作用域内执行字符串内的代码，除非明确地使用global关键字

例子

  g = {"x":1,"y":2}
  l = {"a":100}
  ​
  exec("""
  global x,y
  x = 10
  y = 100
  z = 100
  """,g,l)   # exec 当成一个函数的执行，需要指定全局作用域和局部作用域
  print(g)  #在输出结果中可以看到x,y的值发生了变化
  print(l) #新增加的作为局部作用域的属性

　　

定义类的两种方式

（1）用class关键字定义类

  定义类的方式一：用class关键字定义
  ​

  class People:
  ​
      country = "china"
      def __init__(self,name):
          self.name = name
  ​
      def talk(self):
          print("在说话")

　　

（2）手动模拟class创建类的过程：将创建类的步骤拆分开，手动去创建

准备工作：

创建类主要分为三部分

　　a 类名

　　b 类的父类

　　c 类体

  class_name = "People"  #设置类名
  class_bases = (object,)  #设置类的父类
  class_body = """
  country = "china"
  def __init__(self,name):
      self.name = name
  ​
  def talk(self):
      print("在说话")
  ​
  """
  class_dic = {}
  exec(class_body,globals(),class_dic) #这样执行一下得到类的名称空间(属性字典)
  print(class_dic)
  People2 = type(class_name,class_bases,class_dic) #用元类创建了类

　　

什么是元类？

在python中，一切皆对象，一般的类也是一个类的对象，即这种起源、开始的类就称作元类。

用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类（元类可以简称为类的类），内置的元类为type。

元类的参数

元类实例化创建一般的类有三个参数

1、类名class_name="xxx"

2、基类们class_bases=(object,),要继承的父类名，用元组

3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的，就是类的属性字典

调用type时会依次传入以上三个参数

例子

  class Foo: #一般的用class 关键字创建的类
      pass
  ​
  f = Foo()
  print(Foo)
  print(Foo.__dict__)
  ​
  t = type("FFo",(object,),{})  #由元类创造出来的一般类
  print(t)
  print(t.__dict__)

　　

输出结果

  <class '__main__.Foo'>
  {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
  <class '__main__.FFo'>
  {'__module__': '__main__', '__dict__': <attribute '__dict__' of 'FFo' objects>, '__weakref__': <attribute '__weakref__' of 'FFo' objects>, '__doc__': None}
  ​

　　

元类创建类也可以添加属性和方法

例子2

  class Foo:
      x = 1
      def __init__(self,name):
          self.name = name
  ​
  ​
  f = Foo("nick")
  print(Foo)
  print(Foo.__dict__)
  ​
  ​
  def __init(self,name):
      self.name = name
  ​
  t = type("FFo",(object,),{"__init__":__init,"x":1}) #可以直接在属性字典里为创建的类添加属性和方法
  print(t)
  print(t.__dict__)
  t=T("nick")
  print(t.__dict__)

　　

输出结果

  <class '__main__.Foo'>
  {'__module__': '__main__', 'x': 1, '__init__': <function Foo.__init__ at 0x00665DB0>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}
  <class '__main__.FFo'>
  {'__init__': <function __init at 0x00665DF8>, 'x': 1, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'FFo' objects>, '__weakref__': <attribute '__weakref__' of 'FFo' objects>, '__doc__': None}
  {'name': 'nick'}

　　

自定义元类

一个类没有声明自己的元类，默认它的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类

例子1

  class MyType(type):
  ​
      def __init__(self,class_name,class_bases,class_dic):
          print("类名",class_name)
          print("基类",class_bases)
          print("类字典",class_dic)
          super().__init__(class_name,class_bases,class_dic)
  ​
  ​
  class People(object,metaclass=MyType):  #这里metaclass = MyType就执行MyType("People",(ovject,),{}),
      # 然后自动实例化调用MyType的__init__方法
      def __init__(self,name,age):
          self.name = name
          self.age = age
  ​
      def talk(self):
          print("在说话。。。")
  ​
  p = People("nick",18)
  print(p.__dict__)

　　

输出结果

  类名 People
  基类 (<class 'object'>,)
  类字典 {'__module__': '__main__', '__qualname__': 'People', '__init__': <function People.__init__ at 0x00625DF8>, 'talk': <function People.talk at 0x00625DB0>}
  {'name': 'nick', 'age': 18}
  ​

　　

自定义元类控制类的创建

例子1

对新建的类名的要求

  class MyMeta(type):
  ​
      def __init__(self,class_name,class_bases,class_dic):
          if not class_name.istitle():   #判断产生的类的首字母是不是大写
              raise TypeError("类的首字母不是大写")
          super().__init__(class_name,class_bases,class_dic)
  ​
  class people(metaclass=MyMeta): #程序运行到这里会直接报错
  ​
      def __init__(self,name,age):
          self.name = name
          self.age = age
  ​
      def talk(self):
          print("在说话")

　　

例子2

要求新建的类必须要有注释

  class MyMeta(type):
  ​
      def __init__(self,class_name,class_bases,class_dic):
          print(class_dic["__doc__"],bool(class_dic["__doc__"]))
          if  not class_dic["__doc__"].strip() or "__doc__" not in class_dic :  #判断新建类没有注释或者注释是空的
              raise TypeError("新建类没有注释")
  ​
          super().__init__(class_name,class_bases,class_dic)
  ​
  class people(metaclass=MyMeta): #程序运行到这里会直接报错
      """
      """
      def __init__(self,name,age):
          self.name = name
          self.age = age
  ​
      def talk(self):
          print("在说话")

　　

自定义元类控制类的实例化过程

自定义元类创建的类的对象实例化过程

例子

  class MyType(type):
  ​
      def __init__(self,class_name,class_bases,class_dic):
          print("类名",class_name)
          print("基类",class_bases)
          print("类字典",class_dic)
          super().__init__(class_name,class_bases,class_dic)
  ​
      def __call__(self, *args, **kwargs):
          print("self----",self)
          obj = object.__new__(self) #创建一个新的对象，这里就是创建People类的对象，一个实例化的过程
          self.__init__(obj,*args,**kwargs) #执行对象的__init__方法，给对象属性字典加属性，这里的self是People类
          return obj
  ​
  class People(object,metaclass=MyType):  #这里metaclass = MyType就执行MyType("People",(ovject,),{}),
      # 然后自动实例化调用MyType的__init__方法，生成一个people类
      def __init__(self,name,age):
          self.name = name
          self.age = age
  ​
      def talk(self):
          print("在说话。。。")
  print("实例化之前")
  p = People("nick",18)  #这里触发了__call__方法，自己的类里没有call方法就找元类，执行元类的call方法
  #执行call方法之后得到新的对象赋值给p，
  print(p.__dict__)
  print(p.name)

　　

- 创建类时，先执行type的__init__。
- 类的实例化时，执行type的__call__，__call__方法的的返回值就是实例化的对象。

__call__内部调用：
- 类.__new__，创建对象
- 类.__init__，对象的初始化

单例模式

单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间

单例模式主要是优化内存，无论你实例化多少次，始终用同一个对象

例子1

如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了

创建单例模式的方式1

  #用类实现单例模式
  ​
  class MySQL():
  ​
      __instance = None   #先定义一个空
  ​
      def __init__(self):
          self.host = "127.0.0.1"
          self.port = "8090"
  ​
      @classmethod
      def singleton(cls):
          if not cls.__instance:  #如果之前没有实例则第一次创建一个实例对象，之后如果有实例则直接返回该实例对象
              obj = cls()
              cls.__instance = obj  #将第一次创建的对象赋值给类属性，方便下次调用
          return cls.__instance
  ​
  obj1 = MySQL.singleton()  #创建新的对象
  obj2 = MySQL.singleton()
  print(obj1 is obj2)

　　

创建单例模式的方式2，用元类创建单例模式

  #第二种方式，用元类实现单例模式
  ​

  class Mymeta(type):
  ​
      def __init__(self,class_name,class_bases,class_dic):
          super().__init__(class_name,class_bases,class_dic)
          self.__instance = None  #这里的self是根据这个元类创建的类，也可以把这个创建的类暂时理解为类的对象
  ​
      def __call__(self, *args, **kwargs):
          if not self.__instance:
              obj = object.__new__(self)   #用__new__方法创建类的对象
              self.__init__(obj,*args, **kwargs)  #运行类的__init__方法，为新建对象的属性字典赋值
              self.__instance = obj   #第一次创建对象时将类（self）的属性重新赋值为刚创建的obj
          return self.__instance
  ​
  ​
  class Mysql(metaclass=Mymeta):
  ​
      def __init__(self):
          self.host = "127.0.0.1"
          self.port = 8090
  ​
  obj3 = Mysql()  # 创建类的对象，调用元类的__call__方法
  obj4 = Mysql()
  print(obj3 is obj4)