Python基础-容器,迭代器,可迭代对象,生成器

Python基础知识学习-3

教程来自：知乎专栏: https://zhuanlan.zhihu.com/p/319402935

Python中文指南1.0 https://python.iswbm.com/

1.容器contain

容器就是存储某些元素的统称，它最大的特性就是判断一个元素是否在这个容器内。

在 Python 中，我们通常使用 in 或 not in 来判断一个元素存在/不存在于一个容器内。

str、list、tuple、set、dict 都可以通过 in 或 not in 来判断一个元素是否在存在/不存在这个实例中，所以这些类型我们都可以称作「容器」

那为什么这些「容器」可以使用 in 或 not in 来判断呢？

这是因为它们都实现了 contains 方法。

class A:

    def __init__(self):
        self.items = [1, 2]

    def __contains__(self, item):
        return item in self.items

a = A()
print(1 in a)   # True
print(2 in a)   # True
print(3 in a)   # False

__init__函数（方法）

在Python中定义类经常会用到__init__函数（方法），首先需要理解的是，两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问。而__init__函数（方法）支持带参数类的初始化，也可为声明该类的属性（类中的变量）。

__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。

__init__()方法又被称为构造器（constructor）

def __init__(self, width, height, depth):
        self.width = width
        self.height = height
        self.depth = depth

在这个例子中，类 A 定义了 contains 方法，所以我们就可以使用 1 in a 的方式去判断这个元素是否在 A 这个容器内。

换句话说，一个类只要实现了 contains 方法，那么它就是一个「容器」。

输出容器内的所有元素：例如执行 for x in [1, 2, 3]，就可以迭代出容器内的所有元素。

那使用这种方式输出元素，是如何实现的？这就跟「迭代器」有关了。

2.可迭代对象

可以利用 for 循环的对象，都叫可迭代对象。

譬如我们前面学过的 列表、元组、字典、字符串等都是可迭代对象。

判断是否可迭代？

Python 内置的 collections.abc 模块，在这个模块中提供了一个 Iterable 类，可以用 isinstance 来判断。但是这种方法并不是百分百准确，最准确的方法，还是应该使用 for 循环

>>> from collections.abc import Iterable
>>>
>>> isinstance([0, 1, 2], Iterable) # 列表
True
>>> isinstance({"name": "王炳明"}, Iterable) # 字典
True
>>> isinstance((1,2,3), Iterable) # 元组
True
>>> isinstance("hello", Iterable) # 字符串
True

3.迭代器iterator

当你对一个可迭代对象使用 iter 函数后，它会返回一个迭代器对象，对于迭代器对象，我们可以使用 next 函数，去获取元素，每执行一次，获取一次，等到全部获取完毕，会抛出 StopIteration 提示无元素可取。

一个对象要想使用 for 的方式迭代出容器内的所有数据，这就需要这个类实现「迭代器协议」。

也就是说，一个类如果实现了「迭代器协议」，就可以称之为「迭代器」。

什么是「迭代器协议」呢？

在 Python 中，实现迭代器协议就是实现以下 2 个方法：

• __iter__：这个方法返回对象本身，即 self
• __next__：这个方法每次返回迭代的值，在没有可迭代元素时，抛出 StopIteration

下面我们来看一个实现迭代器协议的例子：

>>> alist = [0, 1, 2, 3]
>>> gen = iter(alist)
>>> gen
<list_iterator object at 0x100a94b20>
>>> next(gen)
0
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
3
>>> next(gen)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration #没有可迭代元素了

4.生成器Generator

生成器Generator 是一个可以像迭代器那样使用for循环来获取元素的函数。「生成器」是一个特殊的「迭代器」，并且它也是一个「可迭代对象」。生成器的出现（Python 2.2 +），实现了延时计算，从而缓解了在大量数据下内存消耗过猛的问题。

当你在 Python Shell 中敲入一个生成器对象，会直接输出 generator object 提示你这是一个生成器对象

>>> gen = (i for i in range(5))
>>> gen
<generator object <genexpr> at 0x10cae50b0>

创建生成器：

我们使用列表推导式时是下面这样子，使用 [] ，此时生成的是列表。

>>> mylist = [i for i in range(5)]
>>> mylist
[0, 1, 2, 3, 4]

而当你把 [] 换成 () ，返回的就不是列表了，而是一个生成器

>>> gen = (i for i in range(5))
>>> gen
<generator object <genexpr> at 0x10cae50b0>

使用 yield

yield 是什么东西呢? 它相当于我们函数里的 return，但与 return 又有所不同。普通的return是什么意思，就是在程序中返回某个值，返回之后程序就不再往下运行了。看做return之后再把yield看做一个是生成器（generator）的一部分（带yield的函数才是真正的迭代器）

• 当一个函数运行到 yield 后，函数的运行会暂停，并且会把 yield 后的值返回出去。
• 若 yield 没有接任何值，则返回 None
• yield 虽然返回了，但是函数并没有结束

更详细的解释，参考这一篇：https://blog.csdn.net/mieleizhi0522/article/details/82142856

def foo():
    print("starting...")
    while True:
        res = yield 4
        print("res:",res)
g = foo()
print(next(g))
print("*"*20)
print(next(g)) 

#代码输出--------------
starting... #对print(next(g))的执行；这是我们定义的foo函数中的print的内容
4 #res = yield 4，函数内返回的结果
******************** #对print("*"*20)的执行
res: None #对print(next(g))执行，但是从程序暂停的地方开始执行的，但是赋值操作的右边是没有值的，res:None
4 #继续在while里执行，又一次碰到yield,这个时候同样return 出4，然后程序停止，print函数输出的4就是这次return出的4.

“解释代码运行顺序，相当于代码单步调试：

1.程序开始执行以后，因为foo函数中有yield关键字，所以foo函数并不会真的执行，而是先得到一个生成器g(相当于一个对象)

2.直到调用next方法，foo函数正式开始执行，先执行foo函数中的print方法，然后进入while循环

3.程序遇到yield关键字，然后把yield想想成return,return了一个4之后，程序停止，并没有执行赋值给res操作，此时next(g)语句执行完成，所以输出的前两行（第一个是while上面的print的结果,第二个是return出的结果）是执行print(next(g))的结果，

4.程序执行print(“*”20)，输出20个

5.又开始执行下面的print(next(g)),这个时候和上面那个差不多，不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，也就是要执行res的赋值操作，这时候要注意，这个时候赋值操作的右边是没有值的（因为刚才那个是return出去了，并没有给赋值操作的左边传参数），所以这个时候res赋值是None,所以接着下面的输出就是res:None,

6.程序会继续在while里执行，又一次碰到yield,这个时候同样return 出4，然后程序停止，print函数输出的4就是这次return出的4.

到这里你可能就明白yield和return的关系和区别了，带yield的函数是一个生成器，而不是一个函数了，这个生成器有一个函数就是next函数，next就相当于“下一步”生成哪个数，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从foo函数的开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，此步就结束。”

为什么用Generator

为为什么用这个生成器，是因为如果用List的话，会占用更大的空间，比如说取0,1,2,3,4,5,6…………1000

你可能会这样：

for n in range(1000):
    a=n

这个时候range(1000)就默认生成一个含有1000个数的list了，所以很占内存。

这个时候你可以用刚才的yield组合成生成器进行实现，它们以一种惰性（lazy）的方式生成值，逐个产生并返回，而不是一次性生成一个大的序列。

def foo(num):
    print("starting...")
    while num<10:
        num=num+1
        yield num
for n in foo(0):
    print(n)

Generator使用

从一个生成器对象中取出元素，和我们前面学过的通过切片slide访问列表中的元素不一样，它没有那么直观。

想要从生成器对象中取出元素，只有两种方法：

第一种方法：使用 next 方法一个一个地把元素取出来，如果元素全部取完了，生成器会抛出 StopIteration 的异常。

>>> gen = (x for x in range(3))
>>> gen
<generator object <genexpr> at 0x1072400b0>
    >>> next(gen)
    0
    >>> next(gen)
    1
    >>> next(gen)
    2
    >>> next(gen)
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
StopIteration

第二种方法：使用 for 循环一个一个地迭代出来

>>> gen = (x for x in range(3))
>>> for i in gen:
    ...     print(i)
...
0
1
2

生成器的激活

生成器对象，在创建后，并不会执行任何的代码逻辑。

想要从生成器对象中获取元素，那么第一步要触发其运行，在这里称之为激活。

方法有两种：

1. 使用next() ：上面已经讲过
2. 使用generator.send(None)

还以下面这段代码为例，可以看到 gen.send(None) 相当于执行了 next(gen)

>>> def generator_factory(top=5):
    ...     index = 0
...     while index < top:
    ...         print("index 值为: " + str(index))
...         index = index + 1
...         yield index
...     raise StopIteration
...
>>>
>>> gen = generator_factory()
>>> gen.send(None)
index 值为: 0
1
>>> gen.send(None)
index 值为: 1
2

生成器的状态

生成器在其生命周期中，会有如下四个状态

• GEN_CREATED # 生成器已创建，还未被激活
• GEN_RUNNING # 解释器正在执行（只有在多线程应用中才能看到这个状态）
• GEN_SUSPENDED # 在 yield 表达式处暂停
• GEN_CLOSED # 生成器执行结束