python装饰器介绍

"""
装饰器
    定义：本质是函数（器：就是函数的意思），功能：装饰其他函数，就是为其他函数添加附加功能

    原则：
        1. 不能修改被装饰的函数的源代码
        2. 不能修改被装饰的函数的调用方式

    实现装饰器知识储备：
        1. 函数即"变量"
        2. 高阶函数
            a: 把一个函数名当做实参传给另一个函数（在不修改被装饰函数源代码的情况下为其添加功能）
            b: 返回值中包含函数名 (不修改函数的调用方式)
        3. 嵌套函数

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

参考链接：http://egon09.blog.51cto.com/9161406/1836763
"""


# 将test1 和 test2 函数添加logging 功能 (未使用使用函数调用)

'''
def logger():
    print ("logging")

def test1():
    pass
    logger()

def test2():
    pass
    logger()

test1()
test2()
'''

# 装饰器示范_1

'''
import time

def timmer(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

@timmer
def test1():
    time.sleep(3)
    print ("this is test1")

test1()
# this is test1
# the func run time is 3.019197702407837

'''

# 函数即"变量"
# 新概念：函数在内存中以变量形式存放
# 匿名函数没有函数名，当运行后内存会被立马回收（def 定义的函数，不会被内存回收，当程序结束后内存地址才会释放）

'''
# eg_v1  
def bar():  # 正常运行
    print ("in the bar")
def foo():
    print ("in the foo")
    bar()
foo()
# in the foo
# in the bar


# eg_v2   # 正常运行
def foo():
    print ("in the foo")
    bar()
def bar():
    print ("in the bar")
foo()
# in the foo
# in the bar


# eg_v3  # 抛出异常
def foo():
    print ("in the foo")
    bar()
foo()
def bar():
    print ("in the bar")
# Traceback (most recent call last):
# in the foo
#   File "E:/pycharm-project/PYTHON自动化课程/第二模块/课堂笔记/装饰器_v1.py", line 92, in <module>
#     foo()
#   File "E:/pycharm-project/PYTHON自动化课程/第二模块/课堂笔记/装饰器_v1.py", line 91, in foo
#     bar()
# NameError: name 'bar' is not defined
'''

# 高阶函数

# eg_v1
'''
def bar():
    print ("in the bar")

def test1(func):
    print (func)
# test1(bar)
# # <function bar at 0x0000024DE92E3E18> bar函数的内存地址
'''

# eg_v2
'''
def bar():
    print ("in the bar")

def test1(func):
    print (func)
    func()     # 2 调用func函数时，也运行了bar函数
test1(bar)     # 1 将bar函数传递给test1
# <function bar at 0x00000216F49D3E18>
# in the bar
'''


# eg_v3  # 装饰器第一步（没有修改源代码，但改变了调用方式）（test1为装饰函数，bar函数为被装饰函数）
'''
import time
def bar():
    time.sleep(2)
    print ("in the bar")

def test1(func):
    start_time = time.time()
    func()
    stop_time = time.time()
    print ("the func run time is %s"%(stop_time - start_time))

test1(bar)
# in the bar
# the func run time is 2.000016689300537
'''

# eg_v4

'''
import time
def bar():
    time.sleep(2)
    print("in the bar")

def test2(func):
    print (func)
    return func
# t = test2(bar)  # 将test2(bar) 赋值给t，t() == 调用test2函数，改变了调用方式
# t()
# # <function bar at 0x00000172B2CF3E18>
# # in the bar
bar = test2(bar)    # # 将test2(bar) 赋值给bar，bar() == 调用test2函数，未改变了调用方式
bar()
# <function bar at 0x0000016C6E663E18>
# in the bar
'''

　　

# 嵌套函数

# eg_v1
'''
def foo():
    print ("in the foo")
    def bar():
        print ("in the bar")

    bar()
foo()
'''

# eg_v2 # 局部作用域和全局作用域的访问顺序
'''
x = 0
def grandpa():
    x = 1
    def dad():
        x = 2
        def son():
            x = 3
            print (x)
        son()
    dad()
grandpa()
# 3
'''

　　

# 写一个简单的装饰器
# eg_v1 不使用语法糖

'''
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 %s:"%(stop_time - start_time))
    return deco

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

def test2():
    time.sleep(3)
    print ("in the test2")
test1 = (timer(test1))  # 赋值必须与被装饰的函数同名
test1()
# in the test1
# the func run time 3.0068588256835938:
'''

# eg_v2 使用语法糖,不带参数

'''
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 %s:"%(stop_time - start_time))
    return deco

@timer
def test1():
    time.sleep(3)
    print ("in the test1")
@timer
def test2():
    time.sleep(3)
    print ("in the test2")

test1()
test2()
# in the test1
# the func run time 3.000098705291748:
# in the test2
# the func run time 3.0001633167266846:
'''

# eg_v2 使用语法糖,被装饰函数带参数

'''
import time

def timer(func):   # timer(test1) --> func= test1
    def deco(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)   # run test1()
        stop_time = time.time()
        print ("the func run time %s:"%(stop_time - start_time))
    return deco

@timer
def test1():
    time.sleep(3)
    print ("in the test1")
@timer
def test2(name):   # test2 = timer(test2) == deco test2(name) == deco(name)
    time.sleep(3)
    print ("in the test2",name)

test1()
test2("xieshengsen")
# in the test1
# the func run time 3.0004942417144775:
# in the test2 xieshengsen
# the func run time 3.0003535747528076:
'''

# eg_v3
# 一个简单的登陆页面认证过程（装饰器）(装饰函数带参数)

user = "aaaaaa"
pawd = "123456"


def auth(auth_type):
    print ("auth func:",auth_type)
    
    def outer_wrapper(func):
        def wrapper(*args,**kwargs):
            print ("wrapper func args:",*args,**kwargs)

            if auth_type == "local":
                username = input("username:").strip()
                password = input("password:").strip()

                if username == user and password == pawd:
                    print ("login....")
                    res = func(*args,**kwargs)  # from home
                    print ("-*-*-*-*-after auth-*-*-*-*-")
                    return res
                else:
                    print ("invalid...")
            elif auth_type == "ldap":
                input("ldap")
                print ("use ladp auth...")
        return wrapper
    return outer_wrapper


def index():
    print ("welcome to index page.")
    

@auth(auth_type="local")
def home():
    print("welcome to home age.")


@auth(auth_type="ldap")
def bbs():
    print("welcome to bbs age.")

index()
home()
bbs()

　　

另 一些关于装饰器介绍的实例

来自：http://blog.csdn.net/yhy1271927580/article/details/72758577

"""
被装饰的对象为函数，且不带参数
简要说明： @timeit装饰器对sleep函数进行了装饰，这是一个装饰器不带参数的装饰器，当sleep函数调用的时候，调用的并不是我们看到的原始的sleep函数，而是装饰过后的sleep函数。这个装饰的过程会发生在调用sleep函数之前发生。
装饰的过程：原生的sleep函数作为参数传递到timeit装饰器函数的fn参数，通过@wraps这个装饰器将fn的属性赋值给底下需要返回的wrap函数，最后返回wrap函数，由此可间，wrap就是装饰过后的sleep函数了。那么在调用新sleep函数的时候，就是调用wrap函数，sleep函数的参数2，被wrap函数的*args、**kwargs这两个可变参数接收。
整个装饰的目的就是将原生的sleep函数，扩充了一个print(nowTime() - start)的过程。
"""

from time import sleep as sleeping
from time import time as nowtime
from functools import wraps


def timeit(fn):
    @wraps(fn)
    def wrap(*args,**kwargs):
        start = nowtime()
        ret = fn(*args,**kwargs)
        print (nowtime() - start)
        return ret
    return wrap

@timeit
def sleep(n):
    sleeping(n)
    print("sleep time {}s".format(n))
    return n

sleep(2)
print("%s func" % sleep.__name__)
# sleep time 2s
# 2.0028135776519775
# sleep func

　　

"""
被装饰的对象为函数，且带参数
简要说明： @timeit装饰器对sleep函数进行了装饰，这是一个装饰器是带参数的装饰器.
这个装饰器由于需要传递参数，因此需要两层装饰，第一层是接受传递的参宿，第二层是接收传递进来的需要装饰的函数当sleep函数调用的时候，调用的并不是我们看到的原始的sleep函数，而是装饰过后的sleep函数。
装饰的过程：装饰器第一次接收cpu_time参数，然后返回一个dec装饰器，而这个dec装饰器会被再次调用，传入参数是原生的sleep函数，原生的sleep函数作为参数传递到dec装饰器函数的fn参数，通过@wraps这个装饰器将fn的属性赋值给底下需要返回的wrap函数，最后返回wrap函数
在调用新sleep函数的时候，就是调用wrap函数，sleep函数的参数2，被wrap函数的*args、**kwargs这两个可变参数接收。整个装饰的目的就是将原生的sleep函数，扩充了一个time_func = time.clock if cpu_time else time.time和print(nowTime() - start)的过程
"""

from functools import wraps
import time


def timeit(cpu_time=False):
    print("timeit")

    def dec(fn):
        @wraps(fn)
        def wrap(*args,**kwargs):
            start = time.time()
            ret = fn (*args,**kwargs)
            print(time.time() - start)
            return ret
        return wrap
    return dec


@timeit(False)
def sleep(n):
    time.sleep(n)
    print ("time sleep")
    return n

sleep(2)
print("%s func" % sleep.__name__)
# timeit
# time sleep
# 2.009625196456909
# sleep func