深入理解python的生成器表达式和列表解析

前言

      没有用过的东西，没有深刻理解的东西很难说自己会，而且被别人一问必然破绽百出。虽然之前有接触过python协程的概念，但是只是走马观花，这两天的一次交谈中，别人问到了协程，顿时语塞，死活想不起来曾经看过的东西，之后突然想到了yield，但为时已晚，只能说概念不清，所以本篇先缕缕python的生成器和yield关键字。

什么是生成器

• 生成器是一个特殊的程序，可以被用作控制循环的迭代行为
• 生成器类似于返回值为数组的一个函数，这个函数可以接收参数，可以被调用，但是，不同于一般的函数会一次性返回包含了所有数值的数组，生成器一次只产生一个值，这样消耗的内存数量大大减少，而且允许调用函数可以很快的开始处理前几个返回值。因此，生成器看起来像一个函数但是表现的却像一个迭代器。

python中的生成器

python提供了两种基本的方式。

• 生成器函数：也是用def来定义，利用关键字yield一次返回一个结果，阻塞，重新开始
• 生成器表达式：返回一个对象，这个对象只有在需要的时候才产生结果

下面详细讲解：

生成器函数

• 为什么叫生成器函数？因为他随着时间的推移生成了一个数值队列。一般的函数在执行完毕之后会返回一个值然后退出，但是生成器函数会自动挂起，然后重新拾起继续执行，他会利用yield关键字关起函数，给调用者返回一个值，同时保留了当前的足够多的状态，可以使函数继续执行。生成器和迭代协议是密切相关的，可迭代的对象都有一个__next()__成员方法,这个方法要么返回迭代的下一项，要么引起异常结束迭代。
  
• 为了支持迭代协议，拥有yield语句的函数被编译为生成器，这类函数被调用时返回一个生成器对象，返回的对象支持迭代接口，即成员方法__next()__继续从中断处执行执行。
  

看下面的例子：

1. # 计数器
2. def create_counter(n):
3. print("create counter")
4. while True:
5. yield n
6. print('increment n')
7. n += 1
9. cnt = create_counter(2)
10. print(cnt)
11. print(next(cnt))
12. print(next(cnt))
13. print(next(cnt))
14. print(next(cnt))
16. # D:\Python\python\python-3.6.1\Python36-64\python.exe
17. #
18. # create counter
19. # 2
20. # increment n
21. # 3
22. # increment n
23. # 4
24. # increment n
25. # 5

分析一下这个例子：

• 在create_counter函数中出现了关键字yield，预示着这个函数每次只产生一个结果值，这个函数返回一个生成器（通过第一行输出可以看出来），用来产生连续的n值
• 在创造生成器实例的时候，只需要像普通函数一样调用就可以，但是这个调用却不会执行这个函数，这个可以通过输出看出来
• next()函数将生成器对象作为自己的参数，在第一次调用的时候，他执行了create_counter()函数到yield语句，返回产生的值2
• 我们重复的调用next（）函数，每次他都会从上次被挂起的地方开始执行，直到再次遇到了yield关键字

为了更加深刻的理解，我们再举一个例子。

1. # 立方
2. def cube(n):
3. for i in range(n):
4. yield i ** 3
6. print(cube(5))
7. print(next(cube(5)))
8. print(next(cube(5)))
9. print(next(cube(5)))
10. print("for循环")
11. for i in cube(5):
12. print(i)
14. # D:\Python\python\python-3.6.1\Python36-64\python.exe
15. #
16. # 0
17. # 0
18. # 0
19. # for循环
20. # 0
21. # 1
22. # 8
23. # 27
24. # 64

所以从理解函数的角度出发我们可以将yield类比为return，但是功能确实完全不同，在for循环中，会自动遵循迭代规则，每次调用next()函数，所以上面的结果不难理解。

生成器表达式：

生成器表达式来自于迭代和列表解析的组合，生成器表达式和列表解析类似，但是他使用圆括号而不是方括号括起来的。如下代码：

1. # 列表解析生成列表
2. list = [ x ** 3 for x in range(5)]
3. print(list)
4. # [0, 1, 8, 27, 64]
6. # 生成器表达式
7. range_ = (x ** 3 for x in range(5))
8. print(range_)
9. print(range_.__next__())
10. print(range_.__next__())
11. print(range_.__next__())
12. # at 0x00000000024A1D00>
13. # 0
14. # 1
15. # 8
17. # 两者之间转换
18. list1 = list(x ** 3 for x in range(5))
19. print(list1)
20. # Traceback (most recent call last):
21. # File "test.py", line 29, in
22. # list1 = list(x ** 3 for x in range(5))
23. # TypeError: 'list' object is not callable

就操作而言，生成器表如果使用大量的next()函数会显得十分不方便，for循环会自动出发next函数，所以可以按下面方式使用：

1. for n in (x ** 3 for x in range(5)):
2. print('%s, %s' % (n, n * n))
4. # 0, 0
5. # 1, 1
6. # 8, 64
7. # 27, 729
8. # 64, 4096

关于列表解析的概念和用法如下：

列表是一个很有用的数据结构，由于其灵活性在实际应用中被广泛使用。对于列表来说，列表解析十分常用。

列表解析的语法如下，它迭代iterable中的每一个元素，当条件满足的时候便根据表达式expr计算的内容生成一个元素并放入新的列表中，依次类推，最终返回整个列表。

1. [expr for iter_item in iterable if cond_expr]

列表解析的使用非常灵活：

• 支持多重嵌套，如果需要生成一个二维列表可以使用列表解析嵌套的方式

1. nested_list = [['Hello', 'World'],['Goodbye', 'World']]
2. print(nested_list)
3. # [['Hello', 'World'], ['Goodbye', 'World']]
4. nested_list = [[ele.upper() for ele in word] for word in nested_list]
5. print(nested_list)
6. # [['HELLO', 'WORLD'], ['GOODBYE', 'WORLD']]

• 支持多重迭代

1. b_ = [(a, b) for a in ['1', '2', '3', '4'] for b in ['a', 'b', 'c', 'd'] if a != b]
2. print(b_)
3. # [('1', 'a'), ('1', 'b'), ('1', 'c'), ('1', 'd'), 
4. # ('2', 'a'), ('2', 'b'), ('2', 'c'), ('2', 'd'), 
5. # ('3', 'a'), ('3', 'b'), ('3', 'c'), ('3', 'd'), 
6. # ('4', 'a'), ('4', 'b'), ('4', 'c'), ('4', 'd')]

• 表达式可以是简单表达式，也可以是复杂表达式，甚至是函数

1. def f(v):
2. if v % 2 == 0:
3. v = v ** 2
4. else:
5. v = v + 1
6. return v
8. print([f(v) for v in [1, 2, 3, -1] if v > 0])
9. print([v ** 2 if v % 2 == 0 else v + 1 for v in [1, 2, 3, -1] if v > 0])
10. # [2, 4, 4]
11. # [2, 4, 4]

• iterable可以是任意可迭代对象

1. fp = open('wdf.py','r')
2. res = [i for i in fp if 'weixin' in i]
3. print(res)

为什么要推荐在需要生成列表的时候使用列表解析呢？

• 使用列表解析更为直观清晰，代码更为简洁
• 列表解析的效率更高，但是对于大数据处理，列表解析并不是一个最佳选择，过多的内存消耗可能会导致MemoryError

除了列表可以使用列表解析的语法之外，其他内置的数据结构也支持，如下：

1. #generator
2. (expr for iter_item in iterable if cond_expr)
3. #set
4. {expr for iter_item in iterable if cond_expr}
5. #dict
6. {expr1: expr2 for iter_item in iterable if cond_expr}

---

两者比较

        一个迭代既可以被写成生成器函数，也可以被写成生成器表达式，均支持自动和手动迭代。而且这些生成器只支持一个active迭代，也就是说生成器的迭代器就是生成器本身。

        绝大多数情况下，遍历一个集合都是为了对元素应用某个动作或是进行筛选。你应该还记得有内建函数map和filter提供了这些功能，但Python仍然为这些操作提供了语言级的支持。

1. (x+1 for x in lst) #生成器表达式，返回迭代器。外部的括号可在用于参数时省略。
2. [x+1 for x in lst] #列表解析，返回list

     如你所见，生成器表达式和列表解析的区别很小，所以人们提到这个特性时，简单起见往往只描述成列表解析。然而由于返回迭代器时，并不是在一开始就计算所有的元素，这样能得到更多的灵活性并且可以避开很多不必要的计算，所以除非你明确希望返回列表，否则应该始终使用生成器表达式。

你也可以为列表解析提供if子句进行筛选：

1. (x+1 for x in lst if x!=0)

   或者提供多条for子句进行嵌套循环，嵌套次序就是for子句的顺序：

1. ((x, y) for x in range(3) for y in range(x))

      列表解析就是鲜明的Pythonic。我常遇到两个使用列表解析的问题：

1. 第一个问题是，因为对元素应用的动作太复杂，不能用一个表达式写出来，所以不使用列表解析。这是典型的思想没有转变的例子，如果我们将动作封装成函数，那不就是一个表达式了么？
2. 第二个问题是，因为if子句里的条件需要计算，同时结果也需要进行同样的计算，不希望计算两遍，就像这样：

1. (x.doSomething() for x in lst if x.doSomething()>0)

这样写确实很糟糕，但组合一下列表解析即可解决：

1. (x for x in (y.doSomething() for y in lst) if x>0)

内部的列表解析变量其实也可以用x，但为清晰起见我们改成了y。或者更清楚的，可以写成两个表达式：

1. tmp = (x.doSomething() for x in lst)
2. (x for x in tmp if x > 0)

列表解析可以替代绝大多数需要用到map和filter的场合，可能正因为此，著名的静态检查工具pylint将map和filter的使用列为了警告。

参考来源：  http://www.cnblogs.com/cotyb/p/5260032.html

参考 来源：  http://www.cnblogs.com/cotyb/p/5111064.html

参考 来源 ：  http://www.jb51.net/article/80741.htm