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

By admin in 4858.com on 2019年4月7日

定义:

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

定义:

  • 真相是函数(装饰其余函数),是为任何函数添加附加功能

原则:

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

  达成装饰器知识储备:

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

  • 嵌套函数

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

实质上选拔方法:

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

代码内投入了自个儿对装修使用的明白

定义:
本质是函数(装饰别的函数),是为别的函数添加附加功效 原则:
不可能改改被点缀函数的源代…

一.装饰器的使用

装饰器–decorator1,装饰–decorator1

装饰器


 

一、定义

一.装饰器:本质是函数

二.成效:用来装饰别的函数,为别的函数添加附加功效

 

二、原则

1.无法改改棉被服装饰函数的源代码

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

 

叁、完毕装饰器

装饰器概念,实际运用干货。1.函数 即 变量 的概念

二.高阶函数

3.嵌套函数

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

 

四、函数 即 变量

壹、函数和变量的类比

x = 1
print(id(x))

def test():
 pass

print(test)

#输出

1842348496
<function test at 0x0000020DBA24D2F0>

  在上例中大家定义了2个变量 “x” 和三个函数
test(),大家分别打字与印刷出变量和函数在内部存款和储蓄器中的地点。能够见见,print(test) 即
print(“函数名”)的时候,我们能够打印出函数的内部存款和储蓄器地址。

  大家看下边包车型大巴代码:

def test():
 print("in the test.")

f=test
f()

#输出
in the test.

  我们把函数名 test 赋予给 f,然后运维f(),能够看看函数是足以健康运维的,而且就是test函数的运营结果。那么那和下部的代码是否近似:

x = 1
y = x

print(y)

#输出
1

  我们能够做出如下类比,函数名 test 也等于 x ,函数体就一定于 1,而 f
就相当于 y。

 

贰.python中内部存款和储蓄器的表现格局

    4858.com 1

  大家把绿方块当作是内部存款和储蓄器,每1个小方块正是变量或许函数在内部存款和储蓄器个中的地方。而变量名(x)或许函数名(test),大家能够形象的将他们比喻门牌号。当须求调用变量只怕函数的时候,我们假设引用他们的门牌号就足以找到她们的内部存款和储蓄器地址并重临。只是函数的运转供给加(),如
test()。

  既然调用变量其实正是引用变量的内部存款和储蓄器地址,而调用函数名相同能够博得函数体的内部存款和储蓄器地址。我们就足以把函数名当作变量名传给函数,即函数正是变量。而将函数当作参数的函数,也便是高阶函数。

 

伍、高阶函数

知足下列标准之一便是高阶函数

一.把二个函数名当作实参传给其它三个函数

2.重返值中涵盖函数名

一)函数名作为参数

import time

def test1():
 time.sleep(2)
 print("in the test1.")

def test2(func):
 start_time = time.time()
 func()
 stop_time = time.time()
 print("The action time of program is {}".format(stop_time-start_time))

test2(test1)

#输出
in the test1.
The action time of program is 2.0012054443359375

  以上事例中,我们定义了一个函数
test一,同时也定义了2个高阶函数test二。大家把test壹函数名当作参数字传送入test第22中学,能够完结那样1个功能,为原本的test一函数添加了一个计量运维时刻的功效。那有点像装饰器了,然则有某个顺应,就是地方的高阶函数test贰变更了函数的调用格局。

  可是大家完成了在不修改棉被服装饰函数的基础上,添加了新成效。

 

4858.com ,贰)再次来到值中有函数名

def test1():
 time.sleep(2)
 print("in the test1.")

def test2(func):
 print(func)
 return func

test1 = test2(test1)
test1()

#输出
<function test1 at 0x000001E5D853D2F0>
in the test1.

  在上例中,大家最后将高阶函数test二(test一)
赋予给了test1,再度调用test1函数。大家得以直观的收看test壹函数的调用形式在此例中从未改观。不过也并未添加新职能,而这就须求动用到嵌套函数了。

 

6、嵌套函数

在函数体内又另多个函数的完好定义,那正是嵌套函数。

1)定义:

def foo():
 print("in the foo")
 def bar():
  print("in the bar")

 bar()

foo()

只是在函数内容调用函数,就不是嵌套函数,如下:

def test1():
    print("in the test1.")

def test2():
    test1()

 

二)嵌套函数的功用域

有的功能域和全局成效域的拜会顺序

x = 0
def grandpa():
 x = 1
 def dad():
  x = 2
  def son():
   x = 3
   print(x)
  son()
 dad()
grandpa()

#输出
3

 

3)使用嵌套函数为被修饰函数添加新成效 

  在高阶函数第一例中,我们落到实处了不更改原函数的调用方式。而须要添加新职能的话,就须要修饰内容存在在再次来到值中,即return
func 中,我们能够定义2个嵌套函数来落到实处这一个意义。

import time

def timer(func):  # timer(test1) func = test1
 def deco():
  start_time = time.time()
  func()   # run test1()
  stop_time = time.time()
  print("the action time of the program is {}".format(stop_time-start_time))
 return deco   # 返回了deco的内存地址

def test1():
 time.sleep(2)
 print("in the test1.")

test1 = timer(test1)
test1()
# 输出 
in the test1.
the action time of the program is 2.0003786087036133

  我们在timer()内部定义了一个嵌套函数
deco(),那个嵌套函数达成了为被修饰函数添加运作时刻的效应。而timer()函数再次来到了deco()的内部存款和储蓄器地址,那些内部存款和储蓄器地址deco就足以被引述,甚至平昔授予给
test1。那样大家就能够直接运维 test壹(),那样就落实我们的装饰器的机能。

 

七、装饰器 

  python通过在函数定义前添加三个装潢器名和@符号,来达成对函数的包裹 

import time

def timer(func):  # timer(test1) func = test1
 def deco():
  start_time = time.time()
  func()   # run test1()
  stop_time = time.time()
  print("the action time of the program is {}".format(stop_time-start_time))
 return deco   # 返回了deco的内存地址

@timer   # test1 = timer(test1)
def test1():
 time.sleep(2)
 print("in the test1.")

test1()

  

                                                                     
  

装饰器
1、定义 壹.装饰器:本质是函数
二.职能:用来装点别的函数,为其余函数添加附加作用 二、原则…

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

 

原则:

 

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

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

 

原则:一.无法修改棉被服装饰函数源代码

贯彻装饰器知识储备:

   二.无法修改被点缀的函数的调用格局

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

 

  1. 把2个函数名当坚实参传给别的三个函数(不改动棉被服装饰函数,为其增加效果)
  2. 再次回到值中隐含函数名(不改动函数调用方式)用return重返内部存款和储蓄器地址

实现装饰器知识储备:

  • 嵌套函数

1.函数即“变量”

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

二.高阶函数

实质上应用格局:

  a:把一个函数名当加强参传给别的八个函数(不改动棉被服装饰源代码

 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)

     的情景下为其增加效果)。

高阶装饰器:

  b:重返值中包含函数名(不修改函数的调用情势)。

 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 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 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.方可一向在函数上写入“@变量名”等于变量达成。

 

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

一.变量创造后会放入到内部存储器中,函数也是变量。

贰.变量末尾的值在内部存储器中,变量名则是门牌号。

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

四.python是解释性语言。

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有