装饰器

------装饰器
"""首先在Python中的函数是可以看做一个特殊变量的.而装饰器是建立
在闭包的前提上的.
闭包就是将函数当做参数传入另一个函数,两个函数的嵌套,外部函数返回
内部函数的引用
.装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何
代码变动的前提下增
加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需
求的场景，
比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰
器是解决这类问
题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无
关的雷同代码并继续
重用。
 装饰器原则：

不改变源代码      - 因为函数可能在其他地方各种调用，一改动全身

-- 不改变原函数调用顺序           - 源代码有自己的逻辑处理
装饰器又叫做语法糖

闭包简介------------------------------
如果在一个函数的内部定义了另一个函数，外部的我们叫他外函数，
内部的我们叫他内函数。
闭包： 
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，
并且外函数的
返回值是内函数的引用。这样就构成了一个闭包。
"""
 #闭包函数的实例
 2 # outer是外部函数 a和b都是外函数的临时变量
 3 def outer( a ):
 4     b = 10
 5     # inner是内函数
 6     def inner():
 7         #在内函数中 用到了外函数的临时变量
 8         print(a+b)
 9     # 外函数的返回值是内函数的引用
10     return inner
11 
12 if __name__ == '__main__':
13     # 在这里我们调用外函数传入参数5
14     #此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
15     # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
16     demo = outer(5)
17     # 我们调用内部函数，看一看内部函数是不是能使用外部函数的临时变量
18     # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
19     demo() # 15

在python3中，可以用nonlocal 关键字声明 一个变量， 表示这个变量不是局部变量空间
的变量，需要向上一层变量空间找这个变量。内函数修改闭包变量的方法通过nonlocal关键字。
1 #修改闭包变量的实例
 2 # outer是外部函数 a和b都是外函数的临时变量
 3 def outer( a ):
 4     b = 10  # a和b都是闭包变量
 5     c = [a] #这里对应修改闭包变量的方法2
 6     # inner是内函数
 7     def inner():
 8         #内函数中想修改闭包变量
 9         # 方法1 nonlocal关键字声明
10         nonlocal  b
11         b+=1
12         # 方法二，把闭包变量修改成可变数据类型 比如列表
13         c[0] += 1
14         print(c[0])
15         print(b)
16     # 外函数的返回值是内函数的引用
17     return inner
18 
19 if __name__ == '__main__':
20 
21     demo = outer(5)
22     demo() # 6  11
还有一点需要注意：使用闭包的过程中，一旦外函数被调用一次返回了内函数的引用，虽然每次调用内函数，是开启一个函数执行过后消亡，但是闭包变量实际上只有一份，每次开启内函数都在使用同一份闭包变量

上代码！

def outer(x):
    def inner(y):
        nonlocal x
        print('x', x)
        x+=y

        print('y',y)
        return x
    return inner
a=outer(10)
print(a(1))
print(a(3))

# x 10
# y 1
# 11
# x 11
# y 3
# 14

两次分别打印出11和14，由此可见，每次调用inner的时候，使用的闭包变量x实际上是同一个。

 
#------------------------------------装饰器
import time
def test():
  time.sleep(2)
  print("test is runing")

def jq(func):
    start=time.time()
    print('start',start)
    func()
    end=time.time()
    print('end',end)
    print(end-start)
jq(test)

# start 1552095544.027457
# # test is runing
# # end 1552095546.028318
# # 2.0008609294891357


import time
def test():
  time.sleep(2)
  print("test is runing")

def jq(func):
    start=time.time()
    func()
    end=time.time()
    print(end-start)
    return func
test=jq(test)
test()

# test is runing
# 2.0007572174072266
# test is runing

import time
def jq(func): # 这里的参数就是test
    def wrapper():
        print(456)
        start=time.time()
        func()  #现在去执行函数test,执行完test,接着往下执行
        end=time.time()
        print(end-start)
        print('执行结束')
    return wrapper # 执行函数wrapper
@jq #在执行函数test之前先执行函数jq
def test():
  print(123)
  time.sleep(2)
  print("test is runing")
test()

# 456
# 123
# test is runing
# 2.0007762908935547
# 执行结束




# @myzsq #添加装饰器
# def test(a,b):
#     print("are you ok")
#     return a*b
#
# print(test(4,8))

一、无参装饰器
def myzsq(func):#func为装饰器绑定的方法
    def tt():
        print("开始")
        cc=func()#调用test函数
        print("结束")
    return tt    
@myzsq #添加装饰器
def test():
    print("are you ok")
test()

# 开始
# are you ok
# 结束

二、带参装饰器
def myzsq(func):
    def tt(x,y):#传入test的方法参数
        print("开始")
        cc=func(x,y)
        print("结束")
        return cc
    return tt
@myzsq
def test(a,b):
    print("are you ok",a,b)
    return a+b+1

print(test(3,4))

# 开始
# are you ok 3 4
# 结束
# 8

(3)装饰器即可装饰带参函数也可以装饰不带参函数

def myzsq(func):
    def tt(*args,**kwargs):#传入test的方法参数
        print("开始")
        cc=func(*args,**kwargs)
        print("结束")
        return cc
    return tt
    
@myzsq #添加装饰器
def test(a):
    print("are you ok",a)
    return 33

print(test(10))

# 开始
# are you ok 10
# 结束
# 33


"""
1、如果想让装饰器不修改被装饰函数的返回值，我们需要在装饰器中接受被装饰函数的返回值
并Return即可。

(2) 如果希望对被装饰函数进行分类处理，我们可以在绑定装饰器时传入一个参数用于
对被装饰函数进行分类，但是这样我们需要在装饰器中在套一层函数，在第一层接收装
饰器传递的参数，在第二层函数中接收被装饰函数。

(3) 如果希望装饰器既能装饰带参的函数也可以修饰不带参的函数，我们只需要在装饰
器中接收参数时，把参数定义为非固定参数即可。

"""
(4)装饰器的高级使用

以上的装饰器已经可以满足基本需求了，但是他们第一存在一个问题，被装饰的函数的返回结果会被修改。

这里我们模拟一个登陆装饰器，装饰器需要对不同的被装饰函数使用不同的登陆方法，并且是返回值不被修改。

user, password = 'db', '12345' 
   
# 当装饰器也需要参入参数时我们需要给装饰器再加一层函数，  
# 此时装饰器接受到的方法需要进入第二层函数进行接受，  
# 第一层需要接受装饰器自己的参数  
    
def login(login_type):  
    def outer_wrapper(func):  
        def wrapper(*agr1, **kwargs):  
            usernameInput = input("UserName:").strip()  
            passwordInput = input("Password:").strip()  
            if login_type == "local":  
                if user == usernameInput and password == passwordInput:  
                    print("login successful")  
                    res = func(*agr1, **kwargs)  # 接受返回结果  
                    return res  
                else:  
                    print("login fail")  
            elif login_type == "ldap":  
                print("远程登录")  
        return wrapper  
    return outer_wrapper  
   
   
def index():  
    print("welcome to index page")  
  
  
@login(login_type="local")  # 对装饰分类  
def home():  
    print("welcome to home page")  
    return "from home" 
  
  
@login(login_type="ldap")  # 对装饰分类  
def blog():  
    print("welcome to blog page")  
   
   
index()  
print(home())  
blog()


test = timer(test)
显然有些麻烦，Python提供了一种语法糖，即：
@timer
这两句是等价的，只要在函数前加上这句，就可以实现装饰作用。 

#--------------例如改变装饰函数的返回结果
def myzsq(func):
    def tt(*arg,**kwargs):#传入test的方法参数
        print("开始")
        cc=func(*arg,**kwargs)
        print(arg) #(4,8)
        print("结束")
        return arg[0]+arg[1] #将相乘的返回结果改为相加的返回结果
    return tt
@myzsq #添加装饰器
def test(a,b):
    print("are you ok")
    return a*b

print(test(4,8))