Python 可迭代对象、迭代器、生成器

可迭代对象

定义

在Python的任意对象中,只要它定义了可以返回一个迭代器的 __iter__ 魔法方法,或者定义了可以支持下标索引的 __getitem__ 方法,那么它就是一个可迭代对象,通俗的说就是可以通过 for 循环遍历了。Python 原生的列表,字符串,元祖,字典等都是可以迭代的,可以通过 dir() 函数查看,如以下查看字符串,可见其定义了 __getitem__ 方法

Python 可迭代对象、迭代器、生成器_第1张图片

判断一个对象是否是可迭代对象

方法一:isinstance + Iterable

方法二:hasattr + __getitem__ 

from collections import Iterable
# 方法一
print(isinstance([], Iterable))  # 返回 True,说明是可迭代对象
# 方法二
print(hasattr({}, '__getitem__'))  # 返回 True,说明是可迭代对象

自定义可迭代对象

class Employee:
    def __init__(self, employee):
        self.employee = employee

emp = Employee(['zs', 'ls', 'ww'])

# 正常情况下会报错,emp 不是一个可迭代对象
# TypeError: 'Employee' object is not iterable
for i in emp:
    print(i)

 实现 __iter__ 和 __getitem__ 方法中的一个或者两个

class Employee:
    def __init__(self, employee):
        self.employee = employee

    def __getitem__(self, item):
        # item 是解释器帮我们维护的索引值
        # 在 for 循环中,自动从 0 开始计算
        print(item)
        return self.employee[item]

emp = Employee(['zs', 'ls', 'ww'])

# 正常情况下会报错,emp 不是一个可迭代对象
# TypeError: 'Employee' object is not iterable
for i in emp:
    print(i)

迭代器

迭代器对象

迭代器就是同时实现了 __next__ 和 __iter__ 方法(缺一不可)的对象。其中 __iter__ 方法返回迭代器自身, __next__ 方法不断返回迭代器中的下一个值,直到容器中没有更多的元素时,抛出 StopIteration 异常,以终止迭代 由定义可以知道,迭代器一定是可迭代对象,因为迭代器实现了 __iter__ 方法,满足了可迭代对象的定义。但是可迭代对象不一定是迭代器,因为不一定实现了 __next__ 方法。

判断一个对象是迭代器

from collections import Iterator
print(isinstance(counter, Iterator))  # True
print(isinstance([], Iterator))  # False

为什么有了可迭代对象,还要有迭代器?

因为迭代器采用了工厂模式,节约了内存空间。所谓的工厂模式,就是在需要的时候,才会去生产数据,而不是像可迭代对象那样一次性 全部把数据生产出来。可迭代对象如列表,字典等,会事先把所有的数据生产并保存起来,而迭代器则是在每次获取下一个值的时候 才会返回值,所以迭代器没有长度这一说法,没有长度这一属性,如果获取完了会抛出 StopIteration 异常来表示没有数据了

所以迭代器适用于那种无限序列,不会占用很大的内存空间

from itertools import count

# count 是一个迭代器
# 创建一个从 10 开始的无限序列
counter = count(start=10)
print(type(counter))  # 
print(dir(counter))  # 有 __iter__ 和 __next__ 方法

print(next(counter))  # 10
print(next(counter))  # 11

# 报错,没有长度属性
# TypeError: object of type 'itertools.count' has no len()
# print(len(counter))

可迭代对象转为迭代器

a = [1, 2, 3, 4]
print(type(a))  # 

a_iter = iter(a)
print(type(a_iter))  # 

迭代器的特点

a = [1, 2, 3, 4]
a_iter = iter(a)
# 每一次获取迭代器中的值之后,都是把该值从迭代器中拿出来,即迭代器中已经没有该值了,因为已经被拿出来了
# 所以遍历完一次迭代器之后,不能遍历第二次
# 因为遍历第一次的时候已经把值拿出来完了,第二次去遍历的时候迭代器中啥也没有了
# 即迭代器不走回头路,可迭代对象则没有这种特点
for i in a_iter:
    print(i)

for i in a_iter:
    print(i)

# 上面代码只会输出一次 1 2 3 4

# 前面说的,当遍历完迭代器的最后一个数据时,再获取数据抛出异常,
# 而 for 循环没有抛出的原因是
# for 循环内部也是用 next() 方法获取迭代器中的值,
# 当抛出异常后 for 循环会对异常进行处理,所以我们采用 for 循环遍历迭代器时不会有异常抛出

生成器

生成器其实是一种特殊的迭代器,但是这种迭代器更加优雅,因为不需要再像普通迭代器那样定义 __next__ 和 __iter__ 方法,只需要一个 yield 关键字,就会自动在内部帮我们实现这两个方法。所以,如果一个函数包含一个或多个 yield 关键字, 这个函数就会变为一个生成器。因为生成器是特殊的迭代器,所以它具备迭代器具备的特性

def demo():
    print('hello')
    yield 5
    print('world')

print(type(demo()))  # 
print(dir(demo))  # 有 __iter__ 和 __next__ 方法

yield 关键字的作用

1、程序每次在代码中遇到 yield 关键字后,会返回结果,相当于 return 5,但是并没有真的退出程序,而是保留当前函数的运行状态

2、返回结果后,保留当前函数的运行状态,等待下一次调用,下次调用时,从上一次返回结果处开始执行 

第二个作用非常重要,这意味着程序控制权的转移是临时和自愿的,函数将来还会收回控制权(在下次调用生成器的时候收回), 这也是 yield 和 return 最大的区别。return 意味着函数彻底交出控制权并结束运行,下一次调用将固定从函数的第一行代码开始执行。

def demo():
    print('hello')
    yield 5
    print('world')

# 此时运行demo(),相当于调用函数,但是并不像普通函数那样马上执行,可以看控制台没有输出
# 此处只是生成一个生成器对象
c = demo()

# 利用 next 方法调用生成器
# 第一次调用,打印 hello ,并返回 5
print(next(c))
# 第二次调用,打印 world ,并抛出异常 StopIteration(迭代器特性)
# 因为已经没有语句可以执行了,相当于数据已经取完了
print(next(c))

通过 send 向生成器传递数据

send 方法作用:

1、像 next 方法一样去调用生成器(调用生成器的两种方法:next 方法和 send 方法)

2、send 方法在调用生成器时,可以同时给生成器传递数据到生成器内部 

def demo():
    print('hello')
    # 注意,此处不是把 yield 5 赋值给变量 t
    # yield 5 是返回给调用者的值,即返回给 next(c),
    # 所以执行 print(next(c)) 语句时会在输出 hello 后输出 5
    # 而变量 t 是接收下一次调用(c.send('test'))时 send 方法传入的 test
    # 即 t = 'test'
    t = yield 5
    print('world')
    print(t)

c = demo()
# 第一次调用生成器,得到 t = yield 5 等号左边的表达式结果,即得到 5
print(next(c))
# 第二次调用,从 t = yield 5 语句开始执行,通过 send 方法把 test 传递给 t = yield 5 等号右边的变量 t
# 然后接着执行函数中两个打印语句,输出 world 和 test
# 打印之后就会抛出异常 StopIteration,因为已经没有要执行的语句了
c.send('test')

生成器的预激活机制

def demo():
    print('hello')
    t = yield 5
    print('world')
    print(t)

c = demo()
# next(c) 就是生成器的预激活机制,即第一次调用
# 第一次调用也可以通过 send 方法,但是参数必须为 None
# 因为生成器没有办法在没有激活的情况下接收一个参数
# print(next(c))  # 预激活方式一
c.send(None)  # 预激活方式二
c.send('test')

查看生成器的运行过程

将下面代码的每一行打上断点(如图),进入debug模式可以清晰的看到代码的运行过程。

Python 可迭代对象、迭代器、生成器_第2张图片

def countdown(n):
    print('counting down from ', n)  # 只在第一次调用生成器的时候输出,此时 n = 10
    while n >= 0:
        # 记住,这里不是将 yield n 赋值给变量 newvalue
        # newvalue 是用来接收 send 方法传递过来的参数的
        # yield n 是用来将 n 返回给调用者(next 方法或 send 方法)的
        newvalue = yield n
        # 判断是否用 send 方法传递参数,如果调用 next 方法,则传递过来的是 None
        if newvalue is not None:
            n = newvalue
        else:
            n -= 1

# 获得生成器对象 c,把 10 传递给 n
c = countdown(10)

for i in c:
    # 第一次调用生成器
    # 第一次执行 for i in c 语句时,内部第一次调用 next(c)
    # 执行 print('counting down from ', n) 语句,此时 n=10
    # 然后进入 while n >= 0 循环,执行 newvalue = yield n 等号右边的 yield n,即返回 n=10 给i
    # 所以第一次for循环 i=10,输出 10
    
    # 第三次调用生成器
    # 第二次执行 for i in c 语句时,内部第二次调用 next(c),此时已经第三次调用生成器,第二次是用 send 方法调用的
    # 接着第二次调用生成器的地方开始执行,即从 newvalue = yield n 开始执行,next 方法没有给生成器传递参数
    # 所以 newvalue 为 None,则执行 else 语句:n -= 1,所以 n = 2
    # 进入 while n >= 0 ,然后返回newvalue = yield n 等号右边的 yield n,即返回 n=2
    # 所以第二次for循环 i=2,输出 2

    # 第四次调用生成器
    # 第三次执行 for i in c 语句时,内部第三次调用 next(c)
    # 接着第三次调用生成器的地方开始执行,即从 newvalue = yield n 开始执行,next 方法没有给生成器传递参数
    # 所以 newvalue 为 None,则执行 else 语句:n -= 1,所以 n = 1
    # 进入 while n >= 0 ,然后返回newvalue = yield n 等号右边的 yield n,即返回 n=1
    # 所以第三次for循环 i=1,输出 1

    # 第五次调用生成器
    # 第四次执行 for i in c 语句时,内部第四次调用 next(c)
    # 接着第四次调用生成器的地方开始执行,即从 newvalue = yield n 开始执行,next 方法没有给生成器传递参数
    # 所以 newvalue 为 None,则执行 else 语句:n -= 1,所以 n = 0
    # 进入 while n >= 0 ,然后返回newvalue = yield n 等号右边的 yield n,即返回 n=0
    # 所以第四次for循环 i=0,输出 0

    # 第六次调用生成器,最后一次
    # 第五次执行 for i in c 语句时,内部第五次调用 next(c)
    # 接着第五次调用生成器的地方开始执行,即从 newvalue = yield n 开始执行,next 方法没有给生成器传递参数
    # 所以 newvalue 为 None,则执行 else 语句:n -= 1,所以 n = -1
    # 不能进入 while n >= 0 ,那么生成器运行到最后结束,抛出一个异常 StopIteration
    # 抛出的异常被for循环内部处理,所以运行到此结束,for循环也结束

    print(i)  # 分别输出 10 2 1 0

    # 第一次进入 for 循环时 i = 10,所以进入 if 判断
    if i == 10:
        # 第二次调用生成器
        # 调用 send 方法调用生成器,接着第一次调用的地方继续执行
        # 把参数传递给 newvalue = yield n 中的 newvalue,此时 newvalue=3
        # newvalue 不为 None,进入判断 if newvalue is not None,将 n 设置为 newvalue (n = newvalue)
        # 此时 n = 3,进入 while n >= 0 ,然后返回newvalue = yield n 等号右边的 yield n,即返回 n=3
        # 然后进行第二次 for 循环
        print('send: ', c.send(3))  # 打印 send:  3

获得生成器的第二种方式

除了通过 yield 关键字得到生成器外,还可以通过小括号的形式得到,如下

"""
生成器表达式
    和列表推导式的区别:
        列表推导式会一下子将所有的数据生产出来,并放到列表中
        生成器表达式一次只生产一个数据
    获得生成器的两种方式:
        1、将普通函数里的 return 替换成 yield ,这样调用函数时会得到一个生成器
        2、利用生成器表达式
"""

# 可以通过元祖表达式(小括号)得到生成器
a = (i for i in range(5))
# 列表推导式得到的是一个列表
b = [i for i in range(5)]

# a 是生成器
print(type(a))  # 
# b 是列表
print(type(b))  # 


# 利用推导式获得生成器的方式称为生成器表达式
t = (i * 2 for i in range(5))
print(t)  #  at 0x000001F466254620>
print(next(t))  # 0
print(next(t))  # 2
# 把剩下的数据处理,目前只剩下 2 3 4
for i in t:
    print(i)  # 4 6 8

生成器实现斐波那契数列 

# 用生成器实现斐波那契数列
def fib():
    num1, num2 = 0, 1
    while True:
        yield num1
        num1, num2 = num2, num1 + num2


f = fib()
# 因为 fib 函数里是死循环,所以只要调用 next(f) 就可以一直得到 斐波那契数列的值
print(next(f))  # 0
print(next(f))  # 1
print(next(f))  # 1
print(next(f))  # 2
print(next(f))  # 3
print(next(f))  # 5

你可能感兴趣的:(Python高阶,python)