python装饰器

装饰器，闭包，函数增强

#!/usr/bin/env python
# coding=utf-8
import time
import logging

logger = logging.getLogger(__name__)


# 普通实现函数增强
def count_time(func):
    start_time = time.time()       # 起始时间
    func()  # 执行函数   # 结束时间
    # time.sleep(2)
    end_time = time.time()
    print(f"it takes {end_time - start_time} s to find all ths olds")


# 闭包实现函数增强
def count_time_wrapper(func):
    # 增强func函数，当增强的函数有参数时，需要设置*args, **kwargs
    def improved_func(*args, **kwargs):
        start_time = time.time()  # 起始时间
        # 当需要增强的函数有返回值时需要接收，当增强的函数有参数时*args, **kwargs
        ret = func(*args, **kwargs)  # 执行函数   # 结束时间
        # time.sleep(2)
        end_time = time.time()
        print()
        print(f"it takes {end_time - start_time} s to find all ths olds")
        return ret
    # 返回增强后的函数
    return improved_func


# 装饰器实现增强【主函数】
@count_time_wrapper
def print_quality():

    for i in range(2, 1000):
        if i == 2:
            print(i, end="\t")
        for j in range(2, i):
            if i % j == 0:
                break
            elif i / j < j:
                print(i, end="\t")
                break


def coumt_odd(lim=100):
    a = 0
    print(lim)
    for i in range(lim):
        if i % 2 == 1:
            a += i
    return a


# 主函数
def print_odd():
    for i in range(1000):
        if i % 2 == 1:
            print(i)


if __name__ == '__main__':
    # count_time(print_odd)     # 普通实现
    # imp = count_time_wrapper(print_odd)   # 闭包实现
    # imp()
    # print_quality()     # 添加装饰器实现
    imp = count_time_wrapper(coumt_odd) # 主函数有返回值和参数时
    print(imp(lim=200))

多层装饰器，装饰器参数

#!/usr/bin/env python
# coding=utf-8
import time


# 传参多加一层
def log_wrapper(info):
    def internal_log_wrapper(func):
        def improved_func1():
            start_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))    # 起始时间
            # time.sleep(2)
            func()
            end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))  # 结束时间
            print()
            print(f"Logging: func:{func.__name__} runs from {start_time} to {end_time}, info[{info}]")
        # 返回增强后的函数
        return improved_func1
    return internal_log_wrapper


def count_time_wrapper(func):

    def improved_func2():
        start_time = time.time()  # 起始时间
        # time.sleep(2)
        func()
        end_time = time.time()
        print()
        print(f"it takes {end_time - start_time} s to find all ths olds")
    # 返回增强后的函数
    return improved_func2


# @count_time_wrapper
@log_wrapper(info='hello haha')     # 装饰器传参
def print_quality():

    for i in range(2, 1000):
        if i == 2:
            print(i, end="\t")
        for j in range(2, i):
            if i % j == 0:
                break
            elif i / j < j:
                # print(i, end="\t")
                break
    # print("qual")


if __name__ == '__main__':
    # 双层装饰器等价于
    # orig = log_wrapper(count_time_wrapper(print_quality))
    # print(print_quality.__name__)
    # orig1 = count_time_wrapper(print_quality)   # 定义count_time_wrapper
    # print(orig1.__name__)
    # orig1 = log_wrapper(orig1)  # 定义log_wrapper
    # print(orig1.__name__)
    # orig1()     # 调用函数首先调用count_time_wrapper内的加强函数，再调用log_wrapper内的函数
    print_quality()