装潢概念,实际利用干货

定义:

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

定义:

  • 实为是函数(装饰别的函数),是为其余函数添加附加成效

装潢概念,实际利用干货。原则:

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

  达成装饰器知识储备:

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

  • 嵌套函数

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

实际采纳方法:

 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

装饰器


 

一、定义

一.装饰器:本质是函数

二.作用:用来装点其余函数,为别的函数添加附加作用

澳门葡京备用网址, 

二、原则

一.不能够修改棉被服装饰函数的源代码

2.无法改改被点缀函数的调用情势

 

三、完结装饰器

1.函数 即 变量 的概念

2.高阶函数

三.嵌套函数

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

 

四、函数 即 变量

一、函数和变量的类比

x = 1
print(id(x))

def test():
 pass

print(test)

#输出

1842348496
<function test at 0x0000020DBA24D2F0>

  在上例中大家定义了3个变量 “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中内部存款和储蓄器的表现情势

    澳门葡京备用网址 1

  大家把绿方块当作是内部存款和储蓄器,每一个小方块正是变量恐怕函数在内部存款和储蓄器在那之中的地点。而变量名(x)大概函数名(test),大家能够形象的将他们比喻门牌号。当供给调用变量大概函数的时候,我们如若引用他们的门牌号就可以找到她们的内部存款和储蓄器地址并再次来到。只是函数的运维须要加(),如
test()。

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

 

5、高阶函数

满足下列原则之一便是高阶函数

一.把3个函数名当作实参传给此外三个函数

贰.再次来到值中包罗函数名

一)函数名作为参数

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一,同时也定义了一个高阶函数test2。我们把test1函数名当作参数传入test第22中学,能够兑现如此几个效果,为本来的test1函数添加了1个计量运转时刻的功用。那有点像装饰器了,可是有少数相符,正是下边包车型客车高阶函数test贰变动了函数的调用格局。

  不过我们兑现了在不修改棉被服装饰函数的基础上,添加了新作用。

 

贰)重返值中有函数名

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贰(test1)
赋予给了test1,再度调用test1函数。大家可以直观的看来test一函数的调用情势在此例中从未变动。不过也并从未增加新成效,而那就须要运用到嵌套函数了。

 

6、嵌套函数

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

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

 

三)使用嵌套函数为被修饰函数添加新职能 

  在高阶函数第2例中,咱们达成了不改动原函数的调用格局。而急需添加新作用的话,就需要修饰内容存在在重回值中,即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就足以被引述,甚至直接给予给
test①。那样大家就能够一直运转 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()

  

                                                                     
  

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

  • 实为是函数(装饰其余函数),是为别的函数添加附加功用

 

原则:

 

  • 无法改改被点缀函数的源代码
  • 无法改改被点缀函数的调用形式

定义:装饰器:本质是函数,(装饰别的函数)正是为其余函数添加附加效率。

 

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

贯彻装饰器知识储备:

   二.无法修改棉被服装饰的函数的调用方式

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

 

  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)

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

注:使用变量实现。

注:重返值是内部存款和储蓄器地址,加括号()执行内部存储器地址。

注:一.足以创建变量来兑现。

  二.得以平昔在函数上写入“@变量名”等于变量达成。

 

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

一.变量创设后会放入到内存中,函数也是变量。

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

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

四.python是解释性语言。

 

相关文章

发表评论

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

*
*
Website