定义:

装饰器概念&实际运用干货,装饰概念

定义:

  • 真相是函数(装饰其余函数),是为其余函数增添附加成效

原则:

  • 无法改改被点缀函数的源代码
  • 不能够改改棉被服装饰函数的调用方式

  达成装饰器知识储备:

  • 函数及“变量”
  • 高阶函数

  • 嵌套函数

装饰器 = 高阶函数 + 嵌套函数

骨子里运用办法:

 1 #装饰器试验
 2 
 3 import time
 4 
 5 #装饰器
 6 def adron(fun):
 7     print('传入待装饰函数的内存地址:%s'%fun)
 8     def ad_x(*args,**kwargs):
 9         start_time = time.time()
10         #fun+()的方式来执行被装饰函数
11         fun(*args,**kwargs)
12         stop_time = time.time()
13         print('visit world use time:%s'%(stop_time-start_time))
14     return ad_x
15 
16 #被装饰函数
17 @adron # @adron = adron(tet),将tet内存地址传当做参数传入装饰器函数
18 def tet():
19     time.sleep(3)
20     print('hello world!')
21 #这里tet由装饰器装饰后,内存地址是ad_x的内存地址
22 tet()
23 
24 @adron
25 def jsq(n,s):
26     for i in range(n):
27         time.sleep(s)
28         print(i)
29 
30 jsq(5,0.1)

装点概念,实际应用干货。高阶装饰器:

 1 #大装饰器
 2 
 3 name = 'sober'
 4 password = '123'
 5 
 6 def badn(action):
 7     print("登录方式:%s"%action)
 8     #fun 由 @badn装饰器传入
 9     def bt_badn(fun):
10         print('查看fun值:%s'%fun)
11         def adron(*args,**kwargs):
12             if action == 'local':
13                 name_value = input('Please user name:')
14                 password_value = input('Please Password:')
15                 if name == name_value and password == password_value:
16                     #fun 会执行被装饰函数,因为传入的fun是被执行函数的内存地址
17                     ret_value = fun(*args,**kwargs)
18                     print('装饰器内执行被装饰函数后返回前')
19                     #返回被装饰函数执行后的结果
20                     return ret_value
21                 else:
22                     print('username or password error')
23             elif action == 'ldap':
24                 print('ldap is unrealized')
25         #return返回函数名称,是在返回函数内存地址,使用内存地址+()的方式调用函数
26         return adron
27     return  bt_badn
28 
29 
30 def index():
31     print('welcome !hello world!')
32 
33 @badn(action='local') # @badn = badn(home) 如果要传入参数则需要在装饰器函数内再嵌套一层
34 def home():
35     print('welcome home path')
36     return 'a'
37 
38 @badn(action='ldap')
39 def ldap():
40     print('welcome ldap enter')
41 
42 index()
43 #这里的执行通过函数内存地址+()执行函数
44 #home()
45 print('显示home返回值:%s'%home())
46 ldap()

注:学习oldboy python自动化运维——装饰器篇笔记

代码内部参考消息加了本身对装修使用的领会

定义:
本质是函数(装饰其余函数),是为别的函数加多附加成效 原则:
不能修改棉被服装饰函数的源代…

一.装饰器的使用

一、定义

  • 真相是函数(装饰其余函数),是为别的函数增添附加功效

 

装饰器本质是函数,装饰其余函数,就是为别的函数增加附加效能

原则:

 

二、装饰器原则

  • 不能够改改棉被服装饰函数的源代码
  • 不可能修改棉被服装饰函数的调用格局

定义:装饰器:本质是函数,(装饰别的函数)正是为别的函数增加附加成效。

一.不可能修改被点缀的函数的源代码

 

原则:一.不能够改改棉被服装饰函数源代码

二.不可能改改被点缀的函数的调用方式

贯彻装饰器知识储备:

   二.不可能修改棉被服装饰的函数的调用方式

金沙注册送58,3、达成装饰器的必需知识

  • 函数及“变量”
  • 高阶函数

 

一.函数正是变量

  1. 把1个函数名当狠抓参传给其余三个函数(不改造被点缀函数,为其增进效果)
  2. 再次回到值中包蕴函数名(不退换函数调用方式)用return重回内部存款和储蓄器地址

落成装饰器知识储备:

 1 # def foo():
 2 #     print("in the foo")
 3 #     bar()    #bar未定义
 4 # foo()
 5 
 6 
 7 # def bar():
 8 #     print("int the bar")
 9 # def foo():
10 #     print("in the foo")
11 #     bar()
12 # foo()
13 
14 
15 # def foo():
16 #     print("in the foo")
17 #     bar()
18 # def bar():
19 #     print("int the bar")
20 # foo()

1 def foo():
2     print("in the foo")
3     bar()
4 foo()
5 def bar():  #在调用后定义不会执行
6     print("int the bar")
  • 嵌套函数

1.函数即“变量”

2.高阶函数(高阶函数的两种表明格局)

装饰器 = 高阶函数 + 嵌套函数

二.高阶函数

2.一把1个函数名当作实参传给其它三个函数(在不修改棉被服装饰函数源代码的处境下为其增加效果)

实质上采纳方法:

  a:把1个函数名当抓好参传给别的贰个函数(不修改棉被服装饰源代码

 1 import time
 2 
 3  def bar():
 4      time.sleep(3)
 5      print("in the bar")
 6 
 7  def test1(func):
 8      start_time = time.time()
 9      func()
10      stop_time = time.time()
11      print("the func run time is %s" %(stop_time-start_time))
12  test1(bar)
 1 #装饰器试验
 2 
 3 import time
 4 
 5 #装饰器
 6 def adron(fun):
 7     print('传入待装饰函数的内存地址:%s'%fun)
 8     def ad_x(*args,**kwargs):
 9         start_time = time.time()
10         #fun+()的方式来执行被装饰函数
11         fun(*args,**kwargs)
12         stop_time = time.time()
13         print('visit world use time:%s'%(stop_time-start_time))
14     return ad_x
15 
16 #被装饰函数
17 @adron # @adron = adron(tet),将tet内存地址传当做参数传入装饰器函数
18 def tet():
19     time.sleep(3)
20     print('hello world!')
21 #这里tet由装饰器装饰后,内存地址是ad_x的内存地址
22 tet()
23 
24 @adron
25 def jsq(n,s):
26     for i in range(n):
27         time.sleep(s)
28         print(i)
29 
30 jsq(5,0.1)

     的动静下为其丰硕效果)。

2.2再次来到值中隐含函数名

高阶装饰器:

  b:再次来到值中含有函数名(不修改函数的调用格局)。

 1 import time
 2 def bar():
 3     time.sleep(3)
 4     print("in the bar")
 5 def test2(func):
 6     print(func)
 7     return func#返回为内存地址
 8 
 9 #print(test2(bar))
10 # t=test2(bar)
11 # t() #run bar
12 bar=test2(bar)
13 bar() #返回的内存地址加上()就可以执行
 1 #大装饰器
 2 
 3 name = 'sober'
 4 password = '123'
 5 
 6 def badn(action):
 7     print("登录方式:%s"%action)
 8     #fun 由 @badn装饰器传入
 9     def bt_badn(fun):
10         print('查看fun值:%s'%fun)
11         def adron(*args,**kwargs):
12             if action == 'local':
13                 name_value = input('Please user name:')
14                 password_value = input('Please Password:')
15                 if name == name_value and password == password_value:
16                     #fun 会执行被装饰函数,因为传入的fun是被执行函数的内存地址
17                     ret_value = fun(*args,**kwargs)
18                     print('装饰器内执行被装饰函数后返回前')
19                     #返回被装饰函数执行后的结果
20                     return ret_value
21                 else:
22                     print('username or password error')
23             elif action == 'ldap':
24                 print('ldap is unrealized')
25         #return返回函数名称,是在返回函数内存地址,使用内存地址+()的方式调用函数
26         return adron
27     return  bt_badn
28 
29 
30 def index():
31     print('welcome !hello world!')
32 
33 @badn(action='local') # @badn = badn(home) 如果要传入参数则需要在装饰器函数内再嵌套一层
34 def home():
35     print('welcome home path')
36     return 'a'
37 
38 @badn(action='ldap')
39 def ldap():
40     print('welcome ldap enter')
41 
42 index()
43 #这里的执行通过函数内存地址+()执行函数
44 #home()
45 print('显示home返回值:%s'%home())
46 ldap()

三.嵌套函数

三.嵌套函数

注:学习oldboy python自动化运营——装饰器篇笔记

注:嵌套函数是壹层下,接着嵌套第壹层。

 1 x=0
 2 def a():
 3     x=1
 4     def b():
 5         x=2
 6         def c():
 7             x=3
 8             print(x)
 9         c()
10     b() #此处如果不执行b(),那么函数相当于什么都没干,因为没有print
11 a()

代码内到场了作者对装修使用的明亮

 

四、装饰器=高阶函数+嵌套函数

 1 x=0
 2 def grandpa():
 3     # x=1
 4     def dad():
 5         x=2
 6         def son():
 7             x=3
 8             print (x)
 9         son()
10     dad()
11 grandpa()
 1 import time
 2 
 3 def timer(func):  #timer(test)  func=test
 4     def deco():
 5         start_time = time.time()
 6         func()   #此处运行被装饰函数test
 7         stop_time = time.time()
 8         print("func run time is %s" %(stop_time-start_time))
 9     return deco  #返回deco的内存地址
10 
11 
12 @timer   #相当于timer=timer(test),装饰器永远放在被装饰的函数前
13 def test():
14     time.sleep(3)
15     print("this is test")
16 
17 test()

高阶函数+嵌套函数=>装饰器

5、假使装饰器的函数中带有参数

 

 1 import time
 2 
 3 def timer(func):
 4     def deco(*args,**kwargs):  #*args,**kwargs代表参数不确定的意思
 5         start_time=time.time()
 6         func(*args,**kwargs)
 7         stop_time=time.time()
 8         print("in the run time is %s" %(stop_time-start_time))
 9     return deco
10 
11 @timer   # test2 = timer(test2) = deco    test2(name) = deco(name)
12 def test2(age,name,job):
13     time.sleep(1)
14     print("test2:",age,name,job)
15 
16 test2(23,"Irlo","seller")
二.装饰器使用进阶

6、装饰器的施用实例

 

如果为网页加多登陆验证

 

 1 user,pasd = "Irlo","12345"
 2 def auth(auth_type):
 3     print("auth func is",auth_type)
 4     def type(func):
 5         def wrapper():
 6             if auth_type == "local":
 7                 username = input("username:").strip()  #strip移除字符串首尾指定的字符(默认为空格)
 8                 password = input("password:").strip()
 9                 if user==username and pasd==password:
10                     print("\033[1;32;1mauthority of account\033[0m") #高亮显示的格式(\033[显示方式;前景色;背景色m)
11                     res=func()  #将结果赋值给一个变量才能在之后调用home有结果
12                     print("after authentication")
13                     return res  #如果不返回,相当于执行完就结束了,没有返回值是一个空值
14                 else:
15                     print(" invalid username or password ")
16             elif auth_type == "ldap":
17                 print("I just know local,fuck off")
18         return wrapper
19     return type
20 
21 def index():
22     print("welcome to index page")
23 
24 @auth(auth_type = "local")
25 def home():
26     print("welcome to home page")
27     return "from home"
28 
29 @auth(auth_type = "ldap")
30 def bbs():
31     print("welcome to bbs page")
32 
33 index()
34 print(home()) #调用home的时候相当于是调用wrapper
35 home()
36 bbs()

创办叁个装饰器,不修改源文件,修章,加多新效能。

 

 1 import time
 2 def timer(func):
 3     def deco():
 4         start_time=time.time()
 5         func()
 6         stop_time=time.time()
 7         print("the func run time is %s" %(stop_time-start_time))
 8     return deco
 9 
10 def test1():
11     time.sleep(2)
12     print("123123")
13 test1 = timer(test1)
14 test1()

1 #执行
2 @time #test1=timer(test1)

注:使用了高阶函数,嵌套函数完成。

注:使用变量达成。

注:重临值是内部存款和储蓄器地址,加括号()实施内部存款和储蓄器地址。

注:一.得以成立变量来贯彻。

  2.方可一贯在函数上写入“@变量名”等于变量落成。

 

注:内部存款和储蓄器变量机制

1.变量成立后会放入到内部存储器中,函数也是变量。

2.变量前面包车型客车值在内部存款和储蓄器中,变量名则是门牌号。

三.当变量门牌号被去除时,内部存款和储蓄器中的值会被限制期限清理掉。

四.python是解释性语言。

 

相关文章

网站地图xml地图