Python生成器、装饰器

## 生成器
　　- 生成器是用来创建Python序列的一个对象
　　- 通常生成器是为迭代器产生数据的
　　- 例如range()函数就是一个生成器
　　- 每次迭代生成器时，它都会记录上一次调用的位置，并返回下一个值，这使程序不需要创建和存储完整的序列

## 生成器函数
　　- 生成器函数与普通函数类似，但它的返回值使用yield语句，而不是return

def my_range(start=0, last=10, step=1):
    number = start
    while number < last:
        yield number
        number += step
    
my_range     # 是一个普通函数
# <function my_range at 0x7efe3dbf2e18>

my_range()   # 返回一个生成器对象
# <generator object my_range at 0x7efe3daac360>

list(my_range(1, 10))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]          

## 装饰器

　　- 装饰器的作用在于在不改变原有代码结构的前提下，对原有代码的功能进行补充扩展
　　- 装饰器的本质上是接受函数为参数的高阶函数，它把一个函数作为参数输入并且返回一个功能拓展后的新函数

# 装饰器函数，为函数添加两条语句
def deco(fn):
    def new_func(*args):  # 内部函数的参数需要与传入的fn的参数相同
        print("执行函数：{0}".format(fn.__name__))
        result = fn(*args)
        print("函数执行结果：{0}".format(result))
        return result
    return new_func


@deco    # 使用@装饰函数名，使用装饰器之后，add实际上已经指向了doco函数返回的新函数
def add(*args):
    print("我是核心代码，可不能改动我")
    result = 0
    for n in args:
        result += n
    return result


add(1, 2, 3, 4)
"""
执行结果：
    执行函数：add
    我是核心代码，可不能改动我
    函数执行结果：10
"""

　　　　

　　　　- 一个函数可以有多个装饰器

　　　　- 最靠近函数的装饰器会先执行，然后一次向上执行装饰器

def count_param(fn):
    def new_func(*args):
        amount = len(args)
        fn(*args)
        print("参数个数为：{0}".format(amount))
        return amount
    return new_func


@count_param
@deco
def add(*args):
    print("我是核心代码，可不能改动我")
    result = 0
    for n in args:
        result += n
    return result


add(1, 2, 3, 4)
"""
执行结果：
    执行函数：add
    我是核心代码，可不能改动我
    函数执行结果：10
    参数个数为：4
"""

　　　　- 如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数

import time


def log(now_time):
    def deco(fn):
        def new_func(*args, **kwargs):
            print(now_time)
            return fn(*args, **kwargs)
        return new_func
    return deco


@log(time.asctime(time.localtime(time.time())))
def add(*args):
    print("我是核心代码，可不能改动我")
    result = 0
    for n in args:
        result += n
    return result


add(1, 2, 3, 4)
"""
执行结果：
    函数开始时间：Sun Jul  1 15:30:14 2018
    我是核心代码，可不能改动我
"""

　　- 此时打印add函数的__name__属性发现：

print("核心函数名：{0}".format(add.__name__))
"""
输出：
    核心函数名：new_func
"""

  

　　- 这表明虽然装饰器表面上并没有改变核心函数的内容，但实际上还是对核心函数的属性进行了修改，所以还需要将核心函数的__name__属性复制到新函数

import time


def log(now_time):
    def deco(fn):
        def new_func(*args, **kwargs):
            # 将原函数的__name__属性复制到新函数
            new_func.__name__ = fn.__name__
            print(now_time)
            return fn(*args, **kwargs)
        return new_func
    return deco


@log(time.asctime(time.localtime(time.time())))
def add(*args):
    print("我是核心代码，可不能改动我")
    result = 0
    for n in args:
        result += n
    return result


add(1, 2, 3, 4)
print("核心函数名：{0}".format(add.__name__))
"""
执行结果：
    Sun Jul  1 15:43:00 2018
    我是核心代码，可不能改动我
    核心函数名：add
"""    

　　- 在functools里面有一个专门的函数处理这个问题

import time
import functools


def log(now_time):
    def deco(fn):
        @functools.wraps(fn)      # 在新的函数上添加装饰器，修改新函数的__name__属性
        def new_func(*args, **kwargs):
            print(now_time)
            return fn(*args, **kwargs)
        return new_func
    return deco


@log(time.asctime(time.localtime(time.time())))
def add(*args):
    print("我是核心代码，可不能改动我")
    result = 0
    for n in args:
        result += n
    return result


add(1, 2, 3, 4)
print("核心函数名：{0}".format(add.__name__))
”“”
执行结果：
    Sun Jul  1 15:48:10 2018
    我是核心代码，可不能改动我
    核心函数名：add
“”“

　　- 类装饰器 

class Test(object):
    def __init__(self, fn):
        self.fn = fn

    # 重写__call__函数，使实例能够像函数一样调用
    def __call__(self, *args, **kwargs):
        print("这是基于类的修饰")
        return self.fn(*args, **kwargs)


@Test
def core_func(a, b):
    return a + b


print(core_func(2, 3))
"""
输出：
    这是基于类的修饰
    5
"""

　　- 类装饰器带参数

import datetime
import functools


class Test(object):
    def __init__(self, log):
        self.log = log

    # 重写__call__函数，使实例能够向函数一样调用
    def __call__(self, fn):
        @functools.wraps(fn)    # 同样在这里使用functools.wraps()，将原函数__name__属性复制到新函数
        def wrapper(*args, **kwargs):
            print(self.log)
            print("执行函数：%s" % fn.__name__)
            return fn(*args, **kwargs)
        return wrapper


@Test(datetime.datetime.now())
def core_func(a, b):
    return a + b


@Test(datetime.datetime.now())
def say_hi():
    print("Hi")


print(core_func(2, 3))
print(core_func.__name__)   # 输出：core_func
say_hi()
print(say_hi.__name__)      # 输出：say_hi
"""
输出：
    2018-07-02 10:55:27.258637
    执行函数：core_func
    5
    core_func
    2018-07-02 10:55:27.258696
    执行函数：say_hi
    Hi
    say_hi
"""

本文参考：

　　[美]Bill Lubanovic 《Python语言及其应用》
　　https://www.liaoxuefeng.com 廖雪峰的官方网站