Python学习笔记（六）之函数式编程

0. Python函数式编程思维导图

0.1 导图链接

Python函数式编程

0.2 导图截图

• 可能不够清晰看链接就好啦

1.函数式编程（Functional Programming）

• 在编程语言中（抽象程度是相对于计算机来说的）：
  • 越低级的语言，越贴近计算机，抽象程度越低，执行效率越高，如C语言；
  • 越高级的语言，越贴近数学计算，抽象程度高，执行效率越低，如Lisp。
• 函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量。
• 函数式编程特点：
  • 允许将一个函数作为参数传入到另一个函数中。
  • 允许返回一个函数。
• Python对函数式编程提供部分支持，由于Python允许使用变量，所以它不是存函数式编程。

2. 高阶函数

2.1 高阶函数是什么？

• 首先了解两个概念

  1. 变量可以指向函数

     • 例2.1.1：

       >>> abs
       
       >>> a = abs
       >>> a(-1)
       1
       

     • 分析：函数本身可以赋值给变量。上述例子中被赋值的变量a可以当做abs函数本身来使用。

  2. 函数名也是变量

     • 例2.1.2：

       >>> abs = 10
       >>> abs(-1)
       Traceback (most recent call last):
         File "", line 1, in 
       TypeError: 'int' object is not callable
       

     • 分析：这里的函数名abs指向了数字10后，我们再以函数的形式调用它，就已经不起作用了，因为abs已经不指向求绝对值的函数，而是指向了10这个整数！说明函数名本身也是变量。

• 搞懂了上面两个概念后，我们再回过头来看高阶函数。

  • 一个函数可以接受另一个函数作为参数，这种函数就是高阶函数。

  • 例2.1.3：

    #!/user/bin/python
    #coding=utf-8
    
    _author_ = "zjw"
    
    #一个计算两个列表总长度的高阶函数函数
    def allLen(x, y, fun):
        return fun(x) + fun(y)
    
    if __name__ == "__main__":
        li1 = [1, 2, 3]
        li2 = [4, 5]
        print allLen(li1, li2, len)
    

  • 输出

    5

  • 分析：上述高阶函数allLen是一个计算两个列表长度总和的函数。该函数将len函数作为参数传入到allLen函数中，所以是一个高阶函数。

2.2 map

• 基本形式：map(function, Iterable)；

  • function指某个特定的函数。
  • Iterable，即凡是可以使用for循环的对象都是Iterable类型的。如list, tuple, dict, set, str等。

• map函数返回一个Iterator(即凡是可以使用next()函数的对象都是Iterator类型的)。

  • 注：因为Iterator是一个惰性序列，所以在返回值时可以使用list()函数把整个序列编程一个list型。

• 函数说明：map将传入的函数依次作用到序列的每一个元素，并把结果作为新的Iterator返回。

• 实例

  • 例2.2.1：

    #!/user/bin/python
    #coding=utf-8
    
    _author_ = "zjw"
    
    if __name__ == "__main__":
        li = [-1, -3, 2, -3]
        newList = list(map(abs, li))
        print newList
    

  • 输出：

    [1, 3, 2, 3]

  • 分析：上面例子中，map函数的作用是将abs函数作用于li列表的每一个元素，返回一个全部都是绝对值的新列表newList；这里在map函数外还嵌套了一个list函数的作用是将惰性序列转化为列表。

2.3 reduce

• 基本形式：reduce(function, Iterable);

  • function指某个特定函数。
  • Iterable的说明如上。

• reduce函数返回的是一个值。

• 函数说明：。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，效果如下：

  reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
  

• 实例

  • 例2.3.1：

    #!/user/bin/python
    #coding=utf-8
    
    _author_ = "zjw"
    
    def add(x, y):
        return x + y
    
    if __name__ == "__main__":
        li = range(11)
        sum = reduce(add, li)
        print sum
    

  • 输出

    55

  • 分析：这里的reduce函数是将add函数作为功能函数，一开始传入两个li的元素，得到结果与li的下一个元素再传入add函数中，以此类推，得到最后的总和的结果。

2.4 filter

• 基本形式：filter(function, Iterable);

• 函数返回一个Iterator。

• 函数说明：filter()把传入的函数依次作用到每一个元素上，然后根据函数的返回值是True还是False决定保留还是丢弃该元素。即就像一个过滤器一样，过滤掉我们不想要的元素。

• 实例：

  • 例2.4.1：

    #!/user/bin/python
    #coding=utf-8
    
    _author_ = "zjw"
    
    #判断是否为偶数，偶数返回True，反之返回False
    def isEven(x):
        return x % 2 == 0
    
    if __name__ == "__main__":
        li = [1, 2, 3, 4]
        newList = list(filter(isEven, li))
        print(newList)
    

  • 输出：

    [2, 4]

  • 分析：这里的isEven函数是一个功能函数，用来判断是否为偶数，再通过filter函数进行筛选，将li列表中不是偶数的元素筛选掉，左右输出的是只有偶数的序列。

2.5 sorted

• sorted (iterable, *, key=None, reverse=False)

  • iterable 即一个可以使用for循环的序列。
  • *是一个特殊分隔符，后面的两个参数时命名关键字参数。
    • key中可以传入一个函数，用来指定排序规则，即映射函数，是排序的灵魂所在。
    • reverse则是决定最后输出序列是递增还是递减序列，默认是递增，即reverse = False。想要改成递减即reverse = True即可。

• 函数返回一个递增或递减序列。

• 函数说明：排序。

• 实例：

  • 例2.5.1：

    >>> li = ['Z', 'a', 'z', 'c', 'A']
    >>> sorted(li)
    ['A', 'Z', 'a', 'c', 'z']
    

    • 分析：默认情况下对字符串的排序是按照ASCII的大小进行排序的，其中大写字母'Z'<'a'，所以大写Z排在小写a之前。且默认情况下排序结果是递增序列。

  • 改进2.0，例2.5.2：

    >>> li = ['Z', 'a', 'z', 'c', 'A']
    >>> sorted(li)
    ['A', 'Z', 'a', 'c', 'z']
    >>> sorted(li, key = str.lower)
    ['a', 'A', 'c', 'Z', 'z']
    

    • 分析：通过key关键字参数规定了排序规则为，将所有字母都变成小写字母后再进行排序，且最后得到的排序序列依旧是原来的字母。

  • 改进3.0，例2.5.3：

    >>> li = ['Z', 'a', 'z', 'c', 'A']
    >>> sorted(li)
    ['A', 'Z', 'a', 'c', 'z']
    >>> sorted(li, key = str.lower)
    ['a', 'A', 'c', 'Z', 'z']
    >>> sorted(li, key = str.lower, reverse = True)
    ['Z', 'z', 'c', 'a', 'A']
    

    • 分析：这次将reverse改成True，则函数根据key规则调整后，又将序列通过逆序输出了出来。

3. 返回函数

3.1 返回函数是什么？

• 顾名思义：函数作为返回值的函数。相当于函数中嵌套一个函数，然后实现该函数后，并返回该函数。

• 将函数作为结果返回也是高阶函数的另一个特性。

3.2 返回函数实例分析

• 例3.2.1：

  #!/user/bin/python
  #coding=utf-8
  
  _author_ = "zjw"
  
  
  def lazy_sum(*args):
      def sum():
          ax = 0
          for n in args:
              ax = ax + n
          return ax
      return sum
  
  if __name__ == "__main__":
      f1 = lazy_sum(1, 2, 3, 4)
      f2 = lazy_sum(5, 6, 7, 8)
      print f1, f2
      print f1(), f2()
  

• 输出：

  
  10 26

• 分析：

  • 可以看到，当我们调用f1和f2的时候，得到的是一个函数本身，即lazy_sum内部函数sum。
  • 当我们想要得到内部函数sum所求的值时，我们需要调用f1()和f2()来得到。
  • 值得注意的是，这里在函数lazy_sum中又定义了函数sum，且内部函数sum可以引用外部函数 lazy_sum的参数和局部变量。当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”。

4. 匿名函数（lambda）

4.1 匿名函数是什么？

• 所谓匿名，匿名，就是将名字隐藏，或则直接说它是没有名字的函数也不为过。哈哈，Python的匿名函数可以说所有的匿名函数的名字统一都是lambda。
• 匿名函数的存在，将已经非常简约的函数又一次变得更简约，且在某些函数使用次数不多的情况下，可以随心所欲的创建和使用。
• 相对于java来说，Python只对匿名函数提供了有限的支持。因为Python中的匿名函数只能够有一个表达式。

4.2 匿名函数实例分析

• 例4.2.1：

  >>> list(map(lambda x : 2 * x, [1, 2, 3, 4, 5]))
  [2, 4, 6, 8, 10]
  

  • 分析：其中map函数和list的转化已经比较熟悉了。那么来看一下这里的lambda函数lambda x : 2 * x，它就相当于一下的函数：

    def f(x):
        return 2 * x
    

  • 其中lambda函数中的关键字lambda就是用来昭示匿名函数，冒号前面的x表示要传入函数的参数，冒号后的2 * x表示的就是return的内容。

• 例4.2.2

  >>> f = lambda x, y : x + y
  >>> f(1, 2)
  3
  >>> f('a', 'b')
  'ab'
  

  • 分析：如该lambda函数表达式所示，函数传入两个数据，中间用,号隔开，并返回两个数据的和，当然和也可以是字符串的和。且在该例子中，我们将该匿名函数作为一个对象赋值给了变量f，调用变量f即可调用我们创建的匿名函数。该函数的原型应该如下：

    def f(x, y):
        return x + y
    

4.3 匿名函数注意点

• 好处：
  • 因为匿名函数没有名字，所以不必担心函数名冲突的问题。
  • 匿名函数也是一个函数对象，可以赋值给一个变量，再利用变量来调用函数。
• 需要注意的是，匿名函数有一个限制，就是只能有一个表达式，该表达式的计算结果就是该匿名函数的返回结果。所以只有一些简单的情况下可以使用匿名函数。

5. 装饰器(Decorator)

5.1 装饰器是什么？

• 首先来写一个简单的函数：

  def now():
      print("这里是now函数，时间是2020年1月19日21:57:19。")
  

• 现在我们有了一个简单的now()函数，当我们想在这个函数的前后加一些装饰，即给他加一些说明时，我们往往会在now函数里面动手脚，但是当我们想要在不动now函数本体的情况下进行一些修改时，我们就要用到装饰器了。

• 这种在代码运行期间动态增加功能的方式，称之为装饰器。

5.2 装饰器实例分析

• 实例1：两层嵌套decorator用法

  • 例5.2.1：

    #!/user/bin/python
    #coding=utf-8
    
    _author_ = "zjw"
    
    #用作now()函数的装饰函数
    def log(func):
        def wrapper(*args, **kw):
            print('call %s():' % func.__name__)
            return func(*args, **kw)
        print("现在执行的是wrapper函数")
        return wrapper
    
    @log
    def now():
        print("2020 1 19")
    
    if __name__ == "__main__":
        now()
    

  • 输出：

    现在执行的是wrapper函数
    call now():
    2020 1 19

  • 分析：在调用now函数的时候，实际上我们先调用了@log中的函数内容。Python就是通过@语法，把decorator置于函数的定义处的，并在调用该函数的时候，实际上是执行了now = log(now)。
    之所以我们看到先执行了wrapper函数，是因为我们进入到log函数后，先跳过了wrapper函数，执行了print("现在执行的是wrapper函数")，在返回函数wrapper的时候调用了wrapper函数，并输出了下面的内容。我们看到wrapper函数的参数是(*args, **kw)，所以该函数可以接受任意参数的调用。

• 实例2：三层嵌套decorator用法

  • 实例5.2.2:

    #!/user/bin/python
    #coding=utf-8
    
    _author_ = "zjw"
    
    #用作now()函数的装饰函数
    def log(text):
        def decorator(func):
            def wrapper(*args, **kw):
                print('%s %s():' % (text, func.__name__))
                return func(*args, **kw)
            print('我现在执行的是decorator函数')
            return wrapper
        print("我现在执行的还是log函数")
        return decorator
    
    @log('execute')
    def now():
        print("2020 1 19")
    
    if __name__ == "__main__":
        now()
    

  • 输出：

    我现在执行的还是log函数
    我现在执行的是decorator函数
    execute now():
    2020 1 19

  • 分析：3层decorator调用实际上效果是：now = log('execute')(now)。首先我们看到执行的是log函数，因为log函数要传参进去，我们传了一个'execute'信息进去，首先我们跳过里面的两层嵌套循环来到了print("我现在执行的还是log函数")语句，在要返回decorator函数时我们进入到decorator函数，其中的func参数就是now函数了，这时我们又先跳过了wrapper函数执行了print('我现在执行的是decorator函数')语句，在返回wrapper函数的时候进入到wrapper函数，执行了wrapper函数的print('%s %s():' % (text, func.__name__))语句，并进入func函数，即执行了now函数中的内容，最后层层返回，先返回到decorator函数，再最后退出了log装饰器。

6. 偏函数（Partial function）

6.1 老规矩，偏函数是什么？

• 就是当函数的参数太多的时候，或则我们需要在某些时候经常改变某些参数的时候，我们需要简化，这时候可以使用（functools.partial）创建一个新的函数，这个函数可以固定住原来的参数的部分参数，从而使我们调用的时候更加的简单。

6.2 话不多说，直接上实例

• 例6.2.1：这里以int()函数为例，当我们需要转换大量的二进制字符串时，每次传入int(x, base = 2)非常麻烦，这时可以用下面方法解决。

  #!/user/bin/python
  #coding=utf-8
  
  _author_ = "zjw"
  
  import functools
  
  if __name__ == "__main__":
      int2 = functools.partial(int, base = 2)
      print(int2('101'))
  

• 输出：

  5

• 分析：其中int2 = functools.partial(int, base = 2)语句其实可以用下面的函数代替：

  def int2(x, base = 2):
  	return int(x, base)
  

  两个的实现方式不同，但是能用一行代码解决的我们坚决不用两行。但是呢这只是暂时固定住函数的base参数，如果我们更改base值，调用时也是会发生变化的，如下：

  #!/user/bin/python
  #coding=utf-8
  
  _author_ = "zjw"
  
  import functools
  
  if __name__ == "__main__":
      int2 = functools.partial(int, base = 2)
      print(int2('101', base = 8))
  

  此时输出的是65了，即八进制转为十进制。

6.3 偏函数小总结

• 当函数参数个数太多，我们需要简化是，我们不妨用上偏函数，使用functools.partial来创建一个新的函数，来固定住原函数中的某些参数，实现新的通用的功能。且用该创建方法更加的简洁，实则就是’节约代码行数‘啦。