####################################
'''
# 1.装饰器 decorator
> 在不改变原有函数代码,且保持原函数调用方法不变的情况下,给原函数增加新的功能(或者给类增加属性和方法)
> 核心思想:用一个函数(或者类)去装饰一个旧函数(或者类),造出一个新函数(或者新类)
> 应用场景:引入日志,函数执行时间的统计,执行函数前的准备工作,执行函数后的处理工作,权限校验,缓存等场景中
> 语法规则:在原有的函数上加上 @符,装饰器会把下面的函数当作参数传递到装饰器中,@符又被成为 语法糖
@outer
def func():
pass
'''
# 1。 装饰器的原型
### 利用闭包,把函数当作参数传递,并且在函数内去调用传递进来的函数,并返回一个函数
# 定义外函数,接收一个函数作为参数
def outer(f):
# 定义内函数,并且在内函数中调用了外函数的参数
def inner():
print('我是外函数中的内函数1')
f()
print('我是外函数中的内函数2')
return inner
# 定义普通函数
# def old():
# print('我是一个普通的函数')
#
# # old() # 作为普通函数直接调用
# old = outer(old) # outer返回了inner函数,赋值给了old
# old() # 此时再调用old函数时,等同于调用了 inner 函数
# 改为装饰器用法
@outer # 此处使用的@outer的语法就是把outer作为了装饰器,等同于 old = outer(old)
def old():
print('我是一个普通的函数')
old() # old函数经过 outer装饰器进行了装饰,代码和调用方法不变,但是函数的功能发送了改变
####################################
# 2.装饰器应用场景-统计函数执行时间
import time
# 定义一个统计函数执行时间的 装饰器
def runtime(f):
def inner():
start = time.perf_counter()
f()
end = time.perf_counter() - start
print(f'函数的调用执行时间为:{end}')
return inner
# 定义一个函数
@runtime
def func():
for i in range(5):
print(i,end=" ")
time.sleep(1)
func()
####################################
# 3.装饰器的嵌套
# 1。普通装饰器的定义
# 定义装饰器
# 外函数
def outer(func):
#内函数
def inner():
print('找到妹子,成功拿到微信。。。3')
func() # 在内函数中调用外函数中的行参-函数
print('约妹子,看一场午夜电影。。。4')
# 在外函数中返回内函数
return inner
# 使用一个装饰器
# @outer
# def love():
# print('跟妹子畅谈人生和理想。。。')
#
# love() # == inner()
# 2。在定义一个装饰器
def kuozhan(f):
def kzinner():
print('扩展1')
f()
print('扩展2')
return kzinner
# 装饰器的嵌套 先执行下面的,再执行上面的。
@kuozhan # 2。再使用上面的 kuozhan 装饰器,装饰 上一次返回的 inner 函数,又返回了 kzinner 函数
@outer # 1。先使用离得近的 outer装饰器 装饰love函数,返回了一个 inner函数
def love():
print('跟妹子畅谈人生和理想。。。5')
love()
'''
1 3 5 4 2
1 先使用离得近的 outer装饰器 装饰love函数,返回了一个 inner函数
2 再使用上面的 kuozhan 装饰器,装饰 上一次返回的 inner 函数,又返回了 kzinner 函数
最后在调用love函数的时候是怎么执行的
love() == kzinner()
===> 1
===> inner()
===> 3
===> love() ===> 5
===> 4
===> 2
'''
####################################
# 4.对带有参数的函数进行装饰
# 定义装饰器
def outer(func):
# 如果装饰器带有参数的函数,需要在内函数中定义行参,并传递给调用的函数。因为调用原函数等于调用内函数
def inner(var):
print(f'找到{var}妹子,成功拿到微信。。')
func(var)
print(f'约{var}妹子,看一场午夜电影。。')
return inner
# 有参数的函数
@outer
def love(name):
print(f'跟{name}妹子畅谈人生。。。')
love('思思') #love() ==> inner() love('思思') ===> inner('思思')
####################################
# 5.装饰带有多参数的函数
def outer(func):
def inner(who,name,*args,**kwargs):
print('约到妹子,聊微信。。。')
func(who,name,*args,**kwargs)
print('天色一晚,怎么办?')
return inner
# 定义多参数的 函数
@outer
def love(who,name,*args,**kwargs):
print(f'{who}跟{name}畅谈人生。。。')
print('完事去吃了好多美食',args)
print('看了一场电影',kwargs)
love('三多','思思','火锅','辣条','7块钱的麻辣烫',mov='唐山大地震')
'''
love() ==> inner()
love(...) ==> inner(...)
inner(...) ==> love(...)
'''
####################################
# 6.带有参数的装饰器
# 如果你的装饰器需要有参数,那么给当前的装饰器套一个壳,用于接收装饰器的参数
def kuozhan(var):
def outer(func):
def inner1():
print('妹子给了你微信')
func()
def inner2():
print('妹子给介绍了个大妈')
func()
# 装饰器壳的参数,可以用于在函数内去做流程控制
if var == 1:
return inner1
else:
return inner2
return outer
@kuozhan(2) # kuozhan(var) ==> outer() ==> outer(love) ==> inner()
def love():
print('谈谈人生。。。')
love()
####################################
# 7.类装饰器装饰函数
class Outer():
# 魔术方法:当把该类的对象当作函数调用时,自动触发 obj()
def __call__(self,func):
self.func = func # 把传进来的函数作为对象的成员方法
return self.inner # 返回一个函数
# 在定义的需要返回的新方法中 去进行装饰和处理
def inner(self,who):
print('拿到妹子的微信。。。')
self.func(who)
print('看一场午夜电影。。。')
@Outer() # Outer() ==> obj @obj==>obj(love) ==> __call__(love) ==> inner()
def love(who):
print(f'{who}和妹子谈谈人生和理想。。。')
love('川哥') # inner('川哥')
print(love) # 此时的 love就是属于Outer类这个对象中的inner方法
####################################
# 8.用类方法装饰函数
class Outer():
def newinner(func):
Outer.func = func # 把传递进来的函数定义为类方法
return Outer.inner # 同时返回一个新的类方法
def inner():
print('拿到妹子微信')
Outer.func()
print('看一场午夜电影')
@Outer.newinner # Outer.newinner(love) ==> Outer.inner
def love():
print('和妹子谈谈人生喝喝茶。。。')
love() # love() ==> Outer.inner()
####################################
# 9.
'''
还有一种装饰器,是专门装饰类的。也就是在类的定义的前面使用@装饰器这种语法
@装饰器
class Demo():
pass
装饰器给函数进行装饰,目的是不改变函数调用和代码的情况下给原函数增加了新的功能。
装饰器给类进行装饰,目的是不改变类的定义和调用的情况下给类增加新的成员(属性或方法)。
'''
# 使用函数装饰器,给类进行装饰,增加新的属性和方法
# 定义函数,接收一个类。返回修改后的类
def kuozhan(cls):
def func2():
print('我是在装饰器中追加的新方法,func2')
cls.func2 = func2 # 把刚才定义的方法赋值给 类
cls.name = '我是在装饰器中追加的新属性 name'
#返回时,把追加类新成员的 类 返回去
return cls
@kuozhan # kuozhan(Demo) ==> cls ==> Demo
class Demo():
def func():
print('我是Demo类中定义的func方法')
Demo.func() # 此时在调用的Demo类是通过装饰器,更新过的Demo类
Demo.func2()
print(Demo.name)
####################################
# 10.使用类装饰器装饰类
class KuoZhan():
def __call__(self, cls):
# 把接收的类,赋值给当前对象,作为一个属性
self.cls = cls
# 返回一个函数
return self.newfunc
def newfunc(self):
self.cls.name = '我是在类装饰器中追加的新属性 name'
self.cls.func2 = self.func2
# 返回传递进来的类的实例化结果,obj
return self.cls()
def func2(self):
print('我是在类装饰器中追加的新方法 func2')
@KuoZhan() # KuoZhan() ==> obj ==> @obj(Demo) ==> __call__(Demo) ==> newfunc
class Demo():
def func(self):
print('我是Demo类中定义的func方法')
obj = Demo() # Demo() ==> newfunc() ==> obj
obj.func()
obj.func2()
print(obj.name)
# 思考: 此时的 obj这个对象,是哪个类的对象。Demo还是KuoZhan
print(obj) # 此时的obj依然是Demo类的实例化对象,只不过经过装饰后,增加了新的属性和方法
####################################
Python入门学习笔记——21.装饰器语法与应用
最新推荐文章于 2024-06-20 15:44:55 发布
本文详细介绍了Python中的装饰器语法,包括定义装饰器、使用@符号应用装饰器以及装饰器在函数和类上的应用。通过实例展示了装饰器如何增强函数功能,如日志记录、性能测试等,帮助初学者深入理解装饰器这一核心概念。
摘要由CSDN通过智能技术生成