解析式和生成器

列表解析

  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}
      

总结

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值