python_装饰器_语法糖

            #!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘


def func_x(x):
    return x * 2


def func_y(y):
    return y * 3


def func_z(x, y):
    # 等价于 return func_x(5) + func_y(3)
    return x(5) + y(3)

if __name__ == ‘__main__‘:
    # 把函数当做参数，本质上是把函数的内存地址当做参数传递过去，
    result = func_z(func_x, func_y)
    print(result)
        

            #!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘

import time


def total_time(func):                              # func = hell_word
    def wrapper():                                 # 等价于hell_word()
        start_time =time.time()
        func()
        end_time = time.time()
        print(end_time - start_time)               # 打印统计时间
    return wrapper


# 通过装饰器给hell_word函数装上了统计时间的功能，功能逻辑在装饰器中实现
@total_time                                      
def hell_word():
    time.sleep(0.5)
    print(‘hello word‘)
    
if __name__ == ‘__main__‘:
    hell_word()
        

            #!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘

import time

            

            
# 装饰器函数
def total_time(func):
    def wrapper():
        start_time =time.time()
        func()
        end_time = time.time()
        print(end_time - start_time)
    return wrapper

            

            
def hell_word():
    time.sleep(0.5)
    print(‘hello word‘)

if __name__ == ‘__main__‘:
    # 把函数当做参数传入装饰器函数，然后装饰器函数返回包裹函数wrapper地址，执行装饰器函数本质上执行包裹函数wrapper中逻辑
    total_time(hell_word)()
        

            #!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘


def jian_zhi(func):
    # 中间字典，判断已经是否求解过
    median = {}
    
    def wrapper(*args):
        # 假如不在中间字典中，说明没有求解过，添加到字典中去，在的话，直接返回, 将不在递归下去，保证每次递归的唯一性
        if args not in median:
            median[args] = func(*args)
        return median[args]
    
    return wrapper


@jian_zhi
def fibonacci(n):
    if n <= 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


@jian_zhi
def climb(n, steps):
    count = 0
    # 当最后台阶为0的时候，说明最后只是走了一次
    if n == 0:
        count = 1
    # 当最后台阶不为0的时候，说明还需要走至少一次
    elif n > 0:
        # 对三种情况进行分别处理momo
        for step in steps:
            count += climb(n - step, steps)
    
    # 返回每次递归的计数
    return count


if __name__ == ‘__main__‘:
    print(climb(10, (1, 2, 3)))
    print(fibonacci(20))

        

            #!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘

import time
from functools import (wraps, update_wrapper, WRAPPER_ASSIGNMENTS, WRAPPER_UPDATES)


def count_time(func):
    """
    给目标函数加上计算运行时间统计
    """
    
    # 这个装上器和update_wrapper一样，默认参数WRAPPER_ASSIGNMENTS, WRAPPER_UPDATES
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        
        # 定义result接收函数返回值，并且在装饰函数最后返回回去
        resutl = func(*args, **kwargs)
        print(‘运行时间：‘, time.time() - start_time)
        return resutl
    
    # 其中默认参数 WRAPPER_ASSIGNMENTS, WRAPPER_UPDATES
    # update_wrapper(wrapper, func)
    return wrapper


@count_time
def add(num=100):
    """
    计算 0~num 累加值，默认num=100
    """
    time.sleep(1)
    return sum([x for x in range(num + 1)])


if __name__ == ‘__main__‘:
    print(‘函数名：‘, add.__name__)
    print(‘属性字典：‘, add.__dict__)
    print(‘函数默认参数：‘, add.__defaults__)
    print(‘函数所在模块：‘, add.__module__)
    print(‘函数文档：‘, add.__doc__)
    
    # 打印两个默认参数
    # WRAPPER_ASSIGNMENTS ：__module__‘, ‘__name__‘, ‘__qualname__‘, ‘__doc__‘, ‘__annotations__
    # WRAPPER_UPDATES：__dict__
    print(WRAPPER_ASSIGNMENTS, WRAPPER_UPDATES)
    result = add()
    print(result)

        

            #!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘

from inspect import signature


def check_type(*ty_args, **ty_kwargs):
    def out_wrapper(func):
        # 通过signature方法，获取函数形参：name, age, height
        sig = signature(func)
        # 获得装饰器传来的参数， 函数签名与之绑定，字典类型
        bind_types = sig.bind_partial(*ty_args, **ty_kwargs).arguments
        print(bind_types)
        
        def wrapper(*args, **kwargs):
            # 给执行函数中具体的实参进行和形参进行绑定，形成字典的形式
            func_type = sig.bind(*args, **kwargs).arguments.items()
            print(func_type)
            # 循环形参和实参字典的items()形式
            for name, obj in func_type:
                if name in bind_types:
                    # 判断实参是否是指定类型数据
                    if not isinstance(obj, bind_types[name]):
                        raise TypeError(‘%s must be %s‘ % (name, bind_types[name]))
            # 假如函数有返回值，通过此方法返回函数的返回值
            res = func(*args, **kwargs)
            return res
        
        return wrapper
    
    return out_wrapper


# 通过装饰器实现对函数参数进行类型检查
@check_type(str, int, float)
def func(name, age, height):
    print(name, age, height)


if __name__ == ‘__main__‘:
    # 正常数据
    func(‘bei_men‘, 18, 1.75)
    # 错误数据
    func(‘bei_men‘, ‘18‘, 1.75)

        

#!/usr/bin/python3

__author__ = ‘beimenchuixue‘
__blog__ = ‘http://www.cnblogs.com/2bjiujiu/‘

import logging
from time import time, strftime, localtime, sleep
from random import choice
from functools import wraps


class ToLog():
    def __init__(self, name):
        log = logging.getLogger(name)
        log.setLevel(logging.INFO)
        # 日志保存文件名字
        file_name = logging.FileHandler(name + ‘.log‘)
        # 添加日志文件
        log.addHandler(file_name)
        # 日志格式
        log.info(‘start‘.center(50, ‘-‘))
        self.log = log
        self.temp = ‘%(func)s -> [%(start_time)s - %(used_time)s - %(naclls)s]‘
    
    def go_log(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 函数每调用一次加1
            wrapper.naclls += 1
            
            start_time = time()
            res = func(*args, **kwargs)
            used_time = time() - start_time
            
            info = {}
            info[‘func‘] = func.__name__
            info[‘start_time‘] = start_time
            info[‘used_time‘] = used_time
            info[‘naclls‘] = wrapper.naclls
            
            msg = self.temp % info
            # 把日志按格式写入文件
            self.log.info(msg)
            
            return res
        
        # 初始化调用次数参数
        wrapper.naclls = 0
        
        return wrapper
    
    # 重新定义日志记录模版
    def set_log_temp(self, temp):
        self.temp = temp
    
    # 关闭日志功能
    def log_off(self):
        self.log.setLevel(logging.WARN)
    
    # 打开日志功能
    def log_on(self):
        self.log.setLevel(logging.INFO)


# 实例化出两个装饰器对象
log_one = ToLog(‘one‘)
log_two = ToLog(‘two‘)

# 修改实例2的日志模版,去掉执行时间
log_two.set_log_temp(‘%(func)s -> [%(start_time)s - %(naclls)s]‘)

# 关闭log_two中记录日志功能
log_two.log_off()


@log_one.go_log
def func_one():
    print(‘one‘)


@log_one.go_log
def func_two():
    print(‘two‘)


@log_two.go_log
def func_three():
    print(‘three‘)


if __name__ == ‘__main__‘:
    for _ in range(50):
        choice([func_one, func_two, func_three])()
        sleep(choice([0.5, 1, 1.5]))