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 廖雪峰的官方网站