【Python基础】day10——生成器

列表生成器（式）

示例一：

a=[x for x in range(30)]                  #这行代码就是列表生成器，执行顺序就是先执行后面的for循环，然后执行前面的x

print(a)

执行结果：

[0, 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]

Process finished with exit code 0

示例二：

a=[x*2 for x in range(30)]

print(a)

执行结果：

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58]

Process finished with exit code 0

示例三：

def f(n):
    return n*n

a=[f(x) for x in range(30)]

print(a)
print(type(a))

执行结果：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841]
<class 'list'>

Process finished with exit code 0

变量赋值的另外一种形式：

t=(123,'a')
a,b=t
print(a)
print(b)

执行结果：

123
a

Process finished with exit code 0

上图这种赋值形式相当于a=t[0],b=t[1]

影响程序执行快慢最主要的两个因素：

• CPU

• MEM

将上例中的列表生成式中的 [] 转换成 () 就将列表生成式转换成了生成器

a=(x*2 for x in range(30))

print(a)
print(next(a))
print(next(a))
print(next(a))
print(next(a))

执行结果：

<generator object <genexpr> at 0x00000236B7D59200>              #从这里可以看出来，我们的内容是生成器
0
2
4
6

Process finished with exit code 0

generator object——生成器对象

生成器就是一个可迭代对象Iterable

a=10
a=5
b=a

• 对于变量的值的变化，当变量从10变成5之后，10这个值就将在内存中被冲掉，也就是内存会将没有变量指向的值从内存中冲掉，以留出空闲的空间给新的变量值存储。

生成器的两种创建方式：

• (x*2 for x in range(30))
• yield关键字

yield创建生成器示例：

def foo():
    yield 1

print(foo)
print(foo())

执行结果：

<function foo at 0x0000019527683E18>              #这里只的是foo本身，foo本身是仍然是一个函数
<generator object foo at 0x0000019527879200>      #但是使用foo()表示执行了这个函数，这时候就生成一个生成器对象了

Process finished with exit code 0

从上面的代码可以看出，foo在加上()之后就已经不再是一个函数，而是由函数转换为一个生成器对象了，跟函数的区别就是不再执行函数中的程序了，只是一个生成器对象

def foo():
    print("ok")
    yield 1

rst=foo()
print(rst)                     #这里并没有执行，也就是说明了生成器对象不会执行函数内部的程序
print("---")
next(rst)                      #这里使用next函数的时候，才会将生成器中的内容打印出来

执行结果：

<generator object foo at 0x000001ACFB549200>
---
ok

Process finished with exit code 0

程序执行顺序：

• 上图是一个gif图片，从上图Debug过程中可以看出整个程序的执行顺序
• 对于含有yield关键字的生成器，在第一次使用next的时候，返回函数，打印生成器的第一个值；第二次使用next的时候，会打印上一个值后面的内容，也就是从yield 1 开始，打印no。

def foo():
    print("ok")
    yield 1
    print("no")
    yield 5

for i in foo():
    print(i)

执行结果：

ok
1                  #这里的1是 yield 1 返回的结果
no
5

Process finished with exit code 0

• 可以调用next的对象才是迭代器，像列表只是一个可迭代对象，并不是迭代器
• for后面跟的是可迭代对象，并不都是迭代器
• 内部有iter方法的才是可迭代对象
• 列表、元组、字典都是可迭代对象

斐波那契数列：

def fibo(max):
    n,before,after = 0,0,1
    while n<max:
        print(after)
        before,after = after,before+after
        n = n+1
    return after

print(fibo(8))

执行结果：

1
1
2
3
5
8
13
21
34

Process finished with exit code 0

yield编写生成器

def fibo(max):
    n,before,after = 0,0,1
    while n<max:
        yield before
        before,after = after,before+after
        n = n+1

fi=fibo(8)
print(fi)

print(next(fi))
print(next(fi))
print(next(fi))
print(next(fi))
print(next(fi))
print(next(fi))
print(next(fi))
print(next(fi))

执行结果：

<generator object fibo at 0x000001D40E519200>
0
1
1
2
3
5
8
13

Process finished with exit code 0

程序执行顺序：

• 因为生成器不会执行生成器对象（也就是函数体）内部的程序，那么如果想执行生成器对象内部的程序的话，就需要使用next调用

生成器的send方法

• send跟next方法类似，都是可以执行生成器内部的程序，但是send比next优势的地方就是，可以向生成器内部传参数
• send括号中的参数，就是赋给yield前面的值

def bar():
    x=yield 1
    print(x)
    yield 2

b=bar()

rst1=b.send(None)        #相当于next(b)  第一次send如果没有next,就只能传一个send(None)
print(rst1)              #1
rst2=b.send('yuyang')    #yuyang  这里因为有send所以会执行生成器内部的程序，程序中有print变量x所以会打印出来yuyang
print(rst2)              #2

执行结果：

1
yuyang
2

Process finished with exit code 0

执行截图：

• 从上面的执行顺序中可以看到，在第一次走send的时候，开始执行生成器内部的程序，但是第一次执行的时候，并没有执行print(x)所以，第一次不需要赋值，第二次执行send的时候，就可以在send后面的括号里面赋值了

生成器对象相比函数的一个优势：

• 在打印生成器内部的内容的时候，如果先打印第一个值、第二个值，然后程序做了一些其他的事情，这时候再次打印生成器内部的值的时候，会接着第三个值打印，但是如果是函数的话，每次打印都是从头开始了

生成器在创建的时候，已经决定了能计算出值的个数，调用next的次数超过这个值，就会报StopIteration

遍历所有元素可以通过for循环，for循环内部做的几件事：

1. 调用对象的iter()方法，返回一个迭代器对象
2. while循环，不断循环next
3. 错误捕捉，异常处理