Python笔记002-列表推导式

系统 448 0

Python笔记002-列表推导式

以下是我学习《流畅的Python》后的个人笔记,现在拿出来和大家共享,希望能帮到各位Python学习者。

首次发表于: 微信公众号:科技老丁哥,ID: TechDing,敬请关注。

本篇主要知识点:

  1. 列表推导式可以从一个序列快速构建另一个序列,非常方便快捷,强烈建议使用。

  2. 列表推导式适用于简单的for循环,可以对一个列表中的每个元素进行相同操作,也可以挑选出原列表中满足一定条件的元素组成新的列表。

  3. 集合推导式应用比较少,而字典推导式却应用广泛,可以从一个dict中选择出满足一定条件的items组成新的dict,也可以对原dict中的key或value进行操作。

  4. 列表推导式有极其广泛的应用场景,可以用于循环执行某个函数,也可以用于将某个list转换为dict,或将dict转换为list等。

1. 列表推导式

列表推导式是构建列表(list)的一种快捷方式,而且可读性强,用它编写的代码非常有Python味儿,是一种非常推荐的编程风格。

而且,Python的内部实现对列表推导式做了大量优化,可以保证运行速度非常快。

列表推导式可以仅仅使用[]来生成一个list,基本代码格式为: [表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件] ,如下为这两种格式的实现方法:

            
              
                ## demo1:
              
              
alist
              
                =
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                50
              
              
                ,
              
              
                89
              
              
                ,
              
              
                26
              
              
                ,
              
              
                30
              
              
                ]
              
              
odd
              
                =
              
              
                [
              
              i 
              
                for
              
               i 
              
                in
              
               alist 
              
                if
              
               i
              
                %
              
              
                2
              
              
                ==
              
              
                1
              
              
                ]
              
              
                # 选出列表alist中所有的奇数
              
              
                print
              
              
                (
              
              odd
              
                )
              
              
                # [1, 3, 89]
              
            
          

Python中的列表推导式主要替换了Java或C语言中的for循环,当你想使用for循环来实现简单的业务时,不妨使用列表推导式。

            
              
                ### demo2:
              
              
alist
              
                =
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                50
              
              
                ,
              
              
                89
              
              
                ,
              
              
                26
              
              
                ,
              
              
                30
              
              
                ]
              
              
plus
              
                =
              
              
                [
              
              i
              
                *
              
              
                2
              
              
                +
              
              
                10
              
              
                for
              
               i 
              
                in
              
               alist
              
                ]
              
              
                # 简单算术操作
              
              
                print
              
              
                (
              
              plus
              
                )
              
              
                # [12, 14, 16, 110, 188, 62, 70]
              
            
          

当然,如果是比较复杂的业务,需要多行代码才能实现,那还是老老实实用for循环来实现吧。从这一点来说,列表推导式类似于函数中的lambda表达式,简单的函数可以直接用lambda来表示。

列表推导式还可以实现嵌套,一般为了可读性比较强,最多嵌套3层。

            
              
                ### demo3: 列表推导式的嵌套用法
              
              
alist
              
                =
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                5
              
              
                ]
              
              
blist
              
                =
              
              
                [
              
              
                'A'
              
              
                ,
              
              
                'B'
              
              
                ,
              
              
                'C'
              
              
                ]
              
              
combined
              
                =
              
              
                [
              
              b
              
                +
              
              
                '_'
              
              
                +
              
              
                str
              
              
                (
              
              a
              
                )
              
              
                for
              
               b 
              
                in
              
               blist 
              
                for
              
               a 
              
                in
              
               alist
              
                ]
              
              
                print
              
              
                (
              
              combined
              
                )
              
              
                # ['A_1', 'A_2', 'A_5', 'B_1', 'B_2', 'B_5', 'C_1', 'C_2', 'C_5']
              
              
                # demo4: 加入判断条件: 只用奇数
              
              
combined2
              
                =
              
              
                [
              
              b
              
                +
              
              
                '_'
              
              
                +
              
              
                str
              
              
                (
              
              a
              
                )
              
              
                for
              
               b 
              
                in
              
               blist 
              
                for
              
               a 
              
                in
              
               alist 
              
                if
              
               a
              
                %
              
              
                2
              
              
                ==
              
              
                1
              
              
                ]
              
              
                print
              
              
                (
              
              combined2
              
                )
              
              
                # ['A_1', 'A_5', 'B_1', 'B_5', 'C_1', 'C_5']
              
            
          

2. 其他推导式

列表推导式并不仅仅适用于列表(list),还适用于其他序列类型,比如set, dict等。所以有的人将生成set的叫做集合推导式,把生成dict的叫做字典推导式。

集合推导式的用法和列表推导式一样,只是将[]改为{}即可,但得到的集合元素之间如果重复,则仅仅保留一个,这是由set的特性:元素不能重复决定的。

            
              
                ### 集合推导式:
              
              
                ## demo1:
              
              
alist
              
                =
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                50
              
              
                ,
              
              
                89
              
              
                ,
              
              
                26
              
              
                ,
              
              
                30
              
              
                ]
              
              
odd
              
                =
              
              
                {
              
              i 
              
                for
              
               i 
              
                in
              
               alist 
              
                if
              
               i
              
                %
              
              
                2
              
              
                ==
              
              
                1
              
              
                }
              
              
                # 选出列表alist中所有的奇数
              
              
                print
              
              
                (
              
              odd
              
                )
              
              
                # {89, 1, 3}
              
            
          

字典推导式的用法和列表推导式一样,只是将[]改为{},但迭代的对象是一个字典类型。

使用字典推导式可以实现很多多样化操作,比如下面将key,value互换。

            
              
                ### 字典推导式:
              
              
                # demo1: key,value互换;
              
              
dictA
              
                =
              
              
                {
              
              
                'a'
              
              
                :
              
              
                10
              
              
                ,
              
              
                'b'
              
              
                :
              
              
                20
              
              
                ,
              
              
                'c'
              
              
                :
              
              
                30
              
              
                }
              
              
changed
              
                =
              
              
                {
              
              value
              
                :
              
              key 
              
                for
              
               key
              
                ,
              
              value 
              
                in
              
               dictA
              
                .
              
              items
              
                (
              
              
                )
              
              
                }
              
              
                print
              
              
                (
              
              changed
              
                )
              
              
                # {10: 'a', 20: 'b', 30: 'c'}
              
            
          

还比如:单独对keys进行迭代,可以选出keys满足一定条件items组成新的dict

            
              
                ### demo2: 选出key是奇数的items
              
              
dictB
              
                =
              
              
                {
              
              
                1
              
              
                :
              
              
                '10'
              
              
                ,
              
              
                2
              
              
                :
              
              
                '20'
              
              
                ,
              
              
                3
              
              
                :
              
              
                '30'
              
              
                ,
              
              
                4
              
              
                :
              
              
                '40'
              
              
                }
              
              
odd_dict
              
                =
              
              
                {
              
              key
              
                :
              
              dictB
              
                [
              
              key
              
                ]
              
              
                for
              
               key 
              
                in
              
               dictB
              
                .
              
              keys
              
                (
              
              
                )
              
              
                if
              
               key
              
                %
              
              
                2
              
              
                ==
              
              
                1
              
              
                }
              
              
                print
              
              
                (
              
              odd_dict
              
                )
              
              
                # {1: '10', 3: '30'}
              
            
          

同理,也可以单独对values进行迭代,选出values满足一定条件的items组成新的dict.

3. 应用示例

列表推导式还有些其他应用场景,比如:

循环执行某个函数:

            
              
                # 循环执行某个函数:
              
              
                import
              
               time

              
                def
              
              
                func_test
              
              
                (
              
              x
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                'start test: {}'
              
              
                .
              
              
                format
              
              
                (
              
              x
              
                )
              
              
                )
              
              
    time
              
                .
              
              sleep
              
                (
              
              
                1
              
              
                )
              
              
                print
              
              
                (
              
              
                'end test: {}'
              
              
                .
              
              
                format
              
              
                (
              
              x
              
                *
              
              
                2
              
              
                )
              
              
                )
              
              
                # 仅仅乘以2
              
              
                [
              
              func_test
              
                (
              
              x
              
                )
              
              
                for
              
               x 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                ,
              
              
                15
              
              
                ,
              
              
                2
              
              
                )
              
              
                ]
              
              
                # 使用列表推导式循环执行某个函数
              
            
          

start test: 10
end test: 20
start test: 12
end test: 24
start test: 14
end test: 28

循环执行函数,并获取返回值:

            
              
                # 循环执行某个函数:
              
              
                import
              
               time

              
                def
              
              
                func_test
              
              
                (
              
              x
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                'start test: {}'
              
              
                .
              
              
                format
              
              
                (
              
              x
              
                )
              
              
                )
              
              
    time
              
                .
              
              sleep
              
                (
              
              
                1
              
              
                )
              
              
                print
              
              
                (
              
              
                'end test: {}'
              
              
                .
              
              
                format
              
              
                (
              
              x
              
                *
              
              
                2
              
              
                )
              
              
                )
              
              
                # 仅仅乘以2
              
              
                return
              
               x
              
                *
              
              
                2
              
              
result
              
                =
              
              
                [
              
              func_test
              
                (
              
              x
              
                )
              
              
                for
              
               x 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                ,
              
              
                15
              
              
                ,
              
              
                2
              
              
                )
              
              
                ]
              
              
                # 使用列表推导式循环执行某个函数
              
              
                print
              
              
                (
              
              result
              
                )
              
              
                # [20, 24, 28]
              
            
          

通过列表推导式和字典推导式的灵活运用,可以将dict类型数据和list数据相互转化,比如:

            
              
                # 由list生成字典:
              
              
blist
              
                =
              
              
                [
              
              
                'A'
              
              
                ,
              
              
                'B'
              
              
                ,
              
              
                'C'
              
              
                ]
              
              
dict_from_list
              
                =
              
              
                {
              
              b
              
                :
              
              
                str
              
              
                (
              
              idx
              
                +
              
              
                10
              
              
                )
              
              
                for
              
               idx
              
                ,
              
              b 
              
                in
              
              
                enumerate
              
              
                (
              
              blist
              
                )
              
              
                }
              
              
                print
              
              
                (
              
              dict_from_list
              
                )
              
              
                # {'A': '10', 'B': '11', 'C': '12'}
              
              
                # 由dict生成list
              
              
dictB
              
                =
              
              
                {
              
              
                1
              
              
                :
              
              
                '10'
              
              
                ,
              
              
                2
              
              
                :
              
              
                '20'
              
              
                ,
              
              
                3
              
              
                :
              
              
                '30'
              
              
                ,
              
              
                4
              
              
                :
              
              
                '40'
              
              
                }
              
              
list_from_dict
              
                =
              
              
                [
              
              key 
              
                for
              
               key
              
                ,
              
              _ 
              
                in
              
               dictB
              
                .
              
              items
              
                (
              
              
                )
              
              
                if
              
               key
              
                %
              
              
                2
              
              
                ==
              
              
                0
              
              
                ]
              
              
                # 选出偶数的key
              
              
                print
              
              
                (
              
              list_from_dict
              
                )
              
              
                # [2, 4]
              
            
          

首次发表于: 微信公众号:科技老丁哥,ID: TechDing,敬请关注。

本文所有代码都已经上传到我的github,欢迎下载

参考资料:

  1. 《流畅的Python》,Luciano Ramalho (作者) 安道 , 吴珂 (译者)。

更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请请扫描上面二维码支持博主1元、2元、5元等您想捐的金额吧,狠狠点击下面给点支持吧

发表我的评论
最新评论 总共0条评论