python进阶04 装饰器、描述器、常用内置装饰器
一、装饰器
作用：能够给现有的函数增加功能
如何给一个现有的函数增加执行计数的功能
首先用类来添加新功能
def fun(): #首先我们定义一个函数
print('func running') #看到封装，我们首先想到的是函数
class MyFunc():
def __init__(self,f): #把函数和变量封装在一起
self.f=f
self.count=0 def run(self): #间接的调用了封装的函数
self.count+=1
return self.f() mf=MyFunc(func)#实例化
mf.run()#输出func running
print(mf.count) #输出1
mf.run()#输出func running
print(mf.count)#输出2
mf.run()#输出func running
print(mf.count)#输出3
#在python中，有一个__call__函数可以让这个对象可以调用
class MyFunc():
def __init__(self,f): #把函数和变量封装在一起
self.f=f
self.count=0 def __call__(self): #让这个对象可以调用
self.count+=1
return self.f() mf =MyFunc(func)
mf() #当你调用一个实例的时候，其实就是调用它的__call__方法，虽然mf()是一个实例，但也同时也是一个函数
func() ——>func.__call__() mf() #func running
print(mf.count)#
mf() #func running
print(mf.count)#
mf() #func running
print(mf.count)#
mf() #func running
print(mf.count)#
def func():
print('func running') class MyFunc():
def __init__(self,f): #把函数和变量封装在一起
self.f=f
self.count=0 def __call__(self,*arg,**kwarg): #为保证所有参数都能够传入，让这个对象可以调用
self.count+=1
return self.f(*arg,**kwarg)#调用封装进来的函数，并拿到他的返回值 func = MyFunc(func) #这便是装饰，右边的实例由于有call方法，他便是一个函数右边的实例封装了原函数和计数器；然后又将这个实例赋值个func函数，让func不指向原函数，指向一个新的函数；看上去功能和原来一样，其实已经增加了功能
#关于装饰，函数名还是原来的函数名，指向的却是新的函数，这个新的函数会调用原来的函数，也可以做些别的事情
也可以用函数来封装
#思路：装饰----一个新的函数，看上去功能和原来一样，其实已经增加了功能，增加了计数器 #首先先定义一个函数：
def my_func(f):
return f() #我在调用my_func的时候，其实已经调用了f() #然后就是添加功能，添加计数器
def my_func(f):
def new_func():
new_func.count+=1 #计数器加1
return f() #调用并返回f的内容
new_func.count=0
return new_func func=my_func(func)#装饰
#装饰，不过是指向了一个新的函数，只不过这个函数除了调用原来的函数以外，还会做点别的事 def my_func(func):
def new_func():
new_func.count+=1#把计数器加1
return func() #返回并调用原来的函数func
new_func.count=0
return new_func#只是返回，不调用 @my_func #在定义的同时便装饰了
def mimc(a,b):
return a-b
@MyFunc #在定义的同时便装饰了
def add(a,b):
return a+b #总结：将新的功能和老的功能都绑定在一个新的函数里面
二、描述器
管理一个类属性的访问，修改，删减
class MyAttribute:#将来他的实例会是一个类的属性（注意！是类的属性，不是实例的属性）
def __get__(self,instance,owner):#instance是实例，owner是类
print('get',instance,owner)
def __set__(self,instance,value):#value是赋的值
print('set',instance,value)
def __delete__(self,instance,value):
print('delete',instance)
def __str__(self):
print('') #重点来了
class MyClass:
attr=MyAttribute() #实例化 mc=MyClass()
print(mc.attr) #如果没有get set delete三种，就会输出字符串表示str的内容；如果够get，get就会被调用，就会替代字符串表示；set就是修改，delete就是删除
#基于描述器的装饰器 Property
class Property:
def __init__(self,fget=None):
self.fget=fget def __get__(self,obj,objtype=None):
if obj is None:return selg
if self.fget is None: raise AttributeError('无法访问这个属性')
returnself.fget(obj) #这个东西不用理解
#他是一个装饰器，也是一个描述器
#例子：是否匿名
class Person:
def __init__(self,name):
self.name=name
self.is_anonymous=False #是否是匿名 @Property
def get_name(self):#方法，所以若要拿到name的，肯定需要调用，如果不想调用，在上面加个@Property这个装饰器即可
if not self.is_anonymous:
return self.name
else:
return 'anonymous' p= Person('Tuple')
p.is_anonymous=False
print(p.get_name)#这样就可以直接取值，不需要print(p.get_name())
三、常用内置装饰器
property
class Person:
def __init__(self,name):
self.name=name @property
def name(self):
print('通过property来获取name')
if hasattr(self,'name'):
return self.name
else:
raise AttributeError('没有name这个属性') @name.setter #控制赋值
def name(self,value):
print('通过property来设置name')
self.name=value @name.deleter
def name(self):
print('通过property来删除name')
del self.name #property 就是把一个方法变成一个属性的样子
静态方法和类方法
class A:
@staticmethod #静态方法能够让类和实例，看他都是一个普通函数
def meth():
print('xxx') a=A()
a.meth() #实例调用的时候——>A.meth(a),两者看起来都是函数 class A:
@classmethod #类方法：第一个参数，回传进去的都是类，不是实例
def meth(cls): #cls表示类
print('xxx') a=A()
a.meth() #实例调用的时候——>A.meth(a) #正常情况下我们都应该传实例，但是以后做项目的时候会用到类方法
#以后做数据库接入的时候，有一个ORM，在查询的时候，可以是由类方法，来简化你的代码
四、关于一些内容的补充
1、关于运行后进入交互环境的说明
#IDLE执行以后，会进入shell模式（交互模式），此时程序还没有执行完，等待你输入下一段代码
2、函数返回值的理解
#区分func和func()
#func是一个函数对象
#func()分为两步：1、执行这个函数里面的内容。2、用return出来的返回值，替代这个调用
def func():
print('xxx')
return 1 print(func()) #相当于print(1) def other():#定义函数，是不会执行这个函数的
print('other')
return 10 def func():
print('xxx')
return other() print(func())#输出 xxx other 10
#文件--第一个执行的是func()
#func--先打印出func
#func--调用other
#other--先打印出other
#other--返回值10
#func--在返回other()的值
#文件--print要输出func()的值
3、装饰后必须赋值变量
def myfunc(func):
def wrapper(*args,**kwargs):
wrapper.count+=1
return func(*args,**kwargs)
wrapper.count=0
return wrapper def func():
print('xxx') f1=myfunc(func)
f2=myfunc(func)
print(f1 is f2) #两次装饰，都是得到了加强版的函数，但是两次装饰的函数时两个，因此他们拥有两个计数器，所以装饰完必须要有一个变量接收它，装饰以后必须赋变量
4、装饰器
#装饰，首先是加功能；碧玺，原来的是得做，还得加东西
#原来的函数，功能一定要有；其次应该还有一个新的功能和她深度的绑定在一起 #思考：我们装饰完以后，得到的必须是一个加强版的函数（新的函数） def func():
print('func')
return 1
#如果我们要模仿这个函数，我们得实现什么
#1、你需要打印出func 2、你也要返回出1 #假如，我要写一个装饰器，这个装饰器什么功能都不加，只是单纯模仿
def myfunc(f):
return f f2=myfunc(func)#f2和func是一个函数
#希望，我返回的不是原来的那个函数，而是新函数，但是做的事和原来一样 def myfunc(f):
def wrapper():#这个是定义，不是调用。定义完成以后会得到一个函数对象wrapper
wrapper.count+=1#把我自己这个函数里面的count+1
return f() #就是运行f，并且把它的返回值给返回出来（因为我要返回f(),就是返回f里面的return）
wrapper.count=0 #由于是一个对象，所以可以加.count
return wrapper#我返回的是wrapper这个函数对象（不是wrapper的调用）
def myfunc(f)
def wrapper():#这个封装的新函数：1、增加计数器 2、调用原函数，并返回其返回值
wrapper.count+=1
return f()
wrapper.count=0
return wrapper 入门版：
def myfunc(f):
count=0
def wrapper():
nonlocal count #作用域的问题，全局变量和局部变量
count+=1
return f()
return wrapper