Python高效编程

系统 145 0

工作中经常要处理各种各样的数据,遇到项目赶进度的时候自己写函数容易浪费时间。
Python 中有很多内置函数帮你提高工作效率!

一:在列表,字典中根据条件筛选数据

1.假设有一个数字列表 data, 过滤列表中的负数
列表推导式

            
              result 
              
                =
              
              
                [
              
              i 
              
                for
              
               i 
              
                in
              
               data 
              
                if
              
               i 
              
                >=
              
              
                0
              
              
                ]
              
            
          

filter

            
              result 
              
                =
              
              
                filter
              
              
                (
              
              
                lambda
              
               x
              
                :
              
               x
              
                >=
              
              
                0
              
              
                ,
              
               data
              
                )
              
            
          

2.学生的数学分数以字典形式存储,筛选其中分数大于 80 分的同学

            
              d 
              
                =
              
              
                {
              
              x
              
                :
              
              randint
              
                (
              
              
                50
              
              
                ,
              
              
                100
              
              
                )
              
              
                for
              
               x 
              
                in
              
              
                range
              
              
                (
              
              
                1
              
              
                ,
              
              
                21
              
              
                )
              
              
                }
              
            
          
            
              
                {
              
              k
              
                :
              
               v 
              
                for
              
               k
              
                ,
              
               v 
              
                in
              
               d
              
                .
              
              items
              
                (
              
              
                )
              
              
                if
              
               v 
              
                >
              
              
                80
              
              
                }
              
            
          

二:对字典的键值对进行翻转

使用 zip() 函数

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。

            
              
                >>
              
              
                >
              
               s1 
              
                =
              
              
                {
              
              x
              
                :
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                4
              
              
                )
              
              
                for
              
               x 
              
                in
              
               sample
              
                (
              
              
                'abfcdrg'
              
              
                ,
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                5
              
              
                )
              
              
                )
              
              
                }
              
              
                >>
              
              
                >
              
               s1

              
                {
              
              
                'b'
              
              
                :
              
              
                1
              
              
                ,
              
              
                'f'
              
              
                :
              
              
                4
              
              
                ,
              
              
                'g'
              
              
                :
              
              
                3
              
              
                ,
              
              
                'r'
              
              
                :
              
              
                1
              
              
                }
              
              
                >>
              
              
                >
              
               d 
              
                =
              
              
                {
              
              k
              
                :
              
              v 
              
                for
              
               k
              
                ,
              
               v 
              
                in
              
              
                zip
              
              
                (
              
              s1
              
                .
              
              values
              
                (
              
              
                )
              
              
                ,
              
               s1
              
                .
              
              keys
              
                (
              
              
                )
              
              
                )
              
              
                }
              
              
                >>
              
              
                >
              
               d

              
                {
              
              
                1
              
              
                :
              
              
                'r'
              
              
                ,
              
              
                4
              
              
                :
              
              
                'f'
              
              
                ,
              
              
                3
              
              
                :
              
              
                'g'
              
              
                }
              
            
          

二. 统计序列中元素出现的频度

1.某随机序列中,找到出现次数最高的3个元素,它们出现的次数是多少?

随机序列如下:

            
              data 
              
                =
              
              
                [
              
              randint
              
                (
              
              
                0
              
              
                ,
              
              
                20
              
              
                )
              
              
                for
              
               _ 
              
                in
              
              
                range
              
              
                (
              
              
                20
              
              
                )
              
              
                ]
              
            
          

方法1: 可以使用字典来统计,以列表中的数据为键,以出现的次数为值

            
              
                from
              
               random 
              
                import
              
               randint


              
                def
              
              
                demo
              
              
                (
              
              
                )
              
              
                :
              
              
    data 
              
                =
              
              
                [
              
              randint
              
                (
              
              
                0
              
              
                ,
              
              
                20
              
              
                )
              
              
                for
              
               _ 
              
                in
              
              
                range
              
              
                (
              
              
                30
              
              
                )
              
              
                ]
              
              
                # 列表中出现数字出现的次数
              
              
    d 
              
                =
              
              
                dict
              
              
                .
              
              fromkeys
              
                (
              
              data
              
                ,
              
              
                0
              
              
                )
              
              
                for
              
               v 
              
                in
              
               li
              
                :
              
              
        d
              
                [
              
              v
              
                ]
              
              
                +=
              
              
                1
              
              
                return
              
               d

            
          

方法2:直接使用 collections 模块下面的 Counter 对象

            
              
                >>
              
              
                >
              
               data 
              
                =
              
              
                [
              
              randint
              
                (
              
              
                0
              
              
                ,
              
              
                20
              
              
                )
              
              
                for
              
               _ 
              
                in
              
              
                range
              
              
                (
              
              
                30
              
              
                )
              
              
                ]
              
              
                >>
              
              
                >
              
               data

              
                [
              
              
                7
              
              
                ,
              
              
                8
              
              
                ,
              
              
                5
              
              
                ,
              
              
                16
              
              
                ,
              
              
                10
              
              
                ,
              
              
                16
              
              
                ,
              
              
                8
              
              
                ,
              
              
                17
              
              
                ,
              
              
                11
              
              
                ,
              
              
                18
              
              
                ,
              
              
                11
              
              
                ,
              
              
                17
              
              
                ,
              
              
                15
              
              
                ,
              
              
                7
              
              
                ,
              
              
                2
              
              
                ,
              
              
                19
              
              
                ,
              
              
                5
              
              
                ,
              
              
                16
              
              
                ,
              
              
                17
              
              
                ,
              
              
                17
              
              
                ,
              
              
                12
              
              
                ,
              
              
                19
              
              
                ,
              
              
                9
              
              
                ,
              
              
                10
              
              
                ,
              
              
                0
              
              
                ,
              
              
                20
              
              
                ,
              
              
                11
              
              
                ,
              
              
                2
              
              
                ,
              
              
                11
              
              
                ,
              
              
                10
              
              
                ]
              
              
                >>
              
              
                >
              
               c2 
              
                =
              
               Counter
              
                (
              
              data
              
                )
              
              
                >>
              
              
                >
              
               c2
Counter
              
                (
              
              
                {
              
              
                17
              
              
                :
              
              
                4
              
              
                ,
              
              
                11
              
              
                :
              
              
                4
              
              
                ,
              
              
                16
              
              
                :
              
              
                3
              
              
                ,
              
              
                10
              
              
                :
              
              
                3
              
              
                ,
              
              
                7
              
              
                :
              
              
                2
              
              
                ,
              
              
                8
              
              
                :
              
              
                2
              
              
                ,
              
              
                5
              
              
                :
              
              
                2
              
              
                ,
              
              
                2
              
              
                :
              
              
                2
              
              
                ,
              
              
                19
              
              
                :
              
              
                2
              
              
                ,
              
              
                18
              
              
                :
              
              
                1
              
              
                ,
              
              
                15
              
              
                :
              
              
                1
              
              
                ,
              
              
                12
              
              
                :
              
              
                1
              
              
                ,
              
              
                9
              
              
                :
              
              
                1
              
              
                ,
              
              
                0
              
              
                :
              
              
                1
              
              
                ,
              
              
                20
              
              
                :
              
              
                1
              
              
                }
              
              
                )
              
              
                >>
              
              
                >
              
               c2
              
                [
              
              
                14
              
              
                ]
              
              
                4
              
              
                >>
              
              
                >
              
               c2
              
                .
              
              most_common
              
                (
              
              
                3
              
              
                )
              
              
                # 统计频度出现最高的3个数
              
              
                [
              
              
                (
              
              
                17
              
              
                ,
              
              
                4
              
              
                )
              
              
                ,
              
              
                (
              
              
                11
              
              
                ,
              
              
                4
              
              
                )
              
              
                ,
              
              
                (
              
              
                16
              
              
                ,
              
              
                3
              
              
                )
              
              
                ]
              
            
          

2. 对某英文文章单词进行统计,找到出现次数最高的单词以及出现的次数

通过上面的练习,我们知道可以用 Counter 来解决

            
              
                import
              
               re

              
                from
              
               collections 
              
                import
              
               Counter


              
                # 统计某个文章中英文单词的词频
              
              
                with
              
              
                open
              
              
                (
              
              
                'test.txt'
              
              
                ,
              
              
                'r'
              
              
                ,
              
               encoding
              
                =
              
              
                'utf-8'
              
              
                )
              
              
                as
              
               f
              
                :
              
              
    d 
              
                =
              
               f
              
                .
              
              read
              
                (
              
              
                )
              
              

total 
              
                =
              
               re
              
                .
              
              split
              
                (
              
              
                '\W+'
              
              
                ,
              
               d
              
                )
              
              
                # 所有的单词列表
              
              
result 
              
                =
              
               Counter
              
                (
              
              total
              
                )
              
              
                print
              
              
                (
              
              result
              
                .
              
              most_common
              
                (
              
              
                10
              
              
                )
              
              
                )
              
            
          

三.根据字典中值的大小,对字典中的项进行排序

比如班级中学生的数学成绩以字典的形式存储:

            
              
                {
              
              
                "Lnad"
              
              
                :
              
              
                88
              
              
                ,
              
              
                "Jim"
              
              
                ,
              
              
                71
              
              
                .
              
              
                .
              
              
                .
              
              
                }
              
            
          

请按数学成绩从高到底进行排序!

方法1: 利用 zip 将字典转化为元祖,再用 sorted 进行排序

            
              
                >>
              
              
                >
              
               data 
              
                =
              
              
                {
              
              x
              
                :
              
               randint
              
                (
              
              
                60
              
              
                ,
              
              
                100
              
              
                )
              
              
                for
              
               x 
              
                in
              
              
                "xyzfafs"
              
              
                }
              
              
                >>
              
              
                >
              
               data

              
                {
              
              
                'x'
              
              
                :
              
              
                73
              
              
                ,
              
              
                'y'
              
              
                :
              
              
                69
              
              
                ,
              
              
                'z'
              
              
                :
              
              
                76
              
              
                ,
              
              
                'f'
              
              
                :
              
              
                61
              
              
                ,
              
              
                'a'
              
              
                :
              
              
                64
              
              
                ,
              
              
                's'
              
              
                :
              
              
                100
              
              
                }
              
              
                >>
              
              
                >
              
              
                sorted
              
              
                (
              
              data
              
                )
              
              
                [
              
              
                'a'
              
              
                ,
              
              
                'f'
              
              
                ,
              
              
                's'
              
              
                ,
              
              
                'x'
              
              
                ,
              
              
                'y'
              
              
                ,
              
              
                'z'
              
              
                ]
              
              
                >>
              
              
                >
              
               data 
              
                =
              
              
                sorted
              
              
                (
              
              
                zip
              
              
                (
              
              data
              
                .
              
              values
              
                (
              
              
                )
              
              
                ,
              
               data
              
                .
              
              keys
              
                (
              
              
                )
              
              
                )
              
              
                )
              
              
                >>
              
              
                >
              
               data

              
                [
              
              
                (
              
              
                61
              
              
                ,
              
              
                'f'
              
              
                )
              
              
                ,
              
              
                (
              
              
                64
              
              
                ,
              
              
                'a'
              
              
                )
              
              
                ,
              
              
                (
              
              
                69
              
              
                ,
              
              
                'y'
              
              
                )
              
              
                ,
              
              
                (
              
              
                73
              
              
                ,
              
              
                'x'
              
              
                )
              
              
                ,
              
              
                (
              
              
                76
              
              
                ,
              
              
                'z'
              
              
                )
              
              
                ,
              
              
                (
              
              
                100
              
              
                ,
              
              
                's'
              
              
                )
              
              
                ]
              
            
          

方法2: 利用 sorted 函数的 key 参数

            
              
                >>
              
              
                >
              
               data
              
                .
              
              items
              
                (
              
              
                )
              
              
                >>
              
              
                >
              
               dict_items
              
                (
              
              
                [
              
              
                (
              
              
                'x'
              
              
                ,
              
              
                64
              
              
                )
              
              
                ,
              
              
                (
              
              
                'y'
              
              
                ,
              
              
                74
              
              
                )
              
              
                ,
              
              
                (
              
              
                'z'
              
              
                ,
              
              
                66
              
              
                )
              
              
                ,
              
              
                (
              
              
                'f'
              
              
                ,
              
              
                62
              
              
                )
              
              
                ,
              
              
                (
              
              
                'a'
              
              
                ,
              
              
                80
              
              
                )
              
              
                ,
              
              
                (
              
              
                's'
              
              
                ,
              
              
                72
              
              
                )
              
              
                ]
              
              
                )
              
              
                >>
              
              
                >
              
              
                sorted
              
              
                (
              
              data
              
                .
              
              items
              
                (
              
              
                )
              
              
                ,
              
               key
              
                =
              
              
                lambda
              
               x
              
                :
              
               x
              
                [
              
              
                1
              
              
                ]
              
              
                )
              
              
                [
              
              
                (
              
              
                'f'
              
              
                ,
              
              
                62
              
              
                )
              
              
                ,
              
              
                (
              
              
                'x'
              
              
                ,
              
              
                64
              
              
                )
              
              
                ,
              
              
                (
              
              
                'z'
              
              
                ,
              
              
                66
              
              
                )
              
              
                ,
              
              
                (
              
              
                's'
              
              
                ,
              
              
                72
              
              
                )
              
              
                ,
              
              
                (
              
              
                'y'
              
              
                ,
              
              
                74
              
              
                )
              
              
                ,
              
              
                (
              
              
                'a'
              
              
                ,
              
              
                80
              
              
                )
              
              
                ]
              
            
          

四. 在多个字典中找到公共键

实际场景:在足球联赛中,统计每轮比赛都有进球的球员

第一轮: {“C罗”: 1, “苏亚雷斯”:2, “托雷斯”: 1…}
第二轮: {“内马尔”: 1, “梅西”:2, “姆巴佩”: 3…}
第三轮: {“姆巴佩”: 2, “C罗”:2, “内马尔”: 1…}

模拟随机的进球球员和进球数

            
              
                >>
              
              
                >
              
               s1 
              
                =
              
              
                {
              
              x
              
                :
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                4
              
              
                )
              
              
                for
              
               x 
              
                in
              
               sample
              
                (
              
              
                'abfcdrg'
              
              
                ,
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                5
              
              
                )
              
              
                )
              
              
                }
              
              
                >>
              
              
                >
              
               s1

              
                {
              
              
                'd'
              
              
                :
              
              
                3
              
              
                ,
              
              
                'g'
              
              
                :
              
              
                2
              
              
                }
              
              
                >>
              
              
                >
              
               s2 
              
                =
              
              
                {
              
              x
              
                :
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                4
              
              
                )
              
              
                for
              
               x 
              
                in
              
               sample
              
                (
              
              
                'abfcdrg'
              
              
                ,
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                5
              
              
                )
              
              
                )
              
              
                }
              
              
                >>
              
              
                >
              
               s2

              
                {
              
              
                'b'
              
              
                :
              
              
                4
              
              
                ,
              
              
                'g'
              
              
                :
              
              
                1
              
              
                ,
              
              
                'f'
              
              
                :
              
              
                1
              
              
                ,
              
              
                'r'
              
              
                :
              
              
                4
              
              
                ,
              
              
                'd'
              
              
                :
              
              
                3
              
              
                }
              
              
                >>
              
              
                >
              
               s3 
              
                =
              
              
                {
              
              x
              
                :
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                4
              
              
                )
              
              
                for
              
               x 
              
                in
              
               sample
              
                (
              
              
                'abfcdrg'
              
              
                ,
              
               randint
              
                (
              
              
                1
              
              
                ,
              
              
                5
              
              
                )
              
              
                )
              
              
                }
              
              
                >>
              
              
                >
              
               s3

              
                {
              
              
                'b'
              
              
                :
              
              
                4
              
              
                ,
              
              
                'r'
              
              
                :
              
              
                4
              
              
                ,
              
              
                'a'
              
              
                :
              
              
                2
              
              
                ,
              
              
                'g'
              
              
                :
              
              
                3
              
              
                ,
              
              
                'c'
              
              
                :
              
              
                4
              
              
                }
              
            
          

首先获取字典的 keys,然后取每轮比赛 key 的交集
由于比赛轮次数是不定的,所以使用 map 来批量操作

            
              
                map
              
              
                (
              
              
                dict
              
              
                .
              
              keys
              
                ,
              
              
                [
              
              s1
              
                ,
              
               s2
              
                ,
              
               s3
              
                ]
              
              
                )
              
            
          

然后一直累积取其交集, 使用 reduce 函数

            
              
                reduce
              
              
                (
              
              
                lambda
              
               x
              
                ,
              
              y
              
                :
              
               x 
              
                &
              
               y
              
                ,
              
              
                map
              
              
                (
              
              
                dict
              
              
                .
              
              keys
              
                ,
              
              
                [
              
              s1
              
                ,
              
               s2
              
                ,
              
               s3
              
                ]
              
              
                )
              
              
                )
              
            
          

一行代码搞定!

Python高效编程_第1张图片


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

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

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

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