如何优雅高效地使用Python——这些Python技巧你必须学会!

系统 355 0

文章目录

  • 前言
  • Python之禅
  • Python:优雅高效的写法
    • 多变量赋值
    • 变量交换
    • 格式化字符串
    • 序列并包(pack)
    • 序列解包(unpack)
    • 条件表达式
    • if结构简化
    • if链式条件表达式
    • any & all
    • eval
    • 遍历元素与下标
    • for/else
    • dict映射代替多条件查找
    • 访问字典元素
    • defaultdict
    • 列表/字典解析式
    • 字符串连接
    • "_"的妙用
    • map函数
    • reduce函数
    • filter函数
    • 生成器(generator)
    • yield
    • partial函数
    • lru_cache
    • 枚举
  • Reference

前言

目前Python已经更新到了3.7版本,不必多说,Python 3比Python 2更是多出了许多新的功能。Python是一门友好的语言,其区别于以往C++,Java的特点不仅是代码易于阅读,同时代码也更加优雅简洁,实现同样的功能相对于Python只需要短短几行代码,这给予了开发人员更大的便利,同时也易于初学者学习。本文将介绍Python中一些有趣实用的(代码)功能,希望这些代码能够帮助大家更加轻松优雅地解决一些问题。
注:本博客代码结果均为Python 3.6版本运行结果

Python之禅

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

Python之禅 by Tim Peters

优美胜于丑陋(Python以编写优美的代码为目标)
明了胜于晦涩(优美的代码应当是明了的,命名规范,风格相似)
简洁胜于复杂(优美的代码应当是简洁的,不要有复杂的内部实现)
复杂胜于凌乱(如果复杂不可避免,那代码间也不能有难懂的关系,要保持接口简洁)
扁平胜于嵌套(优美的代码应当是扁平的,不能有太多的嵌套)
间隔胜于紧凑(优美的代码有适当的间隔,不要奢望一行代码解决问题)
可读性很重要(优美的代码是可读的)
即便假借特例的实用性之名,也不可违背这些规则(这些规则至高无上)
不要包容所有错误,除非您确定需要这样做(精准地捕获异常,不写 except:pass 风格的代码)
当存在多种可能,不要尝试去猜测
而是尽量找一种,最好是唯一一种明显的解决方案(如果不确定,就用穷举法)
虽然这并不容易,因为您不是 Python 之父(这里的 Dutch 是指 Guido )
做也许好过不做,但不假思索就动手还不如不做(动手之前要细思量)
如果您无法向人描述您的方案,那肯定不是一个好方案;反之亦然(方案测评标准)
命名空间是一种绝妙的理念,我们应当多加利用(倡导与号召)

Python:优雅高效的写法

多变量赋值

当你想要初始化多个变量的时候:

  1. Bad
            
              x 
              
                =
              
              
                [
              
              
                ]
              
              
y 
              
                =
              
              
                [
              
              
                ]
              
              
z 
              
                =
              
              
                [
              
              
                ]
              
            
          
  1. Better
            
              x
              
                ,
              
               y
              
                ,
              
               z 
              
                =
              
              
                [
              
              
                ]
              
              
                ,
              
              
                [
              
              
                ]
              
              
                ,
              
              
                [
              
              
                ]
              
            
          

这样做的话代码更加简洁,同时可读性更高

变量交换

  1. Bad
            
              
                # edchange x and y
              
              
t 
              
                =
              
               x
x 
              
                =
              
               y
y 
              
                =
              
               t

            
          
  1. Better
            
              
                # edchange x and y
              
              
x
              
                ,
              
               y 
              
                =
              
               y
              
                ,
              
               x

            
          

这样做的话不止代码简洁,让人一眼就能看出是要交换变量,同时也能免去考虑中间变量赋值的先后顺序,并且后者的效率更是高于前者。

格式化字符串

如果你想要格式化输出一串字符串,你会怎么做?

  1. Bad
            
              name 
              
                =
              
              
                "James"
              
              
country 
              
                =
              
              
                "USA"
              
              
string 
              
                =
              
              
                "My name is %s, from %s, I love %s"
              
              
                %
              
              
                (
              
              name
              
                ,
              
               country
              
                ,
              
               country
              
                )
              
              
                >>
              
              
                >
              
               string


              
                'My name is James, from USA, I love USA'
              
            
          
  1. Better
            
              name 
              
                =
              
              
                "James"
              
              
country 
              
                =
              
              
                "USA"
              
              
string 
              
                =
              
              
                "My name is {}, from {}, I love {}"
              
              
                .
              
              
                format
              
              
                (
              
              name
              
                ,
              
               country
              
                ,
              
               country
              
                )
              
              
                >>
              
              
                >
              
               string


              
                'My name is James, from USA, I love USA'
              
            
          
  1. Best
            
              name 
              
                =
              
              
                "James"
              
              
country 
              
                =
              
              
                "USA"
              
              
string 
              
                =
              
              
                "My name is {name}, from {country}, I love {country}"
              
              
                .
              
              
                format
              
              
                (
              
              name
              
                =
              
              name
              
                ,
              
               country
              
                =
              
              country
              
                )
              
              
                'My name is James, from USA, I love USA'
              
              
                # or you can simplipy it by using f-strings
              
              
name 
              
                =
              
              
                "James"
              
              
country 
              
                =
              
              
                "USA"
              
              
string 
              
                =
              
               f
              
                "My name is {name}, from {country}, I love {country}"
              
              
                >>
              
              
                >
              
               string


              
                'My name is James, from USA, I love USA'
              
            
          

使用 format 函数比使用 %s 可读性更高,同时也更易于控制输出格式。

序列并包(pack)

当你想同时访问两个列表的时候,你的做法是?

  1. Bad
            
              names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ]
              
              
ages 
              
                =
              
              
                [
              
              
                18
              
              
                ,
              
              
                19
              
              
                ,
              
              
                20
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                len
              
              
                (
              
              names
              
                )
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "name:"
              
              
                ,
              
               names
              
                [
              
              i
              
                ]
              
              
                ,
              
              
                "age:"
              
              
                ,
              
               ages
              
                [
              
              i
              
                ]
              
              
                )
              
              

name
              
                :
              
               James age
              
                :
              
              
                18
              
              
name
              
                :
              
               Tim age
              
                :
              
              
                19
              
              
name
              
                :
              
               Katty age
              
                :
              
              
                20
              
            
          
  1. Better
            
              names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ]
              
              
ages 
              
                =
              
              
                [
              
              
                18
              
              
                ,
              
              
                19
              
              
                ,
              
              
                20
              
              
                ]
              
              
                for
              
               name
              
                ,
              
               age 
              
                in
              
              
                zip
              
              
                (
              
              names
              
                ,
              
              ages
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "name:"
              
              
                ,
              
               name
              
                ,
              
              
                "age:"
              
              
                ,
              
               age
              
                )
              
              

name
              
                :
              
               James age
              
                :
              
              
                18
              
              
name
              
                :
              
               Tim age
              
                :
              
              
                19
              
              
name
              
                :
              
               Katty age
              
                :
              
              
                20
              
            
          

后者的方法不仅一目了然,同时遍历元素的行为比遍历下标的行为更加高效!

序列解包(unpack)

当你需要将一个二元组序列拆成两列,你会怎么做?

  1. Bad
            
              Data 
              
                =
              
              
                [
              
              
                (
              
              
                'James'
              
              
                ,
              
              
                18
              
              
                )
              
              
                ,
              
              
                (
              
              
                'Tim'
              
              
                ,
              
              
                19
              
              
                )
              
              
                ,
              
              
                (
              
              
                'Katty'
              
              
                ,
              
              
                20
              
              
                )
              
              
                ]
              
              
names
              
                ,
              
               ages 
              
                =
              
              
                [
              
              
                ]
              
              
                ,
              
              
                [
              
              
                ]
              
              
                for
              
               name
              
                ,
              
               age 
              
                in
              
               Data
              
                :
              
              
    names
              
                .
              
              append
              
                (
              
              name
              
                )
              
              
    ages
              
                .
              
              append
              
                (
              
              age
              
                )
              
            
          
  1. Better
            
              Data 
              
                =
              
              
                [
              
              
                (
              
              
                'James'
              
              
                ,
              
              
                18
              
              
                )
              
              
                ,
              
              
                (
              
              
                'Tim'
              
              
                ,
              
              
                19
              
              
                )
              
              
                ,
              
              
                (
              
              
                'Katty'
              
              
                ,
              
              
                20
              
              
                )
              
              
                ]
              
              
names 
              
                =
              
              
                [
              
              data
              
                [
              
              
                0
              
              
                ]
              
              
                for
              
               data 
              
                in
              
               Data
              
                ]
              
              
ages 
              
                =
              
              
                [
              
              data
              
                [
              
              
                1
              
              
                ]
              
              
                for
              
               data 
              
                in
              
               Data
              
                ]
              
            
          
  1. Best
            
              Data 
              
                =
              
              
                [
              
              
                (
              
              
                'James'
              
              
                ,
              
              
                18
              
              
                )
              
              
                ,
              
              
                (
              
              
                'Tim'
              
              
                ,
              
              
                19
              
              
                )
              
              
                ,
              
              
                (
              
              
                'Katty'
              
              
                ,
              
              
                20
              
              
                )
              
              
                ]
              
              
names
              
                ,
              
               ages 
              
                =
              
              
                zip
              
              
                (
              
              
                *
              
              Data
              
                )
              
            
          

zip() zip(*) 是一对互逆操作,不过需要注意, zip() zip(*) 在Python 3返回的都是迭代器,然后 zip(*) 通过解包返回多个元组。

条件表达式

  1. Bad
            
              
                if
              
               x
              
                <
              
              y
              
                :
              
              
    small
              
                =
              
              x

              
                else
              
              
                :
              
              
    small
              
                =
              
              y

            
          
  1. Better
            
              small 
              
                =
              
               x 
              
                if
              
               x
              
                <
              
              y 
              
                else
              
               y

            
          

后者不仅表达意思更加明了,同时代码量也少了好几行。

if结构简化

如果你需要检查几个数值时:

  1. Bad
            
              
                if
              
               x
              
                ==
              
              
                1
              
              
                or
              
               x
              
                ==
              
              
                2
              
              
                or
              
               x
              
                ==
              
              
                3
              
              
                or
              
               x
              
                ==
              
              
                4
              
              
                :
              
              
                print
              
              
                (
              
              
                "x =1 or 2 or 3 or 4"
              
              
                )
              
            
          
  1. Better
            
              
                if
              
               x 
              
                in
              
              
                (
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "x =1 or 2 or 3 or 4"
              
              
                )
              
            
          

if链式条件表达式

  1. Bad
            
              
                if
              
               x
              
                >
              
              
                0
              
              
                and
              
               x
              
                <
              
              
                10
              
              
                :
              
              
                print
              
              
                (
              
              
                "0
                
                  <10"
                
              
              
                )
              
            
          
  1. Better
            
              
                if
              
              
                0
              
              
                <
              
              x
              
                <
              
              
                10
              
              
                :
              
              
                print
              
              
                (
              
              
                "0
                
                  <10"
                
              
              
                )
              
            
          

前者是其他语言的判断方法,而后者显然更加简洁明了。

any & all

当存在多个条件判断语句时:

  1. Bad
            
              
                if
              
               a
              
                >
              
              
                0
              
              
                or
              
               b
              
                >
              
              
                0
              
              
                or
              
               c
              
                >
              
              
                0
              
              
                :
              
              
                print
              
              
                (
              
              
                "one of them greater than 0"
              
              
                )
              
              
                if
              
               a
              
                >
              
              
                0
              
              
                and
              
               b
              
                >
              
              
                0
              
              
                and
              
               c
              
                >
              
              
                0
              
              
                :
              
              
                print
              
              
                (
              
              
                "all of them greater than 0"
              
              
                )
              
            
          
  1. Better
            
              
                if
              
              
                any
              
              
                (
              
              
                [
              
              a
              
                ,
              
              b
              
                ,
              
              c
              
                ]
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "one of them greater than 0"
              
              
                )
              
              
                if
              
              
                all
              
              
                (
              
              
                [
              
              a
              
                ,
              
              b
              
                ,
              
              c
              
                ]
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "all of them greater than 0"
              
              
                )
              
            
          

eval

eval 函数可以轻易的将字符串转化成元素,甚至可以转化表达式:

            
              
                >>
              
              
                >
              
              
                eval
              
              
                (
              
              
                '[1,2,3,4]'
              
              
                )
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                ]
              
              
                >>
              
              
                >
              
              
                eval
              
              
                (
              
              
                '(1,2,3,4)'
              
              
                )
              
              
                (
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                )
              
              
                >>
              
              
                >
              
              
                eval
              
              
                (
              
              
                '1+1'
              
              
                )
              
              
                2
              
            
          

eval 功能可谓非常强大,即可以做 string list tuple dict 之间的类型转换,还可以做计算器使用。它可以对能解析的字符串都做处理,而不顾忌可能带来的后果!所以说eval强大的背后,是巨大的安全隐患。
例如用户恶意输入下面的字符串:

            
              
                open
              
              
                (
              
              r
              
                'D://filename.txt'
              
              
                ,
              
              
                'r'
              
              
                )
              
              
                .
              
              read
              
                (
              
              
                )
              
              
                __import__
              
              
                (
              
              
                'os'
              
              
                )
              
              
                .
              
              system
              
                (
              
              
                'dir'
              
              
                )
              
              
                __import__
              
              
                (
              
              
                'os'
              
              
                )
              
              
                .
              
              system
              
                (
              
              
                'rm -rf /etc/*'
              
              
                )
              
            
          

那么 eval 就会不管三七二十一,显示你电脑目录结构,读取文件,删除文件……如果是格盘等更严重的操作,它也会照做不误。因此,更加安全的做法是使用 ast.literal_eval :

            
              
                >>
              
              
                >
              
               ast
              
                .
              
              literal_eval
              
                (
              
              
                "__import__('os').system('dir')"
              
              
                )
              
              

ValueError                                Traceback 
              
                (
              
              most recent call last
              
                )
              
              
                <
              
              ipython
              
                -
              
              
                input
              
              
                -
              
              
                95
              
              
                -
              
              
                788ef7e6407f
              
              
                >
              
              
                in
              
              
                <
              
              module
              
                >
              
              
                (
              
              
                )
              
              
                -
              
              
                -
              
              
                -
              
              
                -
              
              
                >
              
              
                1
              
               ast
              
                .
              
              literal_eval
              
                (
              
              
                "__import__('os').system('dir')"
              
              
                )
              
              
                ~
              
              \Anaconda3\lib\ast
              
                .
              
              py 
              
                in
              
               literal_eval
              
                (
              
              node_or_string
              
                )
              
              
                83
              
              
                return
              
               left 
              
                -
              
               right
     
              
                84
              
              
                raise
              
               ValueError
              
                (
              
              
                'malformed node or string: '
              
              
                +
              
              
                repr
              
              
                (
              
              node
              
                )
              
              
                )
              
              
                -
              
              
                -
              
              
                -
              
              
                >
              
              
                85
              
              
                return
              
               _convert
              
                (
              
              node_or_string
              
                )
              
              
                86
              
              
                87
              
              
                ~
              
              \Anaconda3\lib\ast
              
                .
              
              py 
              
                in
              
               _convert
              
                (
              
              node
              
                )
              
              
                82
              
              
                else
              
              
                :
              
              
                83
              
              
                return
              
               left 
              
                -
              
               right

              
                -
              
              
                -
              
              
                -
              
              
                >
              
              
                84
              
              
                raise
              
               ValueError
              
                (
              
              
                'malformed node or string: '
              
              
                +
              
              
                repr
              
              
                (
              
              node
              
                )
              
              
                )
              
              
                85
              
              
                return
              
               _convert
              
                (
              
              node_or_string
              
                )
              
              
                86
              
               

ValueError
              
                :
              
               malformed node 
              
                or
              
               string
              
                :
              
              
                <
              
              _ast
              
                .
              
              Call 
              
                object
              
               at 
              
                0x000001C9DBA145F8
              
              
                >
              
            
          

当你试图转化一些"危险"的表达式时,它会阻止你执行并报错。出于安全考虑,对字符串进行类型转换的时候最好使用 ast.literal_eval

遍历元素与下标

当你需要遍历元素得同时,获取元素的位置下标:

  1. Bad
            
              names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                len
              
              
                (
              
              names
              
                )
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "Id:{},name:{}"
              
              
                .
              
              
                format
              
              
                (
              
              i
              
                ,
              
              names
              
                [
              
              i
              
                ]
              
              
                )
              
              
                )
              
              

Id
              
                :
              
              
                0
              
              
                ,
              
              name
              
                :
              
              James
Id
              
                :
              
              
                1
              
              
                ,
              
              name
              
                :
              
              Tim
Id
              
                :
              
              
                2
              
              
                ,
              
              name
              
                :
              
              Katty

            
          
  1. Better
            
              names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ]
              
              
                for
              
               i
              
                ,
              
              name 
              
                in
              
              
                enumerate
              
              
                (
              
              names
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "Id:{},name:{}"
              
              
                .
              
              
                format
              
              
                (
              
              i
              
                ,
              
              names
              
                [
              
              i
              
                ]
              
              
                )
              
              
                )
              
              

Id
              
                :
              
              
                0
              
              
                ,
              
              name
              
                :
              
              James
Id
              
                :
              
              
                1
              
              
                ,
              
              name
              
                :
              
              Tim
Id
              
                :
              
              
                2
              
              
                ,
              
              name
              
                :
              
              Katty

            
          

前者的代码不仅难看,同时通过下标访问元素比遍历元素效率更低,而后者使用 enumerate 则优雅高效得多。

for/else

如果让你判断某个列表是否存在偶数,存在则输出该偶数,若不存在任何偶数,则输出"There are no even Numbers"

  1. Bad
            
              
                # The variable exit_even_number is redundant
              
              
exit_even_number 
              
                =
              
              
                False
              
              
                for
              
               i 
              
                in
              
              
                [
              
              
                1
              
              
                ,
              
              
                3
              
              
                ,
              
              
                5
              
              
                ,
              
              
                7
              
              
                ,
              
              
                9
              
              
                ]
              
              
                :
              
              
                if
              
               i
              
                %
              
              
                2
              
              
                ==
              
              
                0
              
              
                :
              
              
                print
              
              
                (
              
              
                "{} is even number"
              
              
                .
              
              
                format
              
              
                (
              
              i
              
                )
              
              
                )
              
              
        exit_even_number 
              
                =
              
              
                True
              
              
                if
              
              
                not
              
               exit_even_number
              
                :
              
              
                print
              
              
                (
              
              
                "There are no even Numbers"
              
              
                )
              
            
          
  1. Better
            
              
                for
              
               i 
              
                in
              
              
                [
              
              
                1
              
              
                ,
              
              
                3
              
              
                ,
              
              
                5
              
              
                ,
              
              
                7
              
              
                ,
              
              
                9
              
              
                ]
              
              
                :
              
              
                if
              
               i
              
                %
              
              
                2
              
              
                ==
              
              
                0
              
              
                :
              
              
                print
              
              
                (
              
              
                "{} is even number"
              
              
                .
              
              
                format
              
              
                (
              
              i
              
                )
              
              
                )
              
              
                else
              
              
                :
              
              
                print
              
              
                (
              
              
                "There are no even Numbers"
              
              
                )
              
            
          

前者多了一个 exit_even_number 变量,使得代码显得有点臃肿,而使用后者 for/else 则优雅得多。

dict映射代替多条件查找

  1. Bad
            
              
                if
              
               x 
              
                ==
              
              
                1
              
              
                :
              
              
    y 
              
                =
              
              
                100
              
              
                elif
              
               x 
              
                ==
              
              
                2
              
              
                :
              
              
    y 
              
                =
              
              
                200
              
              
                elif
              
               x 
              
                ==
              
               
    y 
              
                =
              
              
                300
              
            
          
  1. Better
            
              condition = {1:100, 2:200, 3:300}
y = condition[x]

            
          

访问字典元素

访问字典元素的方法想必大家都清楚,但是如果字典中不存在该键值对呢?

  1. Bad
            
              
                >>
              
              
                >
              
               phone_number 
              
                =
              
              
                {
              
              
                'James'
              
              
                :
              
              
                123456
              
              
                ,
              
              
                'Tim'
              
              
                :
              
              
                678910
              
              
                ,
              
              
                'Katty'
              
              
                :
              
              
                111213
              
              
                }
              
              
                >>
              
              
                >
              
               phone_number
              
                [
              
              
                'James'
              
              
                ]
              
              
                123456
              
              
                >>
              
              
                >
              
               phone_number
              
                [
              
              
                'james'
              
              
                ]
              
              

KeyError                                  Traceback 
              
                (
              
              most recent call last
              
                )
              
              
                <
              
              ipython
              
                -
              
              
                input
              
              
                -
              
              
                64
              
              
                -
              
              
                6f91c5f93ae0
              
              
                >
              
              
                in
              
              
                <
              
              module
              
                >
              
              
                (
              
              
                )
              
              
                1
              
               phone_number 
              
                =
              
              
                {
              
              
                'James'
              
              
                :
              
              
                123456
              
              
                ,
              
              
                'Tim'
              
              
                :
              
              
                678910
              
              
                ,
              
              
                'Katty'
              
              
                :
              
              
                111213
              
              
                }
              
              
                -
              
              
                -
              
              
                -
              
              
                -
              
              
                >
              
              
                2
              
               phone_number
              
                [
              
              
                'james'
              
              
                ]
              
              

KeyError
              
                :
              
              
                'james'
              
            
          
  1. Better
            
              
                >>
              
              
                >
              
               phone_number 
              
                =
              
              
                {
              
              
                'James'
              
              
                :
              
              
                123456
              
              
                ,
              
              
                'Tim'
              
              
                :
              
              
                678910
              
              
                ,
              
              
                'Katty'
              
              
                :
              
              
                111213
              
              
                }
              
              
                >>
              
              
                >
              
               phone_number
              
                [
              
              
                'James'
              
              
                ]
              
              
                if
              
              
                'james'
              
              
                in
              
               phone_number 
              
                else
              
              
                "Not Found"
              
              
                123456
              
              
                >>
              
              
                >
              
               phone_number
              
                [
              
              
                'james'
              
              
                ]
              
              
                if
              
              
                'james'
              
              
                in
              
               phone_number 
              
                else
              
              
                "Not Found"
              
              
                'Not Found'
              
            
          
  1. Best
            
              
                >>
              
              
                >
              
               phone_number 
              
                =
              
              
                {
              
              
                'James'
              
              
                :
              
              
                123456
              
              
                ,
              
              
                'Tim'
              
              
                :
              
              
                678910
              
              
                ,
              
              
                'Katty'
              
              
                :
              
              
                111213
              
              
                }
              
              
                >>
              
              
                >
              
               phone_number
              
                .
              
              get
              
                (
              
              
                'James'
              
              
                ,
              
              
                "Not Found"
              
              
                )
              
              
                123456
              
              
                >>
              
              
                >
              
               phone_number
              
                .
              
              get
              
                (
              
              
                'james'
              
              
                ,
              
              
                "Not Found"
              
              
                )
              
              
                'Not Found'
              
            
          

defaultdict

当你的字典中,每一个键值对应的是一个列表时,如何使用 append 操作?

  1. Bad
            
              my_dict 
              
                =
              
              
                {
              
              
                }
              
              
names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ,
              
              
                'James'
              
              
                ]
              
              
numbers 
              
                =
              
              
                [
              
              
                123456
              
              
                ,
              
              
                678910
              
              
                ,
              
              
                111213
              
              
                ,
              
              
                456789
              
              
                ]
              
              
                for
              
               name
              
                ,
              
               number 
              
                in
              
              
                zip
              
              
                (
              
              names
              
                ,
              
               numbers
              
                )
              
              
                :
              
              
                if
              
               name 
              
                in
              
               my_dict
              
                :
              
              
        my_dict
              
                [
              
              name
              
                ]
              
              
                .
              
              append
              
                (
              
              number
              
                )
              
              
                else
              
              
                :
              
              
        my_dict
              
                [
              
              name
              
                ]
              
              
                =
              
              
                [
              
              
                ]
              
              
        my_dict
              
                [
              
              name
              
                ]
              
              
                .
              
              append
              
                (
              
              number
              
                )
              
              
                >>
              
              
                >
              
               my_dict

              
                {
              
              
                'James'
              
              
                :
              
              
                [
              
              
                123456
              
              
                ,
              
              
                456789
              
              
                ]
              
              
                ,
              
              
                'Tim'
              
              
                :
              
              
                [
              
              
                678910
              
              
                ]
              
              
                ,
              
              
                'Katty'
              
              
                :
              
              
                [
              
              
                111213
              
              
                ]
              
              
                }
              
            
          
            
              
                from
              
               collections 
              
                import
              
               defaultdict

my_dict 
              
                =
              
               defaultdict
              
                (
              
              
                list
              
              
                )
              
              
names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ,
              
              
                'James'
              
              
                ]
              
              
numbers 
              
                =
              
              
                [
              
              
                123456
              
              
                ,
              
              
                678910
              
              
                ,
              
              
                111213
              
              
                ,
              
              
                456789
              
              
                ]
              
              
                for
              
               name
              
                ,
              
               number 
              
                in
              
              
                zip
              
              
                (
              
              names
              
                ,
              
               numbers
              
                )
              
              
                :
              
              
    my_dict
              
                [
              
              name
              
                ]
              
              
                .
              
              append
              
                (
              
              number
              
                )
              
              
                >>
              
              
                >
              
               my_dict
defaultdict
              
                (
              
              
                list
              
              
                ,
              
              
                {
              
              
                'James'
              
              
                :
              
              
                [
              
              
                123456
              
              
                ,
              
              
                456789
              
              
                ]
              
              
                ,
              
              
                'Tim'
              
              
                :
              
              
                [
              
              
                678910
              
              
                ]
              
              
                ,
              
              
                'Katty'
              
              
                :
              
              
                [
              
              
                111213
              
              
                ]
              
              
                }
              
              
                )
              
            
          

后者使用 defaultdict ,省去了判断字典中否存在某个键值对应的列表,使得代码更加简洁易懂。 default 还有 int tuple 等类型。
2. Better

            
              my_dict 
              
                =
              
              
                {
              
              
                }
              
              
names 
              
                =
              
              
                [
              
              
                'James'
              
              
                ,
              
              
                'Tim'
              
              
                ,
              
              
                'Katty'
              
              
                ,
              
              
                'James'
              
              
                ]
              
              
numbers 
              
                =
              
              
                [
              
              
                123456
              
              
                ,
              
              
                678910
              
              
                ,
              
              
                111213
              
              
                ,
              
              
                456789
              
              
                ]
              
              
                for
              
               name
              
                ,
              
               number 
              
                in
              
              
                zip
              
              
                (
              
              names
              
                ,
              
               numbers
              
                )
              
              
                :
              
              
                if
              
               name 
              
                in
              
               my_dict
              
                :
              
              
        my_dict
              
                [
              
              name
              
                ]
              
              
                .
              
              append
              
                (
              
              number
              
                )
              
              
                else
              
              
                :
              
              
        my_dict
              
                [
              
              name
              
                ]
              
              
                =
              
              
                [
              
              
                ]
              
            
          

列表/字典解析式

当你想要生成一个列表或者字典的时候:

  1. Bad

生成列表

            
              my_list 
              
                =
              
              
                [
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
    my_list
              
                .
              
              append
              
                (
              
              i
              
                *
              
              i
              
                )
              
              
                >>
              
              
                >
              
               my_list

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

生成字典

            
              my_dict 
              
                =
              
              
                {
              
              
                }
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
    my_dict
              
                [
              
              i
              
                ]
              
              
                =
              
              i
              
                *
              
              i

              
                >>
              
              
                >
              
               my_dict

              
                {
              
              
                0
              
              
                :
              
              
                0
              
              
                ,
              
              
                1
              
              
                :
              
              
                1
              
              
                ,
              
              
                2
              
              
                :
              
              
                4
              
              
                ,
              
              
                3
              
              
                :
              
              
                9
              
              
                ,
              
              
                4
              
              
                :
              
              
                16
              
              
                ,
              
              
                5
              
              
                :
              
              
                25
              
              
                ,
              
              
                6
              
              
                :
              
              
                36
              
              
                ,
              
              
                7
              
              
                :
              
              
                49
              
              
                ,
              
              
                8
              
              
                :
              
              
                64
              
              
                ,
              
              
                9
              
              
                :
              
              
                81
              
              
                }
              
            
          
  1. Better

生成列表

            
              
                >>
              
              
                >
              
              
                [
              
              i
              
                *
              
              i 
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                ]
              
              
                [
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                4
              
              
                ,
              
              
                9
              
              
                ,
              
              
                16
              
              
                ,
              
              
                25
              
              
                ,
              
              
                36
              
              
                ,
              
              
                49
              
              
                ,
              
              
                64
              
              
                ,
              
              
                81
              
              
                ]
              
            
          

生成字典

            
              
                >>
              
              
                >
              
              
                {
              
              i
              
                :
              
              i
              
                *
              
              i 
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                }
              
              
                {
              
              
                0
              
              
                :
              
              
                0
              
              
                ,
              
              
                1
              
              
                :
              
              
                1
              
              
                ,
              
              
                2
              
              
                :
              
              
                4
              
              
                ,
              
              
                3
              
              
                :
              
              
                9
              
              
                ,
              
              
                4
              
              
                :
              
              
                16
              
              
                ,
              
              
                5
              
              
                :
              
              
                25
              
              
                ,
              
              
                6
              
              
                :
              
              
                36
              
              
                ,
              
              
                7
              
              
                :
              
              
                49
              
              
                ,
              
              
                8
              
              
                :
              
              
                64
              
              
                ,
              
              
                9
              
              
                :
              
              
                81
              
              
                }
              
            
          

列表/字典推导式是Python独具特色的功能之一,使用可以使得你的代码更加简洁高效。类似地,你也可以使用元组推导式。

字符串连接

当你需要创建一串字符串类似 0123456789 ,你会如何做?

  1. Bad
            
              string 
              
                =
              
              
                ''
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
    string 
              
                +=
              
              
                str
              
              
                (
              
              i
              
                )
              
              
                >>
              
              
                >
              
               string

              
                '0123456789'
              
            
          
  1. Better
            
              string 
              
                =
              
              
                [
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
    string 
              
                .
              
              append
              
                (
              
              
                str
              
              
                (
              
              i
              
                )
              
              
                )
              
              
                >>
              
              
                >
              
              
                ''
              
              
                .
              
              join
              
                (
              
              string
              
                )
              
              
                '0123456789'
              
              
                # or like this
              
              
string 
              
                =
              
              
                [
              
              
                str
              
              
                (
              
              i
              
                )
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                ]
              
              
                >>
              
              
                >
              
              
                ''
              
              
                .
              
              join
              
                (
              
              string
              
                )
              
              
                '0123456789'
              
            
          
  1. Best
            
              string 
              
                =
              
              
                map
              
              
                (
              
              
                str
              
              
                ,
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                )
              
              
                >>
              
              
                >
              
              
                ''
              
              
                .
              
              join
              
                (
              
              string
              
                )
              
              
                '0123456789'
              
            
          

join 是一种更加高效的字符串连接方式,使用 + 操作时,每执行一次 + 操作就会导致在内存中生成一个新的字符串对象,遍历10次有10个字符串生成,造成无谓的内存浪费。而用 join 方法整个过程只会产生一个字符串对象。最后一个方法使用了 map 函数,在某些情况下, map 函数更易于理解,效率更高。

"_"的妙用

在Python中, _ 的作用主要用来充当一个临时变量,例如:

            
              
                for
              
               _ 
              
                in
              
              
                range
              
              
                (
              
              
                5
              
              
                )
              
                print
              
              
                (
              
              
                "Hello"
              
              
                )
              
            
          

当你只需要一个循环多次重复做某件事,但是并不需要循环体的变量,就可以使用 _ 当作一个占位符代替,同时也省去了命名的麻烦。
同时,在Python解释器中, _ 还可以充当一个保存临时结果的容器:

            
              
                >>
              
              
                >
              
              
                1
              
              
                +
              
              
                2
              
              
                3
              
              
                >>
              
              
                >
              
               _

              
                3
              
            
          

在这里 _ 保存了上一次解释器运行的结果。
同时,也可以作为多变量赋值的一个承载容器:

            
              L 
              
                =
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                ,
              
              
                5
              
              
                ]
              
              
first
              
                ,
              
              
                *
              
              _
              
                ,
              
               last 
              
                =
              
               L


              
                >>
              
              
                >
              
               fitst

              
                1
              
              
                >>
              
              
                >
              
               last

              
                5
              
            
          

map函数

如果我们有一个函数,希望将其作用在一个list[0,1,2,3,4]上,如何实现?

  1. Bad
            
              L 
              
                =
              
              
                [
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                [
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                ]
              
              
                :
              
              
    L
              
                .
              
              append
              
                (
              
              f
              
                (
              
              i
              
                )
              
              
                )
              
              
                >>
              
              
                >
              
               L

              
                [
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                4
              
              
                ,
              
              
                9
              
              
                ,
              
              
                16
              
              
                ]
              
            
          
  1. Better
            
              
                >>
              
              
                >
              
              
                list
              
              
                (
              
              
                map
              
              
                (
              
              
                lambda
              
               i
              
                :
              
              i
              
                *
              
              i
              
                ,
              
              
                range
              
              
                (
              
              
                5
              
              
                )
              
              
                )
              
              
                )
              
              
                [
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                4
              
              
                ,
              
              
                9
              
              
                ,
              
              
                16
              
              
                ]
              
            
          

后者的代码显然一目了然。 map 接收两个参数,一个是函数,一个是序列(迭代器), map 将传入的函数依次作用到序列(迭代器)的每个元素,并把结果作为新的迭代器返回。同时,作为Python内建的高阶函数,事实上它把运算规则抽象了,因此,我们不但可以计算简单的 f ( x ) = x 2 f(x)=x^2 f ( x ) = x 2 ,还可以计算任意复杂的函数,例如作类型转换:

            
              
                >>
              
              
                >
              
              
                list
              
              
                (
              
              
                map
              
              
                (
              
              
                str
              
              
                ,
              
              
                range
              
              
                (
              
              
                5
              
              
                )
              
              
                )
              
              
                )
              
              
                [
              
              
                '0'
              
              
                ,
              
              
                '1'
              
              
                ,
              
              
                '2'
              
              
                ,
              
              
                '3'
              
              
                ,
              
              
                '4'
              
              
                ]
              
            
          

最后很重要的一点是, map 可以接受多个迭代器序列,并且并行地对每个序列对应元素执行该函数,会比普通的函数更加高效。

reduce函数

如果我们需要将[1,2,3,4]转化成1234,如何做?

  1. Bad
            
              
                sum
              
              
                =
              
              
                0
              
              
                for
              
               i 
              
                in
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                ]
              
              
                :
              
              
                sum
              
              
                =
              
              
                sum
              
              
                *
              
              
                10
              
              
                +
              
               i


              
                >>
              
              
                >
              
              
                sum
              
              
                1234
              
            
          
  1. Better
            
              
                # reduce is not built-in function from python 3
              
              
                from
              
               functools 
              
                import
              
              
                reduce
              
              
                >>
              
              
                >
              
              
                reduce
              
              
                (
              
              
                lambda
              
               x
              
                ,
              
              y
              
                :
              
               x
              
                *
              
              
                10
              
              
                +
              
              y
              
                ,
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                4
              
              
                ]
              
              
                )
              
              
                1234
              
            
          

在Python 3中, reduce 函数已经不再是内置函数,而是放入了functools模块。 reduce 把一个函数作用在一个序列[x1, x2, x3…]上,这个函数必须接收两个参数, reduce 把结果继续和序列的下一个元素做累积计算

filter函数

当你需要过滤一个列表的元素,例如,将列表中的奇数删除,只留下偶数:

            
              L 
              
                =
              
              
                list
              
              
                (
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                )
              
              
                for
              
               i 
              
                in
              
               L
              
                :
              
              
                if
              
               i
              
                %
              
              
                2
              
              
                ==
              
              
                0
              
              
                :
              
              
        L
              
                .
              
              remove
              
                (
              
              i
              
                )
              
              
                >>
              
              
                >
              
               L

              
                [
              
              
                0
              
              
                ,
              
              
                2
              
              
                ,
              
              
                4
              
              
                ,
              
              
                6
              
              
                ,
              
              
                8
              
              
                ]
              
            
          
  1. Better
            
              L 
              
                =
              
              
                list
              
              
                (
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                )
              
              
                >>
              
              
                >
              
              
                list
              
              
                (
              
              
                filter
              
              
                (
              
              
                lambda
              
               x
              
                :
              
               x
              
                %
              
              
                2
              
              
                ==
              
              
                0
              
              
                ,
              
               L
              
                )
              
              
                )
              
              
                [
              
              
                0
              
              
                ,
              
              
                2
              
              
                ,
              
              
                4
              
              
                ,
              
              
                6
              
              
                ,
              
              
                8
              
              
                ]
              
            
          

这里 filter 返回的是一个迭代器,显然后者的方法比前者更加优雅简洁。

生成器(generator)

前面介绍过,我们可以直接使用列表推导式创建一个完整的列表,当列表元素剧增的时候,如果只需要访问某几个元素,那将是十分浪费存储空间的。而生成器正是为了解决这一问题,一边循环一边计算,列表元素按照某种算法推算出来,从而节省大量空间。

  1. Bad
            
              
                >>
              
              
                >
              
              
                [
              
              x 
              
                *
              
               x 
              
                for
              
               x 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                ]
              
              
                [
              
              
                0
              
              
                ,
              
              
                1
              
              
                ,
              
              
                4
              
              
                ,
              
              
                9
              
              
                ,
              
              
                16
              
              
                ,
              
              
                25
              
              
                ,
              
              
                36
              
              
                ,
              
              
                49
              
              
                ,
              
              
                64
              
              
                ,
              
              
                81
              
              
                ]
              
            
          
  1. Better
            
              
                >>
              
              
                >
              
              
                (
              
              x 
              
                *
              
               x 
              
                for
              
               x 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                )
              
              
                <
              
              generator 
              
                object
              
              
                <
              
              genexpr
              
                >
              
               at 
              
                0x000001EB028DBA98
              
              
                >
              
            
          

二者的区别只是一个用了 [] ,另一个用了 () ,前者生成一个完整的列表,后者生成一个生成器。生成器的作用无疑是强大的,这里不作过多介绍,更多内容请参加Python文档。

yield

写一个简单的斐波那契数列吧

  1. Bad
            
              
                def
              
              
                fib
              
              
                (
              
              n
              
                )
              
              
                :
              
              
    x
              
                ,
              
               y 
              
                =
              
              
                0
              
              
                ,
              
              
                1
              
              
    L 
              
                =
              
              
                [
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              n
              
                )
              
              
                :
              
              
        L
              
                .
              
              append
              
                (
              
              y
              
                )
              
              
        x
              
                ,
              
               y 
              
                =
              
               y
              
                ,
              
               x
              
                +
              
              y
    
              
                return
              
               L


              
                >>
              
              
                >
              
               fib
              
                (
              
              
                5
              
              
                )
              
              
                [
              
              
                1
              
              
                ,
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                5
              
              
                ]
              
            
          
  1. Better
            
              
                def
              
              
                fib
              
              
                (
              
              n
              
                )
              
              
                :
              
              
    x
              
                ,
              
               y 
              
                =
              
              
                0
              
              
                ,
              
              
                1
              
              
    L 
              
                =
              
              
                [
              
              
                ]
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              n
              
                )
              
              
                :
              
              
                yield
              
               y
        x
              
                ,
              
               y 
              
                =
              
               y
              
                ,
              
               x
              
                +
              
              y


              
                >>
              
              
                >
              
              
                list
              
              
                (
              
              fib
              
                (
              
              
                5
              
              
                )
              
              
                )
              
              
                [
              
              
                1
              
              
                ,
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ,
              
              
                5
              
              
                ]
              
            
          

后者使用了 yield 生成器,该生成器的特点是在哪里使用 yield 在哪里中断,下次返回时候从中断处开始执行,并且返回的是一个生成器,从而节省空间,提高代码效率。关于 yield 的强大之处我这里不便详细介绍,如果你需要详细了解,请参见The Python yield keyword explained。

partial函数

函数在执行时,如果不是默认参数,就必须在调用前传入。但是,有些参数是可以在函数被调用之前提前获知的,这种情况下,一个函数有一个或多个参数预先就能知道,以便函数能用更少的参数进行调用。
我们先看一个乘法的例子,让每个传入的参数都乘以一个固定的常数:

            
              
                # partial is not built-in function from python 3
              
              
                from
              
               functools 
              
                import
              
               partial

              
                def
              
              
                mul
              
              
                (
              
              a
              
                ,
              
               b
              
                )
              
              
                :
              
              
                return
              
               a
              
                *
              
              b

mul_partial 
              
                =
              
               partial
              
                (
              
              mul
              
                ,
              
              b
              
                =
              
              
                10
              
              
                )
              
              
                for
              
               i 
              
                in
              
              
                range
              
              
                (
              
              
                10
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              mul_partial
              
                (
              
              i
              
                )
              
              
                ,
              
              end
              
                =
              
              
                ' '
              
              
                )
              
              
                #  0 10 20 30 40 50 60 70 80 90 
              
            
          

也许你会说,这不就和默认参数一样吗,那我只要在定义函数 mul() 里将 b 固定为10,效果不是一样的?

            
              
                # using default parameters
              
              
                def
              
              
                mul
              
              
                (
              
              a
              
                ,
              
               b
              
                =
              
              
                10
              
              
                )
              
              
                :
              
              
                return
              
               a
              
                *
              
              b

            
          

但是,如果你要传入的 b ,你事先并不知道,而是需要在程序运行的时候才能获取到,那么你如何提前使用固定参数确定好呢?这时候 partial 就有着极大的用处!

lru_cache

仍然是一个计算斐波那契数列的例子,这次我们使用递归实现(虽然递归效率远低于循环,但这里只是作为一个例子演示,实际中最好少用递归)

  1. Bad
            
              
                import
              
               time


              
                def
              
              
                fib
              
              
                (
              
              n
              
                )
              
              
                :
              
              
                if
              
               n 
              
                ==
              
              
                0
              
              
                :
              
              
                return
              
              
                0
              
              
                if
              
               n 
              
                ==
              
              
                1
              
              
                :
              
              
                return
              
              
                1
              
              
                return
              
               fib
              
                (
              
              n
              
                -
              
              
                1
              
              
                )
              
              
                +
              
               fib
              
                (
              
              n
              
                -
              
              
                2
              
              
                )
              
              

start 
              
                =
              
               time
              
                .
              
              time
              
                (
              
              
                )
              
              
                >>
              
              
                >
              
               fib
              
                (
              
              
                40
              
              
                )
              
              
                102334155
              
              
                >>
              
              
                >
              
               f
              
                'Duration: {time.time() - start}s'
              
              
Duration
              
                :
              
              
                40.
              
              126065492630005s

            
          
  1. Better
            
              
                import
              
               time

              
                from
              
               functools 
              
                import
              
               lru_cache

@lru_cache
              
                (
              
              maxsize
              
                =
              
              
                512
              
              
                )
              
              
                def
              
              
                fib
              
              
                (
              
              n
              
                )
              
              
                :
              
              
                if
              
               n 
              
                ==
              
              
                0
              
              
                :
              
              
                return
              
              
                0
              
              
                if
              
               n 
              
                ==
              
              
                1
              
              
                :
              
              
                return
              
              
                1
              
              
                return
              
               fib
              
                (
              
              n
              
                -
              
              
                1
              
              
                )
              
              
                +
              
               fib
              
                (
              
              n
              
                -
              
              
                2
              
              
                )
              
              
    
start 
              
                =
              
               time
              
                .
              
              time
              
                (
              
              
                )
              
              
                >>
              
              
                >
              
               fib
              
                (
              
              
                40
              
              
                )
              
              
                102334155
              
              
                >>
              
              
                >
              
               f
              
                'Duration: {time.time() - start}s'
              
              
Duration
              
                :
              
              
                0.
              
              0009968280792236328s

            
          

可以看到,使用了LRU缓存后,二者的运行时间简直天差地别。

枚举

            
              
                from
              
               enum 
              
                import
              
               Enum
              
                ,
              
               auto

              
                class
              
              
                Animal
              
              
                (
              
              Enum
              
                )
              
              
                :
              
              
    bird 
              
                =
              
               auto
              
                (
              
              
                )
              
              
    dog 
              
                =
              
               auto
              
                (
              
              
                )
              
              
    cat 
              
                =
              
               auto
              
                (
              
              
                )
              
              
                >>
              
              
                >
              
              
                print
              
              
                (
              
              Animal
              
                .
              
              cat
              
                )
              
              
Animal
              
                .
              
              cat

            
          

Python 3 中的 Enum 类支持枚举功能,可以使我们的程序变得更加简洁。 Enum 是一种便捷的变量列表的打包方式,使用该方法能够避免多个变量在代码各处分布而显得杂乱无章。枚举是一个符号集合,每个符号都和唯一的变量对应。通过使用枚举,我们可以通过符号标识来比较各个成员,我们还可以对枚举本身进行迭代。

Reference

[1] Data, what now?
[2] The Hitchhiker’s Guide to Python
[3] The Python yield keyword explained
[4] Generators


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

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

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