闭包函数 装饰器 有参装饰器

闭包函数

1 内部函数

2 包含对外部作用域而非全局作用域的引用
闭包函数的特点:
      自带作用域
       延迟计算

 #闭包函数定义 1 def timmer(func):
 2     def inner(*args,**kwargs):
 3         re = func(*args,**kwargs)
 4         return re
 5     return inner
 6
 7 index():
 8     print("hello")
 9
10 index = timmer(index) #index == inner
11 index()    #index()==inner()

装饰器

一:开放封闭原则,对扩展是开放的,对修改是封闭的

二:装饰器,装饰器本质可以任意可调用对象,被装饰的对象也可以是任意
可调用对象,
装饰器的功能是:
在不修改被装饰对象源代码以及调用方式的前提下为期添加新功能

原则:
    1.不修改源代码
    2.不修改调用方法
    目标:添加新功能

 1 #装饰器的语法:在被装饰对象的正上方的单独一行,@装饰器名字
 2 import time
 3 import random
 4 #装饰器
 5 def timmer(func):
 6      def wrapper():
 7          start_time = time.time()  #添加的计算时间功能
 8          func()
 9          stop_time=time.time()
10          print(‘run time is %s‘ %(stop_time-start_time))
11      return wrapper
12
13 #被装饰函数
14 @timmer      #index=timmer(index)  #index == wrapper
15 def index():  #index()== wrapper()
16      time.sleep(random.randrange(1,5))
17      print(‘welecome to index page‘)
18
19 @timmer      #home=timmer(home)  #home==wrapper
20 def home():
21      time.sleep(random.randrange(1,3))
22      print(‘welecome to HOME page‘)
23
24 index() #wrapper()
25 home() #wrapper()

有参装饰器

 1 def deco(auth_type=‘file‘):
 2     def auth(func):
 3         def wrapper(*args,**kwargs):
 4             if auth_type == ‘file‘:
 5                 print(‘文件的认证方式‘)
 6             elif auth_type == ‘ldap‘:
 7                 print(‘ldap认证方式‘)
 8             elif auth_type == ‘mysql‘:
 9                 print(‘mysql认证方式‘)
10             else:
11                 print(‘不知到的认证方式‘)
12         return wrapper
13     return auth
14
15 @deco(auth_type=‘abc‘) #@auth #index=auth(index)
16 def index():
17     print(‘welecome to index‘)
18
19 @deco(auth_type=‘ldap‘)
20 def home(name):
21     print(‘welecome %s to home page‘ %name)
22
23 index()
24
25 home(‘egon‘)
时间: 2024-10-11 04:16:49

闭包函数 装饰器 有参装饰器的相关文章

装饰器的补充(叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数)

1,叠加多个装饰器 1),加载顺序(outter函数的调用顺序):自下而上 2),执行顺序(wrapper函数的执行顺序):自上而下 def outter1(func1): #func1=wrapper2的内存地址 print('加载了outter1') def wrapper1(*args,**kwargs): print('执行了wrapper1') res1=func1(*args,**kwargs) return res1 return wrapper1 def outter2(func

Python:装饰器之有参装饰器

from inspect import signature def f(a,b,c=1):pass sig = signature(f) sig.parameters 实现一个对被装饰的函数的参数类型检查的装饰器 from inspect import signature def typeassert(*ty_args,**ty_kargs): def decorator(func): #func ->a,b #d = {'a':int,'b':str} sig = signature(func

Python记录11:叠加多个装饰器+有参装饰器

# import time## def timmer(func): #func=最原始的index的内存地址# def wrapper(*args,**kwargs):# start=time.time()# res=func(*args,**kwargs)# stop=time.time()# print(stop - start)# return res# return wrapper## @timmer #index=timmer(index) #index=wrapper的内存地址# d

四 闭包函数、装饰器

一 闭包函数 一.什么是闭包 二.闭包的意义与应用 二 装饰器 一.为何要用装饰器 二.什么是装饰器 三.装饰器的作用 四.装饰器的语法 五.装饰器补充:wraps 一 闭包函数 一.什么是闭包 1 #内部函数包含对外部作用域而非全局作用域的引用 2 3 #提示:之前我们都是通过参数将外部的值传给函数,闭包提供了另外一种思路 4 5 def counter(): 6 n=0 7 def incr(): 8 nonlocal n 9 x=n 10 n+=1 11 return x 12 retur

闭包函数,装饰器

闭包函数 什么是闭包 闭包:闭是封闭(函数内部函数),包是包含(该内部函数对外部作用域而非全局作用域的变量的引用).闭包指的是:函数内部函数对外部作用域而非全局作用域的引用. 两种为函数传值的方式 为函数传参的方式一:使用参数的形式 def func(x): print(x) func(1) 为函数传参的方式二:包给函数 def outter(x): def inner(): print(x) return inner f = outter(1) f() f() f() # 查看闭包的元素 pr

闭包函数、无参装饰器2

一.闭包函数 闭包函数:函数内部定义函数,成为内部函数.该内部函数包含对外部作用域,而不是对全局作用域名字的引用,那么该内部函数成为闭包函数. name='alex' #定义全局变量name='alex' def func(): name='egon' #定义局部变量name='egon' def bar(): print(name) return bar #返回bar函数名 b=func() #执行func()结果为bar的函数名 相当于b=bar name='haha' #重新定义全局变量n

闭包函数、无参装饰器

闭包函数:函数内部定义函数,成为内部函数.该内部函数包含对外部作用域,而不是对全局作用域名字的引用,那么该内部函数成为闭包函数. name='alex' #定义全局变量name='alex' def func(): name='egon' #定义局部变量name='egon' def bar(): print(name) return bar #返回bar函数名 b=func() #执行func()结果为bar的函数名 相当于b=bar name='haha' #重新定义全局变量name='ha

Python基础(7)闭包函数、装饰器

一.闭包函数 闭包函数:1.函数内部定义函数,成为内部函数, 2.改内部函数包含对外部作用域,而不是对全局作用域名字的引用 那么该内部函数成为闭包函数 #最简单的无参闭包函数 def func1() name='ares' def func2() print(name) #有参和返回值的闭包函数 def timmer(func): def wrapper(*args,**kwargs): start_time = time.time() res=func(*args,**kwargs) stop

8 闭包函数和装饰器

闭包函数定义 #内部函数包含对外部作用域而非全局作用域的引用 #提示:之前我们都是通过参数将外部的值传给函数,闭包提供了另外一种思路,包起来喽,包起呦,包起来哇 def counter(): n=0 def incr(): nonlocal n x=n n+=1 return x return incr c=counter() print(c()) print(c()) print(c()) print(c.__closure__[0].cell_contents) #查看闭包的元素 应用场景