linux中的ll（转）

最近在学Python里异步IO中的协程，协程最初是由生成器变形的yield而来，感觉学完理解有些困难，故此再来回顾一下之前学习的生成器。在Python学习之初比较容易混淆可迭代对象、迭代器和生成器。因此，做以总结以辨析其中关键的区别。以下仅为习后个人理解，如有偏差，还请指出！

Talk is cheap,show me the picture!

解释之前，我们先来看一张概览图，下面是一张关于容器(container)、可迭代对象(Iterable)、迭代器(iterator)、生成器(generator)、生成器函数和生成器表达式的概览图。

一、容器(container)
【概述】：容器就是一个用来存储多个元素的数据结构
【特点】：
①容器中的元素可通过迭代获取。
②所有容器中的元素被存储在内存中。
【举例】：以下都是常见容器对象，他们都可以通过迭代获取，所以它们也是可迭代对象(Iterable)，我们暂且理解可迭代对象就是可以被迭代获取的对象。(注：并非所有容器对象都是可迭代对象)
首先引入如下模块：

from collections import Iterable # 可迭代对象  现在是 from collections.abc import Iterable

from collections import Iterator # 迭代器

1.列表(list)

title = ['Python','Java','C++']
for i in title:            # 通过for循环，迭代获取
    print(i)
isinstance(title,Iterable) # True

打印顺序：Python，Java，C++，True

2.元组(tuple)

title = ('Python','Java','C++')
for i in title:            # 通过for循环，迭代获取
    print(i)
isinstance(title,Iterable) # True

二、可迭代对象(Iterable)

【简述】：可迭代对象就是可以被迭代获取的对象。
【特点】：Iterable定义了可返回迭代器的__iter__()方法。
【举例】：

title = ['Python','Java','C++'] # 列表是一个可迭代对象
isinstance(title,Iterable)      # True
a = iter(title) # 由可迭代对象的iter方法返回一个迭代器
>>> next(a)
Python
>>> next(a)
Java
>>> next(a)
C++
>>> next(a)  # 抛出StopIteration异常

如果我们写出以下代码：

x = [1, 2, 3]
for elem in x:
...

则实际内部运行过程是这样的，列表x是一个可迭代对象，在for循环中经过iter()方法变为迭代器，然后遍历x实际就是内部调用elem = next(x)。

三、迭代器(Iterator)
【简述】：迭代器是一个带状态的对象。之所以说是带状态的对象是因为迭代器内部持有一个状态，该状态用于记录当前迭代所在的位置，以方便下次迭代的时候获取正确的元素。迭代器可以通过next()方法来迭代获取下一个值。
【特点】：
①Iterator实现了__iter__()和__next__()方法。
②迭代器不会一次性把所有元素加载到内存，而是需要的时候才生成返回结果(不同于容器)。
【举例】：和上面例子一样，下面的a就是一个迭代器，和可迭代对象title不同，a可以通过next(a)来逐个获取其中的每个元素。

title = ['Python','Java','C++'] # 列表是一个可迭代对象
isinstance(title,Iterable)      # True
a = iter(title) # 由可迭代对象的iter方法返回一个迭代器
>>> next(a)
Python
>>> next(a)
Java
>>> next(a)
C++
>>> next(a)  # 抛出StopIteration异常

如果使用next(title)则会报TypeError错，显示列表对象不是一个迭代器。

>>> next(title)
TypeError: 'list' object is not an iterator

迭代器每次调用next()方法的时候做两件事：

1. 为下一次调用next()方法修改状态
2. 生成当前调用的返回结果

四、生成器(generator)

【概述】：生成器(generator)是一种特殊的迭代器。
【特点】：
①生成器拥有迭代器的迭代传出数据的功能，但用关键字yield来替换迭代器中的__next__()方法来实现，而拥有yield关键字的函数就是生成器函数。
②生成器可以传入数据进行计算(不同于迭代器)，并根据变量内容计算结果后返回。
③迭代器不会一次性把所有元素加载到内存，而是调用的时候才生成返回结果(相同于迭代器，不同于容器)。
④可以通过for循环进行迭代(因为生成器是迭代器)
综上所述：生成器是迭代器的衍生物，但迭代器不是生成器，因为迭代器没有传入数据功能。

4.1 生成器函数(generator function)
【概述】：含有yield关键字的函数就是生成器函数。
【举例】：
1.生成器可以通过for循环迭代，这一点和迭代器中的next()函数功能相同，如下我们使用一个有限序列作为例子，如果是无限序列，则会无休止的循环下去

from collections.abc import Iterable,Iterator
def d():
    yield 1
    yield 2
    yield 3
    yield 4
for i in d():
    print(i)
print (type(d())) # generator
isinstance(d(),Iterator) # True
isinstance(d(),Iterable) # True

得到如下结果：（也可以看出生成器即是迭代器，也是可迭代对象）

2.以下我们展示一个传入和传出数据的例子。

def d():
    print('初始化')
    sum = 0
    value = yield sum
    sum = sum + value
    print('sum的值是：%d' % sum)
    value = yield sum
    sum = sum + value
    print('sum的值是：%d' % sum)
    value = yield sum
    sum = sum + value
    print('sum的值是：%d' % sum)
    return sum+1
c = d()          # c是一个生成器，此行代码并不运行d()内容
a = c.send(None) # 启动生成器，遇到d()的第一个yield时中断
print('生成器传出的值:%d' % a)
a = c.send(1)
print('生成器传出的值:%d' % a)
a = c.send(1)
print('生成器传出的值:%d' % a)

yield有中断的功能:

当运行a = c.send(None)时，启动生成器函数，在第一个yield中断，此时这行程序仅仅运行了yield sum并没有开始赋值，而yield sum就相当于return sum，即向函数外传出sum，所以函数外接收值的变量a存储的值是0。

当运行a = c.send(1)时，我们继续启动生成器函数开始运行value = yield，并向生成器函数的第一个中断点yield传递了值1，然后通过yield把1传递给了value并通过后续计算累加sum。程序直到第二个yield中断，向函数外返回第二个sum。以此类推。

所以执行结果如下：

初始化
生成器传出的值:0
sum的值是：1
生成器传出的值:1
sum的值是：2
生成器传出的值:2

【注】：
1）第一个send(None)填入的参数必须是None，因为在启动生成器函数到第一次中断，程序只运行到第一个yield sum，没有赋值语句，所以只能填None。
2）对于生成器函数最后的return sum语句并不向函数外传递sum，而是会在迭代结束时报错StopIteration: 3，返回值sum包含在StopIteration的value中，也就是3，可以捕获StopIteration在函数外得到这个值。把上面代码中的a = c.send(None)之后的代码改成如下代码即可。

while True:
    print('生成器传出的值:%d' % a)
    try:
        a = c.send(1)
    except StopIteration as e:
        print('生成器传出最后的值:%d' % e.value)
        break

如果不加返回值的话直接break就行，没有外循环的话就直接pass。

while True:
    print('生成器传出的值:%d' % a)
    try:
        a = c.send(1)
    except StopIteration:
        break

4.2 生成器表达式(generator expression)

生成器表达式是列表生成式的生成器版本，看起来像列表生成式，但是它返回的是一个生成器对象而不是列表对象。当然，它既然是生成器，也就可以上个例子一样通过send()函数来迭代。

print ([x*x for x in range(10)])

print  (x*x for x in range(10)) # 生成器表达式

输出结果：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x000000000214B570>

五、协程

下面是一段协程的代码

def simple_coro2(a):
  print("->  Started: a =", a)
  b = yield a
  print("-> Received: b: =", b)
  c = yield a + b
  print("-> Received: c=", c)

可以看到在生成器中，每次调用send()方法时，yield语句对外返回yield右侧的值，再将输入的值赋值给左侧的变量。所以协程在yield上做了拓展。能接收一些参数。

六、协程(coroutine)和生成器(generator)的区别

协程和生成器都使用yield关键字。但是协程更像是对生成器语法的一些扩展

• 在生成器中, yield 只对外产出值
• 在协程中，yield能对外产出值，而且能接收通过send()方法传入值

• 协程有四个状态

  • GEN_CREATED
  • GEN_RUNNING
  • GEN_SUSPEND
  • GEN_CLOSED

  每个协程在使用时，必须进行初始化。否则抛出异常

  TypeError: can't send non-None value to a just-started generator

如你所见，下面这代码将定义一个生成器的。

import time

def eat():
    while True:
        if food:
            print("小明 吃完{}了".format(food))
        yield
        print("小明 要开始吃{}...".format(food))
        time.sleep(1)

food = None
MING = eat()     # 产生一个生成器
MING.send(None)  # 预激
food = "面包"
MING.send('面包')
MING.send('苹果')
MING.send('香肠')

运行一下，从结果中可以看出，不管我们塞给小明什么东西，小明都将只能将他们当成面包吃。

小明 要开始吃面包...
小明 吃完面包了
小明 要开始吃面包...
小明 吃完面包了
小明 要开始吃面包...
小明 吃完面包了

那再来看一下协程的。

import time

def eat():
    food = None
    while True:
        if food:
            print("小明 吃完{}了".format(food))
        food = yield
        print("小明 开始吃{}...".format(food))
        time.sleep(1)

MING = eat()      # 产生一个生成器
MING.send(None)   # 预激
MING.send('面包')
MING.send('苹果')
MING.send('香肠')

运行一下，从结果中可以看出，小明已经可以感知我们塞给他的是什么食物。

小明 开始吃面包...
小明 吃完面包了
小明 开始吃苹果...
小明 吃完苹果了
小明 开始吃香肠...
小明 吃完香肠了

仔细观察一下，上面两段代码并没有太大的区别，我们将主要关注点集中在 yidld 关键词上。

可以发现，生成器里 yield 左边并没有变量，而在协程里，yield 左边有一个变量。

在函数被调用后，一个生成器就产生了，而一般的生成器不能再往生成器内部传递参数了，而这个当生成器里的 yield 左边有变量时，就不一样了，它仍然可以在外部接收新的参数。这就是生成器与协程的最大区别。

协程的优点：

• 线程属于系统级别调度，而协程是程序员级别的调度。使用协程避免了无意义的调度，减少了线程上下文切换的开销，由此可以提高性能。
• 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
• 无需原子操作锁定及同步的开销
• 方便切换控制流，简化编程模型

协程的缺点：

　　（1）无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。

　　（2）进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

协程很类似于Javascript单线程下异步处理的概念，协程同样是单线程的，之所以能够进行并发是因为通过某种方式保存了执行栈的上下文，在一定条件下将执行权交由其他栈，在一定条件下又通过执行栈上下文恢复栈。

总结：

编一则小故事：
在Python中有一种可迭代对象(Iterable)，他声称自己可以通过迭代来获取值(如for循环)，但怎么迭代他说那是迭代器(Iterator)的事，他只负责把自己变成迭代器。于是当他揽下一个需要迭代的活时，他就通过Iter()把自己变成了迭代器。

另外一个容器兄弟开始呼应：”我就是可迭代对象呢，我包含常见的列表、元组、字典、集合和字符串，我将这些序列存储在内存中，需要的时候可以一并取出“

迭代器有点不屑，开始怼容器说：“你将所有序列都存储在内存中，对于少量有限序列是可以的，那如果是大量序列或无限序列，内存都让给你存岂不是很败家？我是迭代功能的实干家，我可以通过next()进行迭代,但并不是把所有序列放在内存中再迭代取值，而是仅仅将迭代到的某个值取到内存中，做到按需存储。

生成器对迭代器说：“我就是另一个你，但我们不一样。大兄弟你的确是个实干家，但你仅仅只能迭代取出数据，而我除了有你的功能还可以通过send()传入数据，传入的数据可在生成器内进行计算呢。”

最后，生成器和迭代器和容器说：“我们都是可迭代对象，Iterable对于我们来说更像一种特点，表示我们是可迭代的，但是功能的实现是我们自己完成的”

http://python-online.cn/zh_CN/latest/c02/c02_12.html

https://jianshu.com/p/5103c6a63e33
https://blog.csdn.net/SL_World/article/details/86507872

https://segmentfault.com/a/1190000013460584

https://www.jianshu.com/p/a36aa573f954