可以直接作用于for循环的对象统称为可迭代对象

写在前言

1.迭代

在理解生成器之前,先理解迭代。

 

必威 1

1、List Conprehensions

列表生成式是python中内置的用来创建list的表达式、
如果我们要生成简单的list可以直接使用range函数来完成。

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

但是有时候我们要生成复杂的list怎么办呢?比如我们生成一个[1^2, 2^2, 3^2...]的list。

>>> my_list = []
>>> for item in range(10):
...     my_list.append(item * item)
...
>>> my_list
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>>

上面的代码都不够简洁,python中的列表生成式可以一行解决。

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

在书写生成式表达式时,将要生成的元素放在前面,后面是for循环。
还可以在创建列表的同时进行简单的过滤。

>>> [x * x for x in range(10) if x%2 == 0]
[0, 4, 16, 36, 64]
>>>

还可以实现全排列

>>> [(x,y) for x in '123' for y in '456']
[('1', '4'), ('1', '5'), ('1', '6'), ('2', '4'), ('2', '5'), ('2', '6'), ('3', '4'), ('3', '5'), ('3', '6')]
>>>

经常会看见,python函数中带有yield关键字,那么yield是什么,有什么作用?

1.1 迭代

如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们称为迭代(Iteration)

alist = [1, 2, 3, 4, 5]

for i in alist:
    print(i)

1
2
3
4
5

正如将列表中的元素通过for循环,遍历了整个alist列表,这种不重复地便利其内部的每一个子项的行为就是迭代。

系列文章 -- ES6笔记系列

Yield

2、Iterables

当我们创建了一个列表,我们可以依次遍历它,依次遍历的过程就是迭代。

>>> my_list = [1, 2, 3]
>>> for i in my_list:
...     print i
...
1
2
3

my_list就是一个可迭代对象,当我们使用上面说的列表生成式创建一个列表时,该列表也是一个可迭代的。

>>> my_list = [x * x for x in range(3)]
>>> for i in my_list:
...     print i
...
0
1
4

对于任何可迭代的对象都可以使用for in来进行迭代。
但是这样做有一个缺点就是:当我们的数据非常多的时候比如一个大列表,这个列表将会被读到内存中,会占用非常多的内存,有时候硬件是达不到的。

 

1.2 可迭代对象

可以直接作用于for循环的对象统称为可迭代对象:Iterable,可迭代对象一般都实现了__iter()__方法,可迭代对象通过其内建的方__iter()__返回一个迭代器对象。

a_iterable = [1, 2, 3]

a_iterator = iter(a_iterable)  # 将可迭代对象转化为迭代器

next(a_iterator)

1

next(a_iterator)

2

next(a_iterator)

3

 

基础概念

3、 Generators

对一个包含大量数据的列表,不仅占用很大的内存,如果我们使用到的就只有某一小部分数据就会导致内存的浪费。
如果列表中的元素可以根据某种算法推导出来,而不是将所有元素都存放在列表中,从而可以节省很多内存空间。这样一边循环一边计算的机制叫做生成器(Generator)。
创建一个Generator直接可以将上面的列表生成式的[]换成()就可以了。python中提供了生成器表达式,它是对列表和生成器的一种泛化,生成器表达式在运行的时候,并不会将整个输出序列都呈现出来,而是会估值为迭代器,这个迭代器每次可以根据生成器表达式产生一项数据。

>>> L1 = [x * x for x in range(10)]
>>> L2 = (x * x for x in range(10))
>>> L1
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> L2
<generator object <genexpr> at 0x000000000347F7E0>
>>>

从打印结果可以看出L2是一个Generator,可以使用next()方法打印每一个元素。

>>> L2.next()
0
>>> L2.next()
1
>>> L2.next()
4
>>> L2.next()
9
>>> L2.next()
16
>>> L2.next()
....
>>> L2.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

如果没有元素了就会抛出异常。
Generator也是可迭代的,但是只能迭代一次。

>>> L2 = (x * x for x in range(10))
>>> for i in L2:
...     print i
...
0
1
4
9
16
25
36
49
64
81
>>>

答案:可以理解yield是一个生成器;

1.3 迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator,迭代器其内实现了__iter__方法和__next__方法,for循环本质是通过调用可迭代对象的__iter__方法,该方法返回一个迭代器对象,再用__next__方法遍历元素

定义一个迭代器:

class MyRange:
    def __init__(self, end):
        self.index = 0
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < self.end:
            val = self.index
            self.index += 1
            return val
        else:
            raise StopIteration()

my_range = MyRange(3)

print([i for i in my_range])

[0, 1, 2]

print([i for i in my_range])

[]

迭代器只能迭代一次,每次调用调用 next() 方法就会向前一步,不能后退,所以当迭代器迭代到最后时,就不可以重复利用,所有需要将迭代器和可迭代对象分开定义

修改上面的可迭代对象:

class MyRange:
    def __init__(self, end):
        self.end = end

    def __iter__(self):
        return MyIterator(self.end)

class MyIterator:
    def __init__(self, end):
        self.index = 0
        self.end = end

    def __iter__(self):
        return self    

    def __next__(self):
        if self.index < self.end:
            val = self.index
            self.index += 1
            return val
        else:
            raise StopIteration()

my_range = MyRange(3)

print([i for i in my_range])

[0, 1, 2]

print([i for i in my_range])

[0, 1, 2]

接触过Ajax请求的会遇到过异步调用的问题,为了保证调用顺序的正确性,一般我们会在回调函数中调用,也有用到一些新的解决方案如Promise相关的技术。

在异步编程中,还有一种常用的解决方案,它就是Generator生成器函数。顾名思义,它是一个生成器,它也是一个状态机,内部拥有值及相关的状态,生成器返回一个迭代器Iterator对象,我们可以通过这个迭代器,手动地遍历相关的值、状态,保证正确的执行顺序。

可迭代对象

python中,一般能够被for循环遍历的对象就是可迭代对象。
拥有__iter__()方法的对象称之为可迭代对象,__iter__()方法返回一个迭代器。

4、生成器和迭代器区别

迭代器是一个更普遍的概念,如果一个类中有next()方法和返回自身return self__iter__()方法,这个类的对象就是一个Iterator
所有的生成器是一个迭代器,但是反过来就不是。生成器通过调用具有一个或多个yield表达式(在Python 2.5和更早版本中的yield语句)的函数构建。

>>> def squares(start, stop):
...     for i in range(start, stop):
...             yield i * i
...
>>>
>>> generator = squares(1, 3)
>>> generator
<generator object squares at 0x000000000347F7E0>
>>>

当然还可以使用生成器表达式直接生成一个Generator。
但是有时候你需要一个定制的迭代器,定义一个类,该类实现next() 和 __iter__()方法就可以。

class Squares(object):
    def __init__(self, start, stop):
        self.start = start
        self.stop = stop
    def __iter__(self):
        return self
    def next(self):
        if self.start >= self.stop:
            raise StopIteration
        current = self.start * self.start
        self.start += 1
        return current

作用:遇到yield关键字,函数会直接返回yield值,相当于return;不同的是下次调用的时候会从yield之后的代码开始执行。

2. 生成器

生成器与可迭代对象、迭代器的关系

必威 2

图片来自Iterables vs. Iterators vs. Generators

生成器对象,在每次调用它的next()方法时返回一个值,直到它抛出StopInteration。

生成器是可以迭代的,但是你 只可以读取它一次 ,因为它并不把所有的值放在内存中,它是实时地生成数据, 可以用生成器表达式创建:

my_generator = (x ** 2 for x in range(3))

my_generator

<generator object <genexpr> at 0x7f975b7a4af0>

for i in my_generator:
    print(i)

0
1
4

yield

可以写一个普通的包含yield语句的Python函数,Python会检测对yield的使用并将函数标记为一个生成器,当函数执行到yield语句时,像return语句那样返回一个值,但是解释器会保存对栈的引用,它会被用来在下一次调用next时恢复函数。

def my_generator():
    yield 1
    yield 2
    yield 'a'
    yield 'generator'

g = my_generator()

g

<generator object my_generator at 0x7f975b7a4d58>

next(g)

1

next(g)

2

next(g)

'a'

next(g)

'generator'

next(g)

---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

<ipython-input-12-5f315c5de15b> in <module>()
----> 1 next(g)


StopIteration: 

上面的例子中,每次调用next()开始实时地生成数据,并返回,因此生成器只可读取一次,上次执行读取的值在下次执行中就无法读取。当整个生成器的值都被读取后,在调用机会出现StopIteration的错误。

def my_gen():
    for i in range(5):
        yield i ** 3

my_gen()

<generator object my_gen at 0x7f975ae15a40>

mygen = my_gen()

for i in mygen:
    print(i)

0
1
8
27
64

每次执行到yield语句,则返回一个值,再执行的时候从上次停下来的地方开始执行。yield语句保存了上次执行后的状态,下次执行不是从头开始,而是从上次的状态开始。

当调用my_gen()这个函数的时候,函数内部的代码不会立即执行,而是返回一个生成器对象,当利用for循环进行遍历的时候,函数内部的代码开始执行,执行到yield表达式返回一个值,记录当前状态并停下,下一次的访问时再从这个状态开始执行。

举一个不太恰当的例子,普通的函数就是没有存档的游戏,只要游戏开始,就玩到结尾,下一次再玩还是从头开始,而生成器就是加了存档,下次玩从上次存档的地方开始

 

迭代器

迭代器是访问集合内元素的一种方式。迭代器对象从集合的第一个元素开始访问,直到所有的元素都被访问一遍后结束。
可以使用工厂函数iter()返回一个迭代器。

>>> iter([1,2,3])
<listiterator object at 0x1100b6a50>
5、使用yield关键字创建生成器

如果一个函数包含了yield关键字,这个函数就是一个生成器。但是Generator和函数的执行流程是不一样的。函数是顺序执行,遇到return语句或者执行完毕后就返回,如果变成了Generator后,每次调用next()函数开始执行,遇到yield返回,下次接着从上次返回位置进行执行。

>>> def fun():
...     print 'run 1'
...     yield 1
...     print 'run 2'
...     yield 2
...
>>> g = fun()
>>> g.next()
run 1
1
>>> g.next()
run 2
2
>>> g.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

我们使用关键字yield定义了一个Generator,在执行的时候,遇到yield关键字就会返回,再次调用就从上次返回的地方开始。

本文由必威发布于必威-编程,转载请注明出处:可以直接作用于for循环的对象统称为可迭代对象

相关阅读