闭包函数,无参装饰器,叠加多个装饰器,有参装饰器

一.闭包函数

闭包函数=函数嵌套定义+函数对象+名称空间与作用域

闭包函数

1.闭:指的是该函数是定义在一个函数内部的函数
2.包:指的是该函数访问了一个来自于外层函数的变量

为函数体传参:

方案一:直接使用参数的形式传递

def wrapper(x):
	print(x)

wrapper(111)
wrapper(222)

方案二:把函数体想要的参数包给它

def outter(x):
	# x = 111
	def wrapper():  # wrapper = 闭包函数的内存地址
		print(x)
	return wrapper  # 一定不要加括号
	# return 闭包函数的内存地址

f1 = outter(111)  # f = 闭包函数的内存地址
f2 = outter(222)  # f = 闭包函数的内存地址

二.装饰器

1.什么是装饰器

器:工具
装饰:为被装饰者添加额外的功能

2.为何要有装饰器

软件一旦上线运行之后,就应该遵循开放封闭原则

1.开放指的是对扩展新功能开放
2.封闭指的是对修改源代码封闭

定义装饰器的目的:

定义装饰器就是为了在遵循1和2的前提下来为其他函数添加新功能的

❀:
不修改被装饰对象指的是定义与调用都不能修改
所以下述行为都违反了开放封闭原则

1.修改被装饰对象定义时的源代码
2.修改被装饰对象的调用方式

3.如何用装饰器?

(1)无参装饰器

1.被装饰对象index如下:

import time

def index(x,y):
	time.sleep(1)
	print('index==>',x,y)

index(1,2)

2.为index添加新功能

2.1 方案1:直接修改源代码为被装饰对象index添加新功能
问题:修改了源代码

import time

def index(x,y):
	start_time=time.time()
	time.sleep(1)
	print('index===>',x,y)
	stop_time=time.time()
	print('run time is: %s'%(stop_time-start_time))

index(1,2)

2.2 方案2:找到所有调用index的位置,然后添加代码
问题:需要写好多段重复代码

import time

def index(x,y):
	time.sleep(1)
	print('index===>',x,y)

start_time=time.time()
index(1,2)
stop_time=time.time()
print('run time is :%s'%(stop_time-start_time))

2.3 方案3:把装饰功能写到一个函数内
问题:装饰功能被写死了,只能用来装饰index函数了

import time

def index(x,y):
	time.sleep(1)
	print('index===>',x,y)

def wrapper():
	start_time = time.time()
	index(1,2)
	stop_time = time.time()
	print('run time is :%s'%(stop_time-start_time))

wrapper()

2.4 方案4:把wrapper函数内的index修改为参数的形式
问题:直接为wrapper函数传参的方案不行,因为原函数的调用是在全局调用index(1,2),而现在的调用统一都变成了wrapper(index),这修改了被装饰对象的调用方式

import time

def index(x,y):
	time.sleep(1)
	print('====>',x,y)

def wrapper(func):
	start_time=time.time()
	func(1,2)
	stop_time=time.time()
	print('run time is :%s'%(stop_time-start_time))

wrapper(index)

2.5 方案5:基于闭包函数把wrapper函数想要的参数包给它,然后基于函数对象把闭包函数wrapper返回到全局,赋值给原函数名
问题:把index伪装成了wrapper,但伪装的不够像:参数的传递与原函数不一致

import time

def index(x,y):
	time.sleep(1)
	print('===>',x,y)

def outter(func):
	# func=index
	def wrapper():
		start_time=time.time()
		func(1,2)
		stop_time=time.time()
		print('run time is:%s'%(stop_time-start_time))
	return wrapper

index=outter(index)

index()

2.6 方案6:在方案5的基础上基于＊args,＊＊kwargs把wrapper的参数伪装成跟被装饰函数一模一样
问题:返回值与原函数不一致

import time

def index(x,y):
	time.sleep(1)
	print('index===>',x,y)

def home(name):
	time.sleep(0.5)
	print('welcome %s to home page'%name)
	return 123

def outter(func):
	# func=index
	def wrapper(*args,**kwargs):
		start_time=time.time()
		func(*args,**kwargs)
		stop_time=time.time()
		print('run time is:%s'%(stop_time-start_time))
	return wrapper

index=outter(index)
home=outter(home)

index(1,2)
res=home('egon')
print(res)  # 此时的返回值是wrapper的

2.7 方案7:在方案6的基础上把wrapper函数的返回值与被装饰函数保持一致
问题:装饰器的使用不够简洁

import time
from functools import wraps

def timmer(func):
	# func=index
	@wraps(func)
	def wrapper(*args,**kwargs):
		start_time=time.time()
		res=func(*args,**kwargs)
		stop_time=time.time()
		print('run time is:%s'%(stop_time-start_time))
		return res
	return wrapper

def index(x,y):
	time.sleep(1)
	print('index===>',x,y)

def home(name):
	'home的文档注释'
	time.sleep(0.5)
	print('welcome %s to home page'%name)
	return 123

index=timmer(index)
home=timmer(home)

res=index(1,2)
print(res)

res=home('egon')
print(res)

# print(home.__name__)
# print(home.__doc__)
# help(home)

2.8 方案8:在方案7的基础上使用装饰器的语法糖@符号,让装饰器的使用变得简洁

import time
from functools import wraps

def timmer(func):
	# func = index
	@wraps(func)
	def wrapper(*args,**kwargs):
		start_time=time.time()
		res=func(*args,**kwargs)
		stop_time=time.time()
		print('run time is:%s'%(stop_time-start_time))
		return res
	return wrapper

@timmer  # index=timmer(index)
def index(x,y):
	time.sleep(1)
	print('index===>',x,y)

@timmer  # home=timmer(home)
def home(name):
	'home的文档注释'
	time.sleep(0.5)
	print('welcome %s to home page'%name)
	return 123
res=index(1,2)
res1=home('egon')

无参装饰器的模板

def outter(func):
	def wrapper(*args,**kwargs):
		res=func(*args,**kwargs)
		return res
	return wrapper 

(2)叠加多个装饰器

加载顺序:自下而上
执行顺序:自上而下运行内层的wrapper函数

def deco1(func1):  # func1=wrapper2的内存地址
	def wrapper1(*args,**kwargs):
		print('wrapper1===>')
		res1=func1(*args,**kwargs)
		return res1
	return wrapper1

def deco2(func2):  # func2 = wrapper3的内存地址
	def wrapper2(*args,**kwargs):
		print('wrapper2===>')
		res2 = func2(*args, **kwargs)
		return res2

	return wrapper2

def deco3(func3):  # func3=最原始的那个被装饰函数的内存地址
	def wrapper3(*args, **kwargs):
		print('wrapper3===>')
		res3 = func3(*args, **kwargs)
		return res3
	return wrapper3

		# index=wrapper1的内存地址
@deco1  # deco1(deco2=>wrapper2的内存地址)=>wrapper1的内存地址
@deco2  # deco2(deco3=>wrapper3的内存地址)=>wrapper2的内存地址
@deco3  # deco3(index=>最原始的那个被装饰函数的内存地址)=>wrapper3的内存地址
def index(x,y):
	print('index=>',x,y)
	
index(1,2)

'''
wrapper1====>
wrapper2====>
wrapper3====>
index=>1,2
'''

案例:

import time

def deco1(func1):
	def wrapper1(*args,**kwargs):
		start_time=time.time()
		res1=func1(*args,**kwargs)
		stop_time=time.time()
		print(stop_time-start_time)
		return res1
	return wrapper1

def deco2(func2):
	def wrapper2(*args,**kwargs):
		name=input('username>>>: ').strip()
		pwd=input('password>>>: ').strip()
		if name == 'juanfu' and pwd == '123':
			print('login successful')
			res2 = func2(*args,**kwargs)
			return res2
		else:
			print('username or password error')
	return wrapper2

@deco2
@deco1
def index(x,y):
	time.sleep(1)
	print('index=>',x,y)

index(1,2)

(3)有参装饰器

def outter(engine='file'):
	def deco2(func2):
		def wrapper2(*args,**kwargs):
			name=input('username>>>: ').strip()
			pwd=input('password>>>: ').strip()

			if engine == 'file':
				print('基于file的认证')
				if name == 'juanfu' and pwd == '123':
					print('login successful')
					res2=func2(*args,**kwargs)
					return res2
				else:
					print('username or password error')
			elif engine == 'mysql':
				print('基于mysql的认证')
			elif engine == 'ldap':
				print('基于ldap的认证')
			else:
				print('未知的engine')

		return wrapper2
	return deco2
@outter(engine='mysql')  # @deco2  # index=deco2(index)
def index(x,y):
	print('index=>',x,y)

index(1,2)  # index=>wrapper

有参装饰器的模板

def outter2(x,y,z,a,b):
	def outter1(func):
		def wrapper(*args,**kwargs):
			res=func(*args,**kwargs)
			return res
		return wrapper 
	return outter1