主要内容：
1、生成器和生成器表达式
2、列表推导式

一、生成器

  • 生成器实质就是迭代器，在python中有三种方式来获取生成器
  • 通过生成器函数
  • 通过各种推导式来实现生成器
  • 通过数据转换也可以获取生成器

首先我们看下一个简单的函数：

def func():
    print(1)
    return 2

ret = func()
print(ret)
结果：
1
2

然后将return 替换成yield，yield就是生成器

def func():
    print(1)
    yield 2

ret = func()
print(ret)
结果：
<generator object func at 0x0000000002236CF0>

替换成yield之后，运行的结果就大不相同，因为函数中存在yield，那么这个函数就是一个生成器函数，这个时候我们再执行这个函数，那就不是简单的函数执行了，而且获取这个生成器，使用方法就是采用 next()来执行生成器。

  • 例：
def func():
    print(1)
    yield 2

ret = func()	#这个时候函数不会执行，而是获取生成器
s = ret.__next__()	#这个时候函数才会执行，yield的作用和return一样，也返回数据
print(s)
结果：
1
2
  • return和yield的效果一样，但yield可以分段来执行一个函数，return则是直接终止了函数的执行
def func():
    print(1)
    yield 11
    print(2)
    yield 22
    print(3)
    yield 33

ret = func()	#这个时候函数不会执行，而是获取生成器
s = ret.__next__()
print(s)
s1 = ret.__next__()
print(s1)
s2 = ret.__next__()	
print(s2)
s3 = ret.__next__()	#报错：StopIteration
print(s3)		
结果：
1
11
2
22
3
33
StopIteration

当程序执行完最后一个yield，那么继续执行__next__()程序将会报错

  • 生成器有什么作用呢，我需要分配一万个token，有二种方式：
  • 使用for循环一次性生成出来
def token():
	lst = []
	for i in range(0,10000):
		lst.append('token'+str(i))
	return lst
t = token()
  • 那么问题来了，目前token需要量没那么多，但一次性分配那么多出来，造成浪费。采取yield生成器来编写
def token():
	for i in range(0,10000):
		yield 'token'+str(i)		
t = token()
print(t.__next__())
print(t.__next__())
print(t.__next__())
  • 区别：
  • 第一种是使用for循环，直接一次性全部拿出来，会很占内存。
  • 第二种使用生成器，一次就拿一个，需要多少生成多少，生成器是一个一个指下去的，__ next__()到哪，指针就指到哪，下一次继续获取指针指向的值

接下来我们了解下send()方法，send()和__next__()一样，都可以让生成器执行到下一个yield

def func():
    print(1)
    a = yield 11
    print(a)
    b = yield 22
    print(b)
    c = yield 33
    print(c)
    yield 'o'

f = func()	#获取生成器
f1 = f.__next__() 
print(f1)
f2 = f.send('111')
print(f2)
f3 = f.send('222')
print(f3)
f4 = f.send('444')
print(f4)
  • send()和__next__()的区别：
  • send()和__next__()都是让生成器向下执行一次
  • send()可以给上一个yield的位置传递值，但不能给最后一个yield传值 和 第一次执行生成器的时候不能使用send()

生成器可以使用for循环来循环获取内部的元素：

def func():
	print(111)
	yield 222
	print(333)
	yield 444
	print(555)
	yield 666
	
gen = func()
for i in gen:
print(i)

二、列表推导式
首先可以先看下这个代码：

lst = []
for i in range(1,10):
	lst.append(i)
print(lst)

转换成列表推导式后：

lst = [i for i in range(1,10)]
print(lst)
  • 列表推导式是通过一行代码来构建我们想要的列表，列表推导式看起来代码简单，但如果出现错误之后很难进行排查
  • 列表推导式的常用写法：
  • [结果 for 变量 in 可迭代对象]
  • 我们还可以对列表中的数据进行筛选
  • 筛选写法：[结果 for 变量 in 可迭代对象 if 条件]
lst = [i for i in range(1,10) if i%2==0 ]
print(lst)

生成器表达式和列表推导式的语法基本上是一样的. 只是把[]替换成()

lst =(i for i in range(1,10))
print(lst)

打印结果就是一个生成器：<generator object <genexpr> at 0x00000000025E6CF0>
我们可以使用for循环来循环这个生成器：

lst =(i for i in range(1,10))
for i in lst:
	print(i)

生成器表达式也可以进行筛选：
lst =(i for i in range(1,10) if i%2==0)
for i in lst:
	print(i)
  • 生成器表达式和列表推导式的区别：
  • 列表推导式比较耗内存，一次性加载，生成器表达式几乎不占用内存，使用的时候才会分配和使用内存
  • 得到的值不一样，列表推导式得到的是一个列表，生成器表达式得到的是一个生成器

需要注意的深坑==> 生成器，要值得时候才拿值。

字典推导式：

  • 根据名字应该也能猜到，推导出来的是字典
# 把字典中的key和value互换
dic = {'a': 1, 'b': '2'}
new_dic = {dic[key]: key for key in dic}
print(new_dic)

# 在以下list中. 从lst1中获取的数据和lst2中相对应的位置的数据组成一个新字典
lst1 = ['a', 'b', 'c']
lst2 = ['1', '2', '3']
dic = {lst1[i]: lst2[i] for i in range(len(lst1))}
print(dic)

结果：
{'2': 'b', 1: 'a'}
{'a': '1', 'b': '2', 'c': '3'}

集合推导式:

  • 集合推导式可以帮我们直接生成一个集合， 集合的特点: 无序, 不重复. 所以集合推导式自带去重功能
lst = [1, -1, 8, -8, 12]
# 绝对值去重
s = {abs(i) for i in lst}
print(s)
  • 总结: 推导式有, 列表推导式, 字典推导式, 集合推导式, 没有元组推导式
  • 生成器表达式: (结果 for 变量量 in 可迭代对象 if 条件筛选)
  • 生成器表达式可以直接获取到生成器对象. 生成器对象可以直接进行for循环. 生成器具有惰性机制.