解析式和生成器

列表解析

1. 举例

   • 生成一个列表，元素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]
     

2. 语法

   • [返回值 for 元素 in 可迭代对象 if 条件句 ]
   • if 条件句，不允许出现else和elif
   • 使用中括号[], 内部是for循环，if 条件语句可选
   • 返回一个新的列表

3. 列表解析式是一种语法糖

   • 编译器会优化，不会因为简写而影响效率，反而因优化提高了效率
   • 减少程序员工作量，减少出错
   • 简化了代码，但可读性增强

4. 思考

   • 有一个赋值语句，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]
     

5. 列表解析进阶

   • [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'}]
       

生成器表达式

1. 语法

   • (返回值 for 元素 in 可迭代对象 if 条件)
   • 使用小括号（）
   • 返回一个生成器

2. 和列表解析式的区别

   • 生成器表达的是按需计算（或称 惰性运算，延迟计算），需要的时候才计算值
   • 列表解析式是立即返回值

3. 生成器

   • 可迭代对象
   • 迭代器

4. 与列表解析式对比

   • 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. 计算速度
        • 单看计算时间，生成器表达式耗时非常短，列表解析式耗时长
        • 但是生成器本身并没有返回任何值，只返回了一个生成器对象
        • 列表解析式构造并返回了一个新的列表

5. 例子，易错点

   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'
   

集合解析式

1. 语法

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

2. 用法

   • {(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}
     

字典解析式

1. 语法

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

2. 用法

   • {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}
     

总结

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