python学习笔记,python学习装饰

python 3.x 学习笔记5 (装饰器),python3.x

1.装饰器

实质是函数,(装饰其余函数)正是为任何函数增添附加成效

python学习笔记,python学习装饰。原则:

澳门葡京备用网址,  1)不可能修改被点缀的函数的源代码
  2)不能修改棉被服装饰的函数的调用方式

2.贯彻装饰器知识储备

  1)函数即“变量”

  2)高阶函数

    a.把贰个函数当作实参传给另二个函数(能够完成不退换被点缀函数的源代码的事态下为其增加效果)

    b.重返值中包涵函数名)(不改造函数的调用情势)

  3)嵌套函数

3.高阶函数+嵌套函数=》装饰器

 

4.发端装饰器

import time
def timer(func):              #timer(test1)  func = test1
    def deco():
        start_time = time.time()
        func()                #run test1
        stop_time = time.time()
        print('the func run time is %s'%(stop_time-start_time))
    return deco

@timer              #test1 = timer(test1)
def test1():
    time.sleep(3)
    print('in the test1')
test1()

5.功力相比较完善的装饰器

 

user,passwd = 'hsj','1234'

def auth(auth_type):
    print('auth func:',auth_type)
    def outer_wrapper(func):
        def wrapper(*args, **kwargs):
            print('wrapper:',*args, **kwargs)
            if auth_type == 'local':
                username = input('Username:').strip()
                password = input('Password:').strip()

                if username == user and password == passwd:
                    print('\033[32;1mUser has pass authentication\033[0m')
                    return func(*args, **kwargs)  # from home         #函数wrapper的返回值
                else:
                    exit('\033[31;1mInvalid username or password\033[0m')
            elif auth_type =='ldap':
                print('ldappppppppp')
        return wrapper
    return outer_wrapper

def index():
    print('welcome to index psge')
@auth(auth_type='local')      # 加了括号相当于运行了outer_wraper所以会执行里面内容   # home = auth(home)
def home():
    print('welcome to home page')
    return 'from home'         #这里有返回值在装饰器里也应该有个返回值不然是print()不出来的
@auth(auth_type='ldap')
def bbs():
    print('welcome to bbs page')

index()
print(home())
bbs()

 

3.x 学习笔记5 (装饰器),python3.x
1.装饰器 : 本质是函数,(装饰其余函数)便是为别的函数增加附加作用原则: 1)无法改改棉被服装…

Python 3 学习笔记(六)—-装饰器,python学习笔记

一、定义

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

二、装饰器原则

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

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

三、达成装饰器的画龙点睛知识

1.函数就是变量

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

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

2.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)

2.2重回值中含有函数名

 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() #返回的内存地址加上()就可以执行

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

六、装饰器的利用实例

固然为网页添Garden陆验证

 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 学习笔记(六)—-装饰器,python学习笔记
一、定义 装饰器本质是函数,装饰别的函数,正是为其余函数增加附加作用二、装饰器原…

python学习之装饰器,python学习装饰

装饰器概念&实际选拔干货,装饰概念

定义:

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

原则:

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

  达成装饰器知识储备:

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

  • 嵌套函数

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

实际行使办法:

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

代码内部参谋消息加了自身对装修使用的理解

定义:
本质是函数(装饰别的函数),是为另外函数增添附加成效 原则:
无法改改被点缀函数的源代…

装饰器前奏1

概念:本质是函数,用来点缀其余函数,正是为别的函数来增添附加作用

标准:1、不能够改改被修饰函数的源代码以及调用情势

装饰器前奏2

 

import time
def timer(func):
        def warpper(*args,**kwargs):
            start_time = time.time()
            func()
            stop_time = time.time()
            print("the func run time is %s" % (stop_time-start_time))
        return warpper
@timer  #timer(test1)
def test1():
    time.sleep(3)
    print("in the test1")
test1()

完结装饰器只是储备:

1、函数即”变量“

2、高阶函数

3、嵌套函数

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

 

 

装饰器前奏3

装饰器前奏4

 

装饰器前奏1
概念:本质是函数,用来装点其余函数,就是为任何函数来增加附加功能原则:1、不可能修…

相关文章

发表评论

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

*
*
Website