Python学习笔记(十) 生成器、迭代器和装饰器

这篇文章主要介绍 Python 中几个常用的高级特性，用好这几个特性可以让自己的代码更加 Pythonnic 哦

1、生成器

什么是生成器呢？简单来说，在 Python 中一边循环一边计算的机制称为 生成器（generator）

生成器最大的优点在于它支持延迟操作，所谓的延迟操作是指在需要的时候才进行运算产生结果

我们可以使用以下两种方法 创建生成器：

• 生成器表达式

类似于列表生成式，只需将列表生成式中的中括号替换成圆括号即可

>>> gen = (item for item in range(3))
>>> type(gen)
# <class 'generator'>

• 生成器函数

类似于普通函数，只需将普通函数中的 return 语句替换成 yield 语句即可

比较难以理解的的地方在于生成器函数和普通函数的执行流程不太一样

普通函数是顺序执行，遇到 return 语句则返回；

生成器函数在每次请求值时都执行一次代码，直至遇到 yield 或 return

yield 意味着返回一个值，且下次执行从上次返回的 yield 语句处开始，而 return 意味着生成器停止执行

>>> def counter(num):
        temp = 0
        while(temp < num):
            temp += 1
            yield temp
            
>>> gen = counter(3)
>>> type(gen)
# <class 'generator'>

我们可以使用以下三种方法 调用生成器：

• 内置方法：__next__()

该方法返回调用生成器的运算结果，每次调用返回一个数据，直到调用结束

注意，生成器只能一直向前迭代，不能回退

>>> gen = (item for item in range(3))
>>> gen.__next__()
# 0
>>> gen.__next__()
# 1
>>> # 在 Python 中有一个全局方法 next(gen)，作用与 gen.__next__() 类似
>>> next(gen)
# 2
>>> # 当生成器调用结束后，再次调用会抛出 StopIteration 异常
>>> next(gen)
# StopIteration

• 内置方法：send()

该方法返回调用生成器的运算结果，同时向生成器内部发送数据

注意，在第一次调用 send() 函数前至少使用一次 next() 或 __next__() 方法

>>> def counter(num):
        temp = 0
        while(temp < num):
            temp += 1
            re = yield temp
            print(re)
            
>>> gen = counter(3)
>>> next(gen)
# 1
>>> gen.send('Hello')
# Hello
# 2
>>> gen.send('World')
# World
# 3
>>> next(gen)
# None
# StopIteration

• for 循环

生成器也是一个可迭代对象，我们可以使用 for 循环进行遍历生成器中的每一个元素

需要注意的是，生成器只能遍历一次

>>> gen = (item for item in range(3))
>>> for item in gen:
		print(item)

# 0
# 1
# 2

2、迭代器

我们首先来了解一下几个与迭代器相关的概念：

迭代（Iteration）：在Python 中，我们可以通过 for 循环遍历 list 或 tuple 等数据类型，这种遍历我们称为迭代

可迭代对象（Iterable）：可以直接作用于 for 循环的对象我们称为可迭代对象，一般包括集合数据类型和生成器

迭代器（Iterator）：实现了迭代器协议的对象称为迭代器

那么如何判断可迭代对象和迭代器：

• 一个实现了 __iter__() 方法的对象是可迭代的，一个实现了 __iter__() 方法和 __next__() 方法的对象是迭代器

  由此也可以看出，迭代器一定是可迭代对象，但可迭代对象不一定是迭代器

• 一个可作用于 for 循环的对象是可迭代的，一个可作用于 next() 方法的对象是迭代器

例如，集合数据类型是可迭代对象，但不是迭代器；生成器是可迭代对象，同时也是迭代器

>>> from collections import Iterable, Iterator
>>> li = [item for item in range(3)]
>>> isinstance(li,Iterable)
# True
>>> isinstance(li,Iterator)
# False
>>> gen = (item for item in range(3))
>>> isinstance(gen,Iterable)
# True
>>> isinstance(gen,Iterator)
# True

3、装饰器

（1）闭包

在了解装饰器之前，我们先来了解一下什么是闭包？先看看闭包的定义：

如果在一个内部函数中对外部作用域（但不是全局作用域）的变量进行引用，那么该内部函数称为闭包

>>> def external(x):
        def internal(y):
            return x+y
        return internal

>>> func1 = external(5)
>>> func1(10)
# 15
>>> func2 = external(10)
>>> func2(10)
# 20

例如，在上面的代码中，internal 为内部函数，external 为外部函数

在内部函数 internal 中对外部作用域（但不是全局作用域）的变量 x 进行引用

那么这时我们可以称内部函数 internal 为闭包

（2）装饰器

装饰器实际上是一个闭包，它接受一个函数作为参数，返回一个经过装饰的函数

def decorator(func):
    def wrapper(*args, **kwargs):
        print('装饰器')
        func()
        print('装饰器')
    return wrapper

@decorator
def func():
    print('原有操作')
        
func()

# 装饰器
# 原有操作
# 装饰器

实际上，我们还可以为一个函数添加多个装饰器，注意观察它们之间的执行顺序：

def decorator1(func):
    def wrapper(*args, **kwargs):
        print('装饰器1')
        func()
        print('装饰器1')
    return wrapper

def decorator2(func):
    def wrapper(*args, **kwargs):
        print('装饰器2')
        func()
        print('装饰器2')
    return wrapper

@decorator1
@decorator2
def func():
    print('原有操作')

func()

# 装饰器1
# 装饰器2
# 原有操作
# 装饰器2
# 装饰器1

装饰器常常用于日志功能，下面是一个例子：

from functools import wraps

def logger(func):
    @wraps(func) # 添加 functools.wraps 可以防止原有函数自身的信息丢失
    def wrapper(*args, **kwargs):
        print(func.__name__ + ' is called')
        return func(*args, **kwargs)
    return wrapper

@logger
def func(x,y):
   return x + y

res = func(3,4)

# func is called

装饰器还可以用于计时功能，下面是另外一个例子：

from functools import wraps
import time

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        end_time = time.time()
        print(end_time - start_time)
    return wrapper

@timer
def func():
    time.sleep(1)

func()

# 1.0003883838653564

【 阅读更多 Python 系列文章，请看 Python学习笔记 】