简单介绍Python 中的迭代器和生成器

可迭代对象和迭代器

迭代(iterate)意味着重复,就像 for 循环迭代序列和字典那样,但实际上也可使用 for 循环迭代其他对象:实现了方法 __iter__ 的对象(迭代器协议的基础)。

__iter__方法返回一个迭代器,它是包含方法 __next__ 的对象,调用时可不提供任何参数;

当你调用 __next__ 时,迭代器应返回其下一个值;如果没有可供返回的值,应引发 StopIteration 异常;

也可使用内置函数 next(),此种情况下,next(it) 与 it.__next()__ 等效。

至于为什么不用列表?因为在很多情况下,使用列表都有点太浪费了。例如,如果你有一个可逐个计算值的函数,你可能只想逐个地获取值,而不是使用列表一次性获取。这是因为如果有很多值,列表可能占用太多的内存。

下面来看一个不能使用列表的示例,因为如果使用,这个列表的长度将是无穷大的!

# 这个“列表”为斐波那契数列,表示该数列的迭代器如下:
class Fibs:
    def __init__(self):
        self.a = 0
        self.b = 1

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        return self.a  # 前面逻辑自定义,最后返回下一个值即可

    def __iter__(self):
        return self  # 返回迭代器本身(一个包含 __next__ 方法的对象)
    
fibs = Fibs()

for f in fibs:
	if f > 1000:
		print(f)  # 1597
		break  # 若不中断循环,将一直循环下去
        
next(fibs)  # 2584
next(fibs)  # 4181

更正规的定义是,实现了方法 __iter__ 的对象是 可迭代的,再实现了方法 __next__ 的对象是 迭代器。

内置函数 iter()

通过对可迭代对象调用内置函数 iter(),可以获得一个迭代器。还可使用它从函数或其他可调用对象创建可迭代对象。

不过,可迭代对象在转化为迭代器后,会丢失⼀些属性(如 __getitem__() ),但同时也会增加⼀些属性(如 __next__() )。

另外,迭代器一般都是⼀次性的,当迭代过⼀轮后,再次迭代将获取不到元素;而可迭代对象可以重复使用。

it = iter([1, 2, 3])  # list 是可迭代对象哦
next(it)  # 1
next(it)  # 2
next(it)  # 3
next(it)  # StopIretation; 普通的可迭代对象是可复用的,而迭代器是一次性的,回不了头的

it = iter("ABCD")  # string 也是可迭代对象
for i in it:
    print(i, end=" ")  # A B C D
for i in it:
    print(i, end=" ")  # ⽆输出

查看对象是否实现了魔法方法 _ iter _ 的四种方法:

# ⽅法1:dir()查看__iter__,详情请自己尝试
dir(2) # 没有
dir("abc") # 有 __iter__()

# ⽅法2:isinstance()判断
import collections
isinstance(2, collections.Iterable) # False
isinstance("abc", collections.Iterable) # True

# ⽅法3:hasattr()判断
hasattr(2,"__iter__") # False
hasattr("abc","__iter__") # True

# ⽅法4:⽤iter()查看是否报错
iter(2) # 报错:'int' object is not iterable
iter("abc") # <str_iterator at 0x1e2396d8f28>

从迭代器创建序列

在可以使用序列的情况下,大多也可以使用迭代器或可迭代对象(诸如索引和切片等操作除外)。迭代器因为缺少 __getitem__ ,因此不能使⽤普通的切⽚语法,暂未深究。

# 使用构造函数 list() 显示的将迭代器转换为列表
class TestIterator:
    value = 0
    
    def __next__(self):
        self.value += 1
        if self.value > 10: raise StopIteration
        return self.value
    
    def __iter__(self):
        return self
    
ti = TestIterator()
ti2 = list(ti)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in ti2:
    print(i, end=" ")  # 1 2 3 4 5 6 7 8 9 10
        
print('the second:')

for i in ti2:
    print(i, end=" ")  # 1 2 3 4 5 6 7 8 9 10

生成器

生成器,也被称为简单生成器(simple generator),生成器自动创建了 iter() 和 next() 方法,是一种使用普通函数语法定义的 迭代器 。与函数的主要的形式差别就在于,它的函数体中有一句 yield 语句。

每次执行到 yield 处时,生成并返回一个值后,函数都将暂时停止执行,等待下一轮迭代调用,如此往复,直到迭代完。 数据量大时,生成器能够极大地节省内存空间 。下面还是通过斐波纳契数列来看看:

# 斐波纳契数列的生成器实现: 返回数列的前 n 项
def fibs(n):
    a, b = 0, 1
    for _ in range(n):
        yield a  # 返回的是一个生成器
        a, b = b, b+a

f = fibs(5)
print(f)  # <generator object fibs at 0x05BB20B0>
print(list(f))  # [0, 1, 1, 2, 3]; 此处生成器 f 已经被迭代过一次了

for i in f:
    print(i, end=" ")  # ⽆输出; for循环会⾃动捕捉到 StopIteration 异常并停⽌调⽤ next()
    
print(next(f))  # StopIteration

与 return 的区别:生成器不是像 return 一样返回一个值,而是可以生成多个值,每次返回一个;return 返回的话,这个函数就结束了。

生成器推导(生成式表达式)

将列表生成式的 [] 改成 () 之后,数据结构将从列表变为生成器,而不是元组。如果要包装可迭代对象(可能生成大量的值)时,若使用列表推导将立即实例化一个列表,从而丧失迭代的优势;但如果使用生成器推导的话,每迭代一次就生成一个值,没必要一次性生成全部值,这样就好的多了。而且,可以直接在既有的圆括号内(如在函数调用中)使用生成器推导时,无需再添加一对圆括号。

L = [x*x for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

g = (x*x for x in range(10))  # <generator object <genexpr> at 0x052AF8F0>
print(next(g))  # 0

sum(i ** 2 for i in range(10))  # 285

递归式生成器

创建一个将两层嵌套列表展开的函数:

nested = [[1, 2], [3, 4], [5], 6]

def flatten(nested):
    try:
        for sub in nested:
            for ele in sub:
                yield ele
    except TypeError:
        yield sub
            
f = flatten(nested)
next(f)  # 1
# print(list(f))  # [2, 3, 4, 5, 6]

for i in f3:
    print(i)  # 2 3 4 5 6

创建一个将任意层嵌套列表展开的函数:

对一层列表进行遍历,遍历下层列表的时候,先对一层遍历出来的元素再调用一次 flatten 函数,这时,如果是不可再迭代的对象的话,就会报 TypeError 错误,捕捉到之后,yeild 返回,继续下一个;如果是可迭代的话,就递归下去;

def flatten(nested):
    try:
        for sub in nested:
            for ele in flatten(sub):
                yield ele
    except TypeError:
        yield nested
        
nested = [[[1], 2], 3, 4, [5, [6, 7]], 8]
print(list(flatten(nested)))

不过,上面要注意的是:前面也提到了,字符串对象也是可迭代的,而且一般我们也不会将它拆开。更重要的是,字符串的第一个元素是一个长度为 1 的字符串,而长度为 1 的字符串的第一个元素是字符串本身。

s = 'ABCD'
s2 = s[0]  # 'A'
s2[0]  # 'A'

这样子会造成无穷递归的。所以还需要检查一下对象是否类似于字符串:

def flatten(nested):    
    try:
        if isinstance(nested, str): raise TypeError
            
        for sub in nested:
            for ele in flatten(sub):
                yield ele
    except TypeError:
        yield nested
        
nested = [[[1], '23'], 3, '43', [5, [6, '73']], 8]
print(list(flatten(nested)))  # [1, '23', 3, '43', 5, 6, '73', 8]

不过,它有两个 yield 唉,这认哪个来着???pass

def flatten(nested):
	try:
		for sublist in nested:
			for element in flatten(sublist):
				print("element:", element)
				yield element
	except TypeError:
		print("nested :", nested)
		yield nested
		
print(list(flatten([[1, 2], [3, 4], [5], 6])))

输出:

nested : 1
element: 1
element: 1
    
nested : 2
element: 2
element: 2
    
nested : 3
element: 3
element: 3
    
nested : 4
element: 4
element: 4
    
nested : 5
element: 5
element: 5
    
nested : 6
element: 6
[1, 2, 3, 4, 5, 6]

今天的分享就到这里啦,最后祝大家天天进步!!学习Python最重要的就是心态。我们在学习过程中必然会遇到很多难题,可能自己想破脑袋都无法解决。这都是正常的,千万别急着否定自己,怀疑自己。如果大家在刚开始学习中遇到困难,想找一个python学习交流环境,可以加入我们,领取学习资料,一起讨论

 


版权声明:本文为m0_64355682原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。