解析式和生成器

最新推荐文章于 2020-02-15 17:52:43 发布

卡布奇诺不卡

最新推荐文章于 2020-02-15 17:52:43 发布

阅读量335

点赞数

本文链接：https://blog.csdn.net/qq_41827944/article/details/99086594

版权

列表解析

举例

生成一个列表，元素0~9，对每一个元素自增1后求平方返回新的列表

l1 = list(range(10))
l2 = []
for i in l1:
    l2.append((i+1)**2)
print(l2)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

#列表解析式
l1 = list(range(10))
l2 = [(i+1)**2 for i in l1]
print(l2)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

语法
- [返回值 for 元素 in 可迭代对象 if 条件句 ]
- if 条件句，不允许出现else和elif
- 使用中括号[], 内部是for循环，if 条件语句可选
- 返回一个新的列表
列表解析式是一种语法糖
- 编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
- 减少程序员工作量，减少出错
- 简化了代码，但可读性增强

思考

有一个赋值语句，newlist = [print(i) for i in range(10)]，请问打印出来的元素是什么？

newlist = [print(i)  for i in range(10)]
print(newlist)

0
1
2
3
4
5
6
7
8
9
[None, None, None, None, None, None, None, None, None, None]

列表解析进阶

[expr for item in iterable if cond1 if cond2]

等价于

ret = []
for item in iterable :
	if cond1:
		if cond2:
			ret.append(expr)

举例：20以内，既能被2整除又能被3整除的数

[i for i in range(20) if i%2==0 and i%3==0] 
[i for i in range(20) if i%2==0 i%3==0]

[expr for i in iterable1 for j in iterable2]

等价于

ret = []
for i in iterable1:
	for j in iterable2:
		ret.append(expr)

举例

l1 = [(i,j) for i in "abcde"  for j in range(3)]
print(l1)

[('a', 0), ('a', 1), ('a', 2), ('b', 0), ('b', 1), ('b', 2), ('c', 0), ('c', 1), ('c', 2), ('d', 0), ('d', 1), ('d', 2), ('e', 0), ('e', 1), ('e', 2)]

l1 = [[i,j] for i in 'abcde' for j in range(3)]
print(l1)

[['a', 0], ['a', 1], ['a', 2], ['b', 0], ['b', 1], ['b', 2], ['c', 0], ['c', 1], ['c', 2], ['d', 0], ['d', 1], ['d', 2], ['e', 0], ['e', 1], ['e', 2]]

l1 = [{i,j} for i in 'abcde' for j in range(3)]
print(l1)

[{0, 'a'}, {1, 'a'}, {2, 'a'}, {0, 'b'}, {1, 'b'}, {2, 'b'}, {0, 'c'}, {1, 'c'}, {2, 'c'}, {0, 'd'}, {1, 'd'}, {2, 'd'}, {0, 'e'}, {1, 'e'}, {2, 'e'}]

生成器表达式

语法
- (返回值 for 元素 in 可迭代对象 if 条件)
- 使用小括号（）
- 返回一个生成器
和列表解析式的区别
- 生成器表达的是按需计算（或称惰性运算，延迟计算），需要的时候才计算值
- 列表解析式是立即返回值
生成器
- 可迭代对象
- 迭代器
与列表解析式对比
- ```
g = ("{:04}".format(i) for i in range(1,11))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print("++++++++++++")
for x in g:
    print(x)
print("------------")
for x in g:
    print(x)
    
0001
0002
0003
0004
++++++++++++
0005
0006
0007
0008
0009
0010
------------
```
  - 总结：
    1. 延迟计算
    2. 返回迭代器，可以迭代
    3. 从前到后走完一遍之后，不能回头
- ```
g = ["{:04}".format(i) for i in range(1,11)]

for x in g:
    print(x)
print("------------")
for x in g:
    print(x)
    
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
------------
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
```
  - 总结
    1. 立即计算
    2. 返回的不是迭代器，返回可迭代对象列表
    3. 从前到后走完一遍之后，可以重新回头迭代
- 和列表解析式的对比
  1. 计算方式
    - 生成器表达式延迟计算，列表解析式立即计算
  2. 内存占比
    - 单从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表
    - 生成器没有数据，内存占比极少，但是使用的时候，虽然一个个返回数据，但是合起来占用的内存也差不多
    - 列表解析式构造新的列表需要占用内存
  3. 计算速度
    - 单看计算时间，生成器表达式耗时非常短，列表解析式耗时长
    - 但是生成器本身并没有返回任何值，只返回了一个生成器对象
    - 列表解析式构造并返回了一个新的列表

例子，易错点

it = (print("{}".format(i+1)) for i in range(2))
first = next(it)
second = next(it)
val = first + second
print(val)

1
2
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-26-1c252ff9f51c> in <module>
      2 first = next(it)
      3 second = next(it)
----> 4 val = first + second
      5 print(val)

TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'

集合解析式

语法
- {返回值 for 元素 in 可迭代对象 if条件}
- 用大括号{}表示
- 立即返回一个集合

用法

{(x,x+1) for x in range(10)}

{(0, 1),
 (1, 2),
 (2, 3),
 (3, 4),
 (4, 5),
 (5, 6),
 (6, 7),
 (7, 8),
 (8, 9),
 (9, 10)}

{(x) for x in range(10)}

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

字典解析式

语法
- {返回值 for 元素 in 可迭代对象 if条件}
- 用大括号{}表示
- 使用key:value 形式
- 立即返回一个字典

用法

{x:(x+1) for x in range(10)}

{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}

{x:[x,x+1] for x in range(10)}

{0: [0, 1],
 1: [1, 2],
 2: [2, 3],
 3: [3, 4],
 4: [4, 5],
 5: [5, 6],
 6: [6, 7],
 7: [7, 8],
 8: [8, 9],
 9: [9, 10]}

{(x,):[x,x+1] for x in range(10)}

{(0,): [0, 1],
 (1,): [1, 2],
 (2,): [2, 3],
 (3,): [3, 4],
 (4,): [4, 5],
 (5,): [5, 6],
 (6,): [6, 7],
 (7,): [7, 8],
 (8,): [8, 9],
 (9,): [9, 10]}

{(x):[x,x+1] for x in range(10)}

{0: [0, 1],
 1: [1, 2],
 2: [2, 3],
 3: [3, 4],
 4: [4, 5],
 5: [5, 6],
 6: [6, 7],
 7: [7, 8],
 8: [8, 9],
 9: [9, 10]}

{[x]:[x,x+1] for x in range(10)}

TypeError: unhashable type: 'list'

{str(x):y for x in range(3) for y in range(4)}

{'0': 3, '1': 3, '2': 3}

总结

生成器和迭代器是不同的对象，但都是可迭代对象