day6 装饰器总结

　装饰器：开放封闭原则，为一个函数加上新的功能，不改变原函数，不改变调用方式

def fun2(wtf):
    def fun3():
        print('i am pythoner!!! ')
        wtf（）
    return fun3

@fun2
def fun1():
    print('this is fun1')
fun1()

输出：

i am pythoner!!!
this is fun1

 def fun2(wtf):
     def fun3(*args, **kwargs):
         print('i am pythoner!!! ')
         wtf(*args, **kwargs)
     return fun3     #这里不是fun3（）是因为：return作用在于函数赋值,即让fun3指向fun1的函数内存地址

 @fun2     # @fun2  当于fun1 = fun2(fun1) ，把下面的函数传递到装饰器函数里面，相当于 fun1 = fun2(fun1) = fun3（用return令fun1=fun3）, 后面再执行fun1() , 相当于执行fun3()
 def fun1(arg, arg2):
     print('this is fun1: %s %d' % (arg, arg2))
 fun1('tom', 55)                      #注意此处fun1（）调用的实际是fun3（），而不是原来的fun1（）了   
注意：只要函数应用装饰器，函数就被重新定义，重新定义为：装饰器的内层函数     

def runtime(func):
    def warpper():
        start_time = time.time()
        func()
        end_time = time.time()
        print 'run time is %s' % (end_time-start_time)
    return warpper

@runtime
def test1():
    time.sleep(3)
    print 'in the test1'

test1()

带参数的装饰器举例：

 def outer(func):
     def inner(a, b):
         print('heihei')
         r = func(a, b)    #func即index函数，即inner函数
         return r
     return inner

 @outer                 # index = outer(index) = inner
 def index(a1, a2):
     print('----------')
     return a1 + a2

 print(index(1, 2))

  输出：
 heihei
 ----------
 3

@outer 作用
1. 执行outer函数，将index作为参数传递
2. 将outer的返回值，重新赋值给index
3. 执行index函数时不再是原来的index函数，而是执行装饰器中的inner函数（由装饰器中的return赋值使index=inner）

带N个参数的装饰器：
应用场景：
当一个装饰器装饰多个函数时，而这些函数的参数个数都不相同时。
原理：

 #原理：
 def f1(*args, **kwargs):
     print(args)
     print(kwargs)

 f1(1, 2, 3, 4, M1='')
 输出：
 (1, 2, 3, 4)
 {'M1': ''}

 dic = {'a': 2, 'b': 23333}
 tup = (1, 2, 3)
 f1(*tup, **dic)

 输出：
 (1, 2, 3)
 {'a': 2, 'b': 23333}

举例：

 def outer(func):
     def inner(*args, **kwargs):
         print('into inner')
         print('the arg is :', *args, **kwargs)
         r = func(*args, **kwargs)
         return r
     return inner

 @outer                 # index = outer(index) = inner
 def index(a1, a2):
     print('----------')
     return a1 + a2

 print(index(1, 2))

 @outer                  # f1 = outer(f1) = inner
 def f1(a1):
     print('++++++++++++++++++++++++++')
     return a1 * a1
 print(f1(2))

 #输出：
 into inner
 the arg is : 1 2
 ----------
 3
 into inner
 the arg is : 2
 ++++++++++++++++++++++++++
 4

多个装饰器装饰同一个函数：

 def outer(func):　　　　　　　　　　　　　　　　　#func等同于outer2中的inner2
     def inner(*args, **kwargs):
         print('first decorate-------------')
         print('the arg is :', *args, **kwargs)
         r = func(*args, **kwargs)　　　　　　　#func等于outer2中的inner2，r值为inner2中的 return r
         print('first decorate-------------')
         return r　　　　　　　　　　　　　　　　　# r的值最终返回给index
     return inner

 def outer2(func):　　　　　　　　　　　　　　　  #func等于index
     def inner2(*args, **kwargs):　　　　　　　#inner2等同于于outer2+被outer2装饰的index函数
         print('second decorate-----------')
         r = func(*args, **kwargs)　　　　　　 #func等于index，r值为index的return a1 + a2
         print('second decorate------------')
         return r　　　　　　　　　　　　　　　　　#r为inner2的返回值，返回给outer中的func函数
     return inner2

 @outer         # 　　　　 outer(inner2) = inner， 作用：将outer2装饰的index，即inner2当作参数传递到第一个装饰器中outer中
 @outer2　　　　 # index = outer2(index) = inner2
 def index(a1, a2):
     print('ori func----------')
     return a1 + a2

 print(index(1, 2))

 输出：
 first decorate-------------
 the arg is : 1 2
 second decorate-----------
 ori func----------
 second decorate------------
 first decorate-------------
 3

执行顺序说明：
当运行index（1， 2）时，
1.执行第一个装饰器outer中的inner函数
2.由1步中的inner函数中的func函数，执行outer2中的inner2函数
3.执行outer2中inner2中的func函数，即执行最初需要装饰的index函数
4.index的返回值返回给它的调用者，即inner2中的func函数
5。inner2的返回值返回给它的调用者，即inner中的func函数
6.将r返回给index函数

https://segmentfault.com/a/1190000007837364

def decorator_b(func):

    print ('Get in decorator_b') #
    def inner_b(*args, **kwargs):
        print ('Get in inner_b') #
        return func(*args, **kwargs)
    return inner_b

def decorator_a(func):

    print ('Get in decorator_a') #
    def inner_a(*args, **kwargs):
        print ('Get in inner_a') #
        return func(*args, **kwargs)
    return inner_a

@decorator_b
@decorator_a
def f(x):
    print ('Get in f')           #
    return x * 2

f # 分步骤来，这里很重要。这里会先后打印出Get in decorator_a 和Get in decorator_b

1、输入函数名f，意味着将函数f作为参数，传入装饰器a和b。 1.5、但是并未调用函数f(x)，也就是f(x)函数并不会执行，因为没有传入参数。重点也就在这，函数和函数调用是不一样的。 2、f首先传入装饰器a，也就是装饰器a函数获得参数被调用，那么就执行打印，并同时返回函数inner_a。 2.5、当然，此时函数inner_a也没有被调用。因为同样没有参数传入。 3、inner_a传入装饰器b，也就是装饰器b函数获得参数被调用，那么也执行打印，并同时返回函数inner_b。 4、现在就是返回函数inner_b>inner_a>f
f(1) # 然后输入这段代码，会先后打印出Get in inner_b和Get in inner_a，以及Get in f

5、此时函数f获得参数1，即函数被调用，由于上面步骤4中最后返回函数是inner_b，那么最先调用最外层的函数，print先行，也就是先打印Get in inner_b，再返回inner_a函数； 6、进而调用inner_a函数，print先行，也就是先打印Get in inner_a，再返回f(1)函数； 7、最后调用f(1)函数，print先行，也就是先打印Get in f，再返回2。 8、这样顺序就理顺了，哈哈，我这么理解的。

装饰器由下到上依次立马执行，之后我们调用的f已经是被装饰器执行了之后的f了，此时是由上到下返回去依次调用。整个过程有点像先上楼梯（装饰过程），再下楼梯（调用函数）

在实际应用的场景中，当我们采用上面的方式写了两个装饰方法比如先验证有没有登录 @login_required ， 再验证权限够不够时 @permision_allowed 时，我们采用下面的顺序来装饰函数:

@login_required
@permision_allowed
def f()
  # Do something
  return

小结：执行装饰器函数的顺序是由下到上（由内到外），调用f（被装饰的函数）是由上到下

对于装饰器来说，在这里程序从上到下执行，开始记录装饰器1-3，然后读到了函数的时候，装饰器开始装饰，把函数的引用传入装饰器中，从装饰器3开始往上装饰，所以这时候开始执行装饰器3的初始化，并把装饰完的函数当做一个新的函数，再次把新的引用传入到装饰器2，接着装饰器2进行初始化,再次把新的函数的引用传入到装饰器1进行装饰，这时候装饰器1的初始化开始，并开始执行，从而接下来的执行顺序为1-3执行装饰的内容，最后再执行本来的函数，达到一个对原有函数增加功能和特性的要求。
装饰器：从程序开始的顺序，从上到下读取----》从下到上装饰----》从上到下执行
https://www.cnblogs.com/wf-skylark/p/9310448.html

def a(func):
    print 'Get in decorator_a'
    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        print "in a, args ", args
        print "in a, kwargs ", kwargs
        kwargs.update({"params": ""})
        return func(*args, **kwargs)
    return inner_a

def b(func):
    print 'Get in decorator_b'
    def inner_b(*args, **kwargs):
        print 'Get in inner_b'
        print "in b, args ", args
        print "in b, kwargs ", kwargs
        return func(*args, **kwargs)
    return inner_b

@b
@a
def f(x, params):
    print 'Get in f'
    print "params: ", params
    return x * 2

f(*(1, ))

# 执行步骤： 执行f(*(1, ))，调用装饰器a(即执行a函数：a(f)), a返回一个inner_a （inner_a = a(f)），执行f(*(1, ))等价于inner_a(*(1, ))
# 调用装饰器b，并把inner_a(*(1, ))传入b中，inner_a = inner_b ,inner_a(*(1, ))即执行inner_b(*(1, )),
# inner_b执行后return并执行inner_a(*(1, ))，最后在inner_a中return并执行f(*(1, ))

#结果：
Get in decorator_a
Get in decorator_b
Get in inner_b
in b, args  (1,)
in b, kwargs  {}
Get in inner_a
in a, args  (1,)
in a, kwargs  {}
Get in f
params:  1234

示例：

def decorator_a(func):
    # print func.func_name
    print 'in a'
    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        return func(*args, **kwargs)
    return inner_a

def decorator_b(func):
    # print func.func_name
    print 'in b'
    def inner_b(*args, **kwargs):
        print 'Get in inner_b'
        return func(*args, **kwargs)
    return inner_b

@decorator_b            # 相当于decorator_b包裹了decorator_a，decorator_a包裹了f（x） ,decorator_a包裹了f（x）等同于 inner_a,同理，decorator_b包裹的函数等于inner_b
@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

print f(1)          # 相当于执行f(1) = decorator_b(decorator_a(f(1))) = inner_b(1)
# 调用顺序：有内到外,先由f（1）传入装饰器decorator_a,打印“in a”, 返回inner_a,
# 执行顺序，先执行decorator_b中的inner_b函数，再执行decorator_a中的inner_a。

https://zhuanlan.zhihu.com/p/26889350

自身带参数的装饰器

例1：

 user_list=[
     {'name':'alex','passwd':''},
     {'name':'linhaifeng','passwd':''},
     {'name':'wupeiqi','passwd':''},
     {'name':'yuanhao','passwd':''},
 ]
 current_dic={'username':None,'login':False}

 def auth(auth_type='filedb'):
     def auth_func(func):
         def wrapper(*args,**kwargs):
             print('认证类型是',auth_type)
             if auth_type == 'filedb':
                 if current_dic['username'] and current_dic['login']:
                     res = func(*args, **kwargs)
                     return res
                 username=input('用户名：').strip()
                 passwd=input('密码：').strip()
                 for user_dic in user_list:
                     if username == user_dic['name'] and passwd == user_dic['passwd']:
                         current_dic['username']=username
                         current_dic['login']=True
                         res = func(*args, **kwargs)
                         return res
                 else:
                     print('用户名或者密码错误')
             elif auth_type == 'ldap':
                 print('鬼才特么会玩')
                 res = func(*args, **kwargs)
                 return res
             else:
                 print('鬼才知道你用的什么认证方式')
                 res = func(*args, **kwargs)
                 return res

         return wrapper
     return auth_func

 @auth(auth_type='filedb') #auth_func=auth(auth_type='filedb')-->@auth_func 附加了一个auth_type  --->index=auth_func(index)
 def index():
     print('欢迎来到京东主页')

 @auth(auth_type='ldap')
 def home(name):
     print('欢迎回家%s' %name)
 #
 @auth(auth_type='sssssss')
 def shopping_car(name):
     print('%s的购物车里有［%s,%s,%s］' %(name,'奶茶','妹妹','娃娃'))

 # print('before-->',current_dic)
 # index()
 # print('after--->',current_dic)
 # home('产品经理')
 shopping_car('产品经理')

例2：

 # !/usr/bin/env python
 # coding:utf-8

 def before(request, kargs):
     print('before')

 def after(request, kargs):
     print('after')

 def Filter(before_func, after_func):
     def outer(main_func):
         def wrapper(request, kargs):

             before_result = before_func(request, kargs)
             if before_result:
                 return before_result

             main_result = main_func(request, kargs)
             if main_result:
                 return main_result

             after_result = after_func(request, kargs)
             if after_result:
                 return after_result

         return wrapper

     return outer

 # outer = Filter(before, after) ---> 相当于@outer附带参数（before, after） 相当于执行 ==> index = outer(index)
 @Filter(before, after)
 def index(request, kargs):
     print('index')

 index(1,2)

 # 带参数的装饰器：利用装饰器的最外层函数传参

装饰器------------自己的理解（持续更新）

 def fun2(wtf):
     def fun3():
         print('i am pythoner!!! ')
         wtf（）
     return fun3

 @fun2
 def fun1():
     print('this is fun1')
 fun1()

 输出：
 i am pythoner!!!
 this is fun1

 fun2只是个桥梁：
 0.把要装饰的函数接收进来，嵌套进包含新功能的函数（这个函数同时包含原函数功能）
 1.让fun1和fun3内存地址相同

 目的：装饰后在fun1()执行前后再执行一些其他的动作

 def outer(func):                                                                          #
     def inner(a, b):                                                                      # 2  a:1 b:2
         print('heihei')                                                                   #
         r = func(a, b)    # func即index函数，即inner函数                                  # 4
         return r         # 如果index有返回值，这里要加上return返回index的返回值        # 7
     return inner         # 作用：让index和inner内存地址相同

 @outer                 # index = outer(index) = inner
 def index(a1, a2):
     print('----------')                                                                    #
     return a1 + a2                                                                         #

 print(index(1, 2))             # 偷梁换柱，相当于直接执行包含原函数功能的函数inner(1, 2)             # 1

def write_log(func):
    def wrapper(a, b):
        print 'log --------------'
        return func(a, b)

    return wrapper

# @write_log
def bar(a,b):
    return a + b

print write_log(bar)(1, 3)
#  write_log(bar)        等于 wrapper
#  write_log(bar)(1, 3)  等于 wrapper(1, 3)

#输出：
log --------------
4

def public(f):
    """"
    Use a decorator to avoid retyping function/class names.
    Based on an idea by Duncan Booth:
    http://groups.google.com/group/comp.lang.python/msg/11cbb03e09611b8a
    Improved via a suggestion by Dave Angel:
    http://groups.google.com/group/comp.lang.python/msg/3d400fb22d8a42e1
    """
    # all = sys.modules[f.__module__].__dict__.setdefault('__all__', [])
    # if f.__name__ not in all:  # Prevent duplicates if run from an IDE.
    #     all.append(f.__name__)
    print('new feature ---')
    # return '1123'
    return f

# public(public)  # Emulate decorating ourself

# @public # public(str_fsize)(10000)
def str_fsize(sz):
    """
    Formats file size as string (i.e., 1.2 Mb)
    """
    if sz < 1024:
        return '%.1f bytes' % sz
    sz /= 1024.0
    if sz < 1024:
        return '%.1f KB' % sz
    sz /= 1024.0
    if sz < 1024:
        return '%.1f MB' % sz
    sz /= 1024.0
    if sz < 1024:
        return '%.1f GB' % sz
    sz /= 1024.0
    return '%.1f TB' % sz

a = public(str_fsize)(1000000)
print(a)

# a = str_fsize(1000000)
# print(a)

新的理解：

如果只在函数执行前加某些功能，装饰器可以简化：

import time

def decorator(sss):
    print("begin to run xxx")

    return sss

@decorator
def fun(a):
    time.sleep(1)
    print(a)

fun(3)  # 相当于在执行decorator(fun)(3) => return fun => fun(3) （扒皮，脱壳）
# decorator(fun)(3) # 注意：decorator(fun)和fun完全等价,内存地址相同

# begin to run xxx #

def public(f):
    """"
    Use a decorator to avoid retyping function/class names.
    Based on an idea by Duncan Booth:
    http://groups.google.com/group/comp.lang.python/msg/11cbb03e09611b8a
    Improved via a suggestion by Dave Angel:
    http://groups.google.com/group/comp.lang.python/msg/3d400fb22d8a42e1
    """
    # all = sys.modules[f.__module__].__dict__.setdefault('__all__', [])
    # if f.__name__ not in all:  # Prevent duplicates if run from an IDE.
    #     all.append(f.__name__)
    def inner(a):
        print('new feature1 ---')    # 要添加的新功能
        val = f(a)
        print('new feature2 ---')  # 要添加的新功能
        return val      # 原函数有返回值这里必须返回
    # return '1123'
    return inner

# public(public)  # Emulate decorating ourself

@public # public(str_fsize)(10000)
def str_fsize(sz):
    """
    Formats file size as string (i.e., 1.2 Mb)
    """
    if sz < 1024:
        return '%.1f bytes' % sz
    sz /= 1024.0
    if sz < 1024:
        return '%.1f KB' % sz
    sz /= 1024.0
    if sz < 1024:
        return '%.1f MB' % sz
    sz /= 1024.0
    if sz < 1024:
        return '%.1f GB' % sz
    sz /= 1024.0
    return '%.1f TB' % sz

a = str_fsize(1000000000000000)
print(a)

原函数执行前后都加功能

装饰器含参：

import time

def decorator(sss):
    print('aaa', sss)
    def outer(aaa):
        print('aaa', sss)
        def inner(s):
            print("begin to run xxx")
            aaa(s)
            print("run completed")
        return inner
    return outer

@decorator(123)
def fun(a):
    time.sleep(1)
    print(a)

fun(3)

#输出：

aaa 123
aaa 123
begin to run xxx
3
run completed