Python自动化开发学习4-2

Posted 2020-10-13

列表生成式

先看2段代码

a = [ i*2 for i in range(10) ]
print(a)
#
b = []
for i in range(10):
   b.append(i*2)
print(b)

a和b的效果一样，但是a使用的代码更加简洁

列表生成式也可以使用函数，生成更加复杂的列表

a = [ max(i,6) for i in range(10) ]
print(a)

上面的是铺垫，主要讲下面的生成器

生成器

用列表生成式，我们可以直接创建一个列表。等列表创建完之后，我们可以访问列表中的元素。但是这都得等列表生成完之后。如果列表很大很复杂，就需要耗费很长的时间和内存空间，然后我们才能访问列表中的元素。

如果列表元素可以按照某种算法推算出来，我们不必创建完列表在进行后续的操作，而是一边循环一边引用每一个新创建的元素。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

a = [ i*2 for i in range(10) ]
for i in a:
    print(i)
b = ( i*2 for i in range(10) )  # 这个是生成器
for i in b:
    print(i)
print(type(a),type(b))

上面的代码中，a和b的效果是一样的。但是a的机制是先生成完整列表，再执行for循环。而b中只是记录了一个算法，并没有生成任何数据。等到for循环调用b的时候，才一边循环一边计算每一个元素。

这里我们感觉不出两种机制的差别，但是当列表很大或者计算很复杂的情况下，就能发现两者的差别。我们强行来增加生成列表的时间。

import time
def f(n):
    time.sleep(1)
    return n*2
a = [ f(i) for i in range(10) ]
for i in a:
    print(i)
b = ( f(i) for i in range(10) )  # 这个是生成器
for i in b:
    print(i)

这下就发现区别了，a是等待了很长时间来生成列表，然后快速的把结果输出。而b是计算一个元素，输出一个元素，开始没有很长的等待时间，但是每次输出之间是要等待1秒来生成新的元素。

顺便我看了一下两者的效率，理论上是差不多的，但是测试下来a要耗时10.02秒，b要耗时10.005秒。每次结果会不同，但是都在这个数字级别。

import time
def f(n):
    time.sleep(1)
    return n*2
t = time.time()
a = [ f(i) for i in range(10) ]
for i in a:
    print(i)
print(time.time()-t)
t = time.time()
b = ( f(i) for i in range(10) )  # 这个是生成器
for i in b:
    print(i)
print(time.time()-t)

看来使用生成器，也是一个更加效率的方法。

生成器是一边循环一边计算的，所有的元素需要一个一个计算出来。只能一个一个的计算出来，并且只记住了当前的位置，在当前位置你只能取到下一个值，不能退回去，也不能跳过。

所以，生成器只有一个方法.__next__

b = ( i*2 for i in range(10) )
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
print(b.__next__())
# 超出范围会报错

上面好LOW，一般都用循环，__next__用的不是很多。

在继续之前，先用函数写一个斐波那契数列。

斐波那契数列指的是这样一个数列 1, 1, 2, 3, 5, 8, 13, 21，这个数列从第3项开始，每一项都等于前两项之和。

def fib(n):
    i,a,b = 0,0,1
    while i < n:
        print(b)
        a,b = b,a+b
        i += 1
    return "结束"
fib(10)

把上面的函数的print(b)替换成yield b，就实现了用函数做了一个生成器。

def fib(n):
    i,a,b = 0,0,1
    while i < n:
        #print(b)
        yield b  # 替换成这句
        a,b = b,a+b
        i += 1
    return "结束"
f = fib(10)
print(type(f))  # f的数据类型是generator

这是定义生成器的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个生成器。

生成器在语句执行遇到yield的时候会返回，但是会记住当前的位置，如果你使用.__next__()则会在之前的位置继续执行。也就是生成器在执行并且返回之后，并没有完全结束。跳出生成器后可以正常执行别的语句，在需要的时候再从之前生成器返回的位置继续执行下一次循环。这样的话生成器最后的return就没有意义了。接着看，我们先试着打印出生成器中的所有元素。

def fib(n):
    i,a,b = 0,0,1
    while i < n:
        #print(b)
        yield b
        a,b = b,a+b
        i += 1
    return "结束"
f = fib(10)
print(type(f))
print(f.__next__())
print("你可以随时插入你的语句")
print(f.__next__())
print("生成器会记住之前的位置继续循环")
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print("打了那么多就是要超出限制")
print(f.__next__())
print(f.__next__())

如果超出了继续取，就会报错。仔细看一下报错的内容，最后的StopIteration:后的内容就是你return的内容。我们可以用try来捕获这个错误从而获取return的值。try还没讲到，后面应该会细讲。

def fib(n):
    i,a,b = 0,0,1
    while i < n:
        #print(b)
        yield b
        a,b = b,a+b
        i += 1
    return "结束"
f = fib(10)
while 1:
    try:
        x = next(f)  # x = f.__next__()
        print(x)
    except StopIteration as e:
        print("返回值是：",e.value)
        break

这里x=next(f)和x=f,__next__()效果一样。这里上课没讲，暂时没发现有什么区别。

通过yield还可以实现单线程下的并行效果，这个不叫并行，叫协程。这里好烦，直接抄老师的例子了。

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield  # 这里中断，通过send传值进来继续执行
       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
def producer(name):
    c = consumer(‘A‘)  # 定义了一个consumer(‘A‘)，但是并没有运行
    c2 = consumer(‘B‘)  # 定义了一个consumer(‘B‘)
    c.__next__()  # consumer(‘A‘)启动运行，运行到yield之前，打印"准备吃包子啦"
    c2.__next__()  # consumer(‘B‘)启动运行
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)  # send是给yield传值
        c2.send(i)
producer("C")

上面的例子里.send(i)之前没提过，和.__next__()一样，但是sent可以传一个值回去。

上面的例子就是producer启动以后，又启动了2个consumer。consumer运行到yield中断，等待。producer将值通过send传给consumer后，consumer就执行一次循环，然后再中断，等待新的值传入。

迭代器

可直接作用于for循环的对象，统称为可迭代对象：Iterable。

使用下面这个方法可以判断一个对象是否迭代

from collections import Iterable
print(isinstance(‘‘,Iterable))  # 字符串可迭代
print(isinstance(123,Iterable))  # 数字不可迭代
print(isinstance((),Iterable))
print(isinstance([],Iterable))
print(isinstance({},Iterable))
print(isinstance((x for x in range(10)),Iterable))  # 这个是生成器，可迭代

生成器不但可以作用于for循环，还可以next，不断调用返回下一个值。

可以被__next__()调用并不断返回下一个值的对象称为迭代器：Iterator。

使用下面的方法再判断一下之前的对象是否是迭代器

from collections import Iterator
print(isinstance(‘‘,Iterator))
print(isinstance(123,Iterator))
print(isinstance((),Iterator))
print(isinstance([],Iterator))
print(isinstance({},Iterator))
print(isinstance((x for x in range(10)),Iterator))

只有最后一个可以__next__()，只有最后一个是True，是迭代器。

上面的这些可迭代对象，目前都不是迭代器。通过iter()就可以把这些可迭代对象变成迭代器。

from collections import Iterator
a = [1,2,3,4,5,6]
print(isinstance(a,Iterator))
b = iter(a)
print(isinstance(b,Iterator))
print(b.__next__())
print(b.__next__())
print(b.__next__())

Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。这样，迭代器甚至可以表示一个无限大的数据流。

我们的for循环，本质上就是通过不断调用next来实现的。