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

时间:2024-08-03 16:36:38

一、类的装饰器

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

例子

  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)