12. 函数式编程

た入场券 2024-04-17 23:14 59阅读 0赞

`函数式编程`就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量。对于任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此这种函数是有副作用的。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。Python对函数式编程提供部分支持，由于Python允许使用变量，因此Python不是纯函数式编程语言。

--------------------

### 匿名函数 ###

顾名思义，匿名函数就是不需要显式地定义函数名的函数，通过关键字`lambda`定义。`lambda`后面跟的只能是表达式，不能是赋值语句或代码块。

lambda parameter_list: expression

匿名函数有个限制，就是只能有一个表达式，不用写`return`，返回值就是该表达式的结果。

匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

*  示例：

def add(x, y):
        return x + y
    
    print(add(2, 3))
    
    f = lambda x,y:x+y               #匿名函数赋值给变量f
    print(f(2, 3))
    
    5               #结果
    5

可以看到，两次结果一致，使用匿名函数更为简洁。

--------------------

### 三元表达式 ###

其他语言的三元表达式：

判断的条件 ? 条件为真时的结果 : 条件为假时的结果
    
    比如：x > y ? x : y

python的三元表达式：

条件为真时的结果 if 判段的条件 else 条件为假时的结果
    
    比如：x if x > y else y

三元表达式通常跟lambda匿名函数合在一起使用。

*  示例：

x,y = 2,1
    
    r = x if x > y else y
    print(r)
    
    f = lambda x,y:x*y if x > y else x**y 
    print(f(4,2))
    
    2               #结果
    8

--------------------

### 高阶函数 ###

Python中，可以接收另一个函数作为参数的函数称为高阶函数。常用的高阶函数有`map()`、`reduce()`和`filter()`。

--------------------

#### map ####

`map()`会根据提供的函数对指定迭代器对象的每个元素做映射，映射规则由指定的函数决定，返回一个map对象。

第一个参数function以参数迭代器对象中的每一个元素调用function函数，返回包含每次function函数返回值的map对象。

map(func, *iterables)

*  示例：

l = [1, 2, 3, 4, 5, 6]
    
    def squa(x):
        return x * x
    
    r = map(squa, l)
    print(list(r))
    
    [1, 4, 9, 16, 25, 36]               #结果

`map()`通常与`lambda`匿名函数一起使用，比上面更简洁。

*  示例：

l = [1, 2, 3, 4, 5, 6]
    
    r = map(lambda x:x*x, l)
    print(list(r))
    
    [1, 4, 9, 16, 25, 36]               #结果

l1 = [1, 2, 3, 4, 5, 6]
    l2 = [1, 2, 3, 4, 5, 6, 7, 8]
    r = map(lambda x,y:x*x+y, l1, l2)
    print(list(r))
    
    [2, 6, 12, 20, 30, 42]              #结果

`map()`允许传入多个迭代器对象，迭代器的数量与lambda传入的变量数量一致。当最短的迭代器耗尽时停止。

--------------------

#### reduce ####

`reduce()`函数会对参数序列中元素进行累积，累积规则由指定的函数决定。

`reduce()`函数将一个序列中的所有数据进行下列操作：用传给reduce中的函数function（必须有两个参数）先对集合中的第1、2个元素进行操作，得到的值再与第三个元素用function函数运算，依次类推，最后得到一个值。

reduce(function, sequence[, initial])

`reduce()`函数通常也与`lambda`匿名函数一起使用，此时lambda匿名函数必须要有两个参数。

*  示例：

from functools import reduce
    
    l = [1, 2, 3, 4, 5, 6]
    
    sum = reduce(lambda x,y:x+y , l)
    red = reduce(lambda x,y:x-y , l, 10)
    print(sum)
    print(red)
    
    21              #结果
    -11

累积规则由指定的函数决定。当指定了初始值后，初始值作为第一个元素，与序列中第一个元素开始按函数规则运算。

--------------------

#### filter ####

`filter()`函数用于过滤序列，过滤掉不符合条件的元素，返回一个由符合条件元素组成的filter对象。

filter(function or None, iterable)

`filter()`函数接收两个参数，第一个为函数，第二个为迭代器对象，迭代器的每个元素作为参数传递给函数进行判断，然后返回True或False，最后将返回True的元素放到filter对象中。

`filter()`函数通常也与`lambda`匿名函数一起使用。

*  示例：

from random import randint
    
    l = [randint(-10, 10) for _ in range(10)]
    
    r = filter(lambda x: x >= 0, l)
    print(list(r))
    
    [6, 7, 1, 4, 9, 3]              #结果

map、reduce、filter及lambda是函数式编程不可或缺的组成部分；与之对应的函数（def）、判断（if else）、循环（for、while）是命令式编程不可或缺的组成部分。

Lisp是函数式编程的鼻祖，而Python只是部分支持函数式编程。

--------------------

### 装饰器 ###

编写代码有个**开闭原则**：对修改是封闭的，对扩展是开放的。

Python的装饰器decorator本质上是一个高阶函数，它接收一个函数作为参数，然后返回一个新的函数，可以让该函数在不改动源代码的情况下增加其他新功能。

Python通过一个语法糖`@`符号来使用decorator，这样可以避免编写`f = decorate(f)`这样形式的代码。所谓的语法糖便是你不使用也可以完成任务,但是使用它可以让你的代码更简洁。

对于装饰器，需要记住的就是

@decorate
    def f():
        pass

其中，

@decorate   等价于  f = decorate(f)

*  示例：

import time
    
    def decorator(func):
        def wrapper():
            print(time.time())              #unix时间戳
            func()
        return wrapper
    
    def f1():
        print('This is a function.')
    
    f1 = decorator(f1)              #decorator()函数对 f1()函数装饰
    f1()
    
    1566442483.4864995              #结果
    This is a function.

import time
    
    def decorator(func):
        def wrapper():
            print(time.time())
            func()
        return wrapper
    
    @decorator
    def f1():
        print('This is a function.')
    
    # f1 = decorator(f1)
    f1()
    
    1566442745.7653272              #结果
    This is a function.

从上面两个例子中可以看出，`@decorator 等价于 f1 = decorator(f1)`，即`decorator()`函数对`f1()`函数进行装饰。

装饰器应具有通用性，即可以对多个函数进行装饰，所以装饰器函数的内部函数（上面例子中的wrapper()函数）的参数应该是可变参数`*args, **kw`。这样不管被装饰函数的参数是什么、有多少个，装饰器都可对其进行装饰。

--------------------

#### 无参数decorator ####

*  示例：

import time
    
    def performance(f):
        def fn(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            print 'call %s() in %f s' % (f.__name__, t2 - t1)
            return r
        return fn
    
    @performance
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    
    print factorial(10)
    
    call factorial() in 0.002750 s              #结果
    3628800

`@performance`可以打印出`factorial()`函数调用的时间。

利用python的`*args`和`**kw`，可以让`@performance`自适应任何参数定义的函数，保证任意个数的参数总是能正常调用。

**`@performance` 完全等价于 `factorial = performance(factorial)`**。

对于`performance()`函数，形成一个闭包。程序首先调用`performance(factorial)`，得到的返回结果赋值给了`factorial`，这样`factorial`就变成了指向函数`fn()`的指针，经过装饰后的`factorial()`，其实是调用`fn()`。

--------------------

#### 带参数decorator ####

*  示例：

import time
    
    def performance(unit):
        def perf_decorator(f):
            def wrapper(*args, **kw):
                t1 = time.time()
                r = f(*args, **kw)
                t2 = time.time()
                t = (t2 - t1) * 1000 if unit =='ms' else (t2 - t1)
                print 'call %s() in %f %s' %(f.__name__, t, unit)
                return r
            return wrapper
        return perf_decorator
        
    @performance('ms')
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    
    print factorial(10)
    
    call factorial() in 2.448082 ms             #结果
    3628800

**`@performance('ms')` 完全等价于 `factorial = performance('ms')(factorial)`**。

而`factorial = performance('ms')(factorial)`展开一下就是：

perf_decorator = performance('ms')
    
    factorial = perf_decorator(factorial)

即

perf_decorator = performance('ms')
    
    @perf_decorator
    def factorial():
        pass

所以，带参数的`performance()`函数首先返回一个`decorator`函数，再让这个`decorator`函数接收`factorial`并返回新函数。

对于`performance()`函数，形成一个闭包；对于`perf_decorator()`函数，也形成一个闭包。程序首先调用`performance('ms')`，返回`perf_decorator`，再将`perf_decorator(factorial)`得到的返回结果赋值给了`factorial`，这样`factorial`就变成了指向函数`wrapper()`的指针，经过装饰后的`factorial()`，其实是调用`wrapper()`。

--------------------

#### 装饰器应用 ####

例如，在flask中的装饰器的应用：

@api.route('/get', methods=['GET'])
    def test_javascript_http():
        p = request.args.get('name')
        return p, 200
        
    @api.route('/psw', methods=['GET'])
    @auth.login_required
    def get_psw():
        p = request.args.get('psw')
        r = generate_password_hash(p)
        return 'aaaaaa', 200

**装饰器在不改变原先的函数代码的情况下，给原先的函数添加额外的功能**，这是装饰器的原则。

--------------------