其实利用干货,学习笔记

定义:

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

定义:

  • 本质是函数(装饰其余函数),是为其余函数增加附加功能

原则:

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

  完结装饰器知识储备:

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

  • 嵌套函数

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

实际接纳方法:

 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自动化运行——装饰器篇笔记

其实利用干货,学习笔记。代码内加入了自己对装修使用的敞亮

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

一.装饰器的使用

一、定义

  • 实质是函数(装饰别的函数),是为其它函数增加附加功用

 

装饰器本质是函数,装饰别的函数,正是为其余函数增多附加功用

原则:

 

二、装饰器原则

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

定义:装饰器:本质是函数,(装饰别的函数)便是为别的函数加多附加功用。

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

 

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

二.不能改改被点缀的函数的调用格局

心想事成装饰器知识储备:

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

3、完毕装饰器的画龙点睛知识

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

 

①.函数便是变量

  1. 把3个函数名当抓实参传给别的八个函数(不改造被点缀函数,为其充分效果)
  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.函数即“变量”

二.高阶函数(高阶函数的三种表达格局)

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

贰.高阶函数

二.1把贰个函数名当作实参传给别的1个函数(在不修改棉被服装饰函数源代码的情状下为其增加效果)

实则应用办法:

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

 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.贰重返值中带有函数名

高阶装饰器:

  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自动化运转——装饰器篇笔记

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

 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()

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

伍、假如装饰器的函数中涵盖参数

 

 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")
二.装饰器使用进阶

陆、装饰器的应用实例

 

要是为网页增多登陆验证

 

 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()

创设3个装饰器,不修改源文件,修章,加多新职能。

 

 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.变量创设后会放入到内部存款和储蓄器中,函数也是变量。

贰.变量背后的值在内部存款和储蓄器中,变量名则是门牌号。

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

4.python是解释性语言。

 

网站地图xml地图