2022年 11月 5日

Python生成器表达式

语法

  • (返回值 for 元素 in 可迭代对象 if 条件)
  • 列表解析式的中括号换成小括号就行了
  • 返回一个生成器，生成器也是一个对象，属于中间值
  • g = (i ** 2 for i in range(5)) # 将使用生成器表达式得到的生成器对象赋给一个变量g
print(g)

'''输出：
<generator object <genexpr> at 0x109835b10>
'''
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

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

  • 可迭代对象：

    • 能够通过迭代一次次返回不同的元素的对象。
    • 所谓相同，不是指值是否相同，而是元素在容器中是否是同一个，例如，列表中值可以重复的，[‘a’, ‘a’]，虽然这个列表有2个元素，值一样，但是两个’a’是不同的元素
    • 可以迭代，但是未必有序，未必可索引（只有序列才有序，才可索引）
    • 可迭代对象有:list、tuple、string、bytes、bytearray、range、set、dict、生成器等
      其中序列有：list、tuple、string、bytes、bytearray
    • 成员操作符in、not in，in本质上就是在遍历对象
    • 3 in range(10)
3 in (x for x in range(10))
3 in {x:y for x,y in zip(range(4),range(4,10))}
      • 1
      • 2
      • 3

  • 迭代器

    • 迭代器是特殊的对象，一定是可迭代对象，具备可迭代对象的特征
    • 但是一个可迭代对象却不一定是迭代器，例如：列表list
    • 判断一个可迭代对象是否是迭代器：通过next()方法，迭代一个迭代器对象
    • 通过iter()方法把一个可迭代对象封装成迭代器
    • <迭代器对象从头到尾全都取完一遍值之后，不能再回头取值了

  • 生成器

    • 一个生成器对象一定是迭代器对象，是可迭代的;但是一个迭代器对象不一定是生成器对象；生成器和迭代器是两个不同的对象
  • # 使用内建函数next()判断一个可迭代对象是否是迭代器，只有迭代器才可以使用next()方法取值
# 判断列表是否是一个迭代器
lst = [i ** 2 for i in range(1, 4)]
print((next(lst))
    
'''输出：
TypeError: 'list' object is not an iterator  说明列表不是一个迭代器，只有迭代器才可以使用next()方法取值
'''

# 判断生成器是否是一个迭代器
g = (i ** 2 for i in range(1, 4)) 
print(next(g))
print(next(g))
print(next(g))

'''输出：
1
4
9
说明生成器是一个迭代器
'''

# 判断range对象是否是一个迭代器
r = range(4)
print(next(r))

'''输出：
TypeError: 'range' object is not an iterator
说明range对象不是迭代器
'''
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
  • # 使用内建函数iter()可以将一个可迭代对象封装为一个迭代器
# 将列表封装为一个迭代器
lst = [i ** 2 for i in range(1, 4)]
i = iter(lst)
print(next(i))
print(next(i))
print(next(i))
       
'''输出：
1
4
9
'''
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
  • lst = [i ** 2 for i in range(1, 4)]
i = iter(lst) # 此处将lst这个列表封装为一个迭代器，变量i指向了这个迭代器
print(next(i))
print(next(i))
i = iter(lst) # 此处再次将lst封装为另外一个迭代器，而变量i此时则指向了这个新封装出来的迭代器
print(next(i)) # 所以在这里是从新的迭代器中取值，取出来的第一个值是1
      
'''输出：
1
4
1
'''
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
  • g = (i for i in range(4)) # 创建一个生成器
print(next(g)) # 从生成器中取出第一个值
print('~~~~~~')
for i in g: # 使用for循环依次取出生成器中的其它值，注意：因为已经将第一个值取出了，所以这里会从第二个值开始取，直到生成器中的值全部取值，就会退出for循环，不会抛异常
	print(i)
print('~~~~~~')
for j in g: # 在上一个for循环中已经将这个生成器中的值全部取出，for循环自动的不会再从生成器中取值，也就是说不会再进入这个for循环，所以这个for循环就不会再有任何输出，也不会抛异常
	print(j)
print('~~~~~~')
# print(next(g)) # 如果要在生成器中的值全部取出后，使用next()强行继续取值，就会抛StopIteration异常
'''输出:
1
4
1
'''
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

生成器表达式和列表解析式的区别

  • 生成器表达式 列表解析式
    按需计算（或称惰性求值、延迟计算），即需要的时候才计算值，可以简单的理解为，每次向生成器对象中要一个元素，这个生成器对象才会返回一个元素 立即返回值
    返回生成器，生成器也是迭代器，可以迭代 返回的是可迭代对象：列表
    返回的生成器从头到尾全都取完一遍值之后，不能再回头取值了 从头到尾全都取完一遍值之后，可以从头重新取值