Python学习笔记-函数式编程

发表于 | 分类于 | 热度 | 字数统计 3,545

还没有到IO啊…..什么时候才能写的出爬虫….
不过还是希望能够比较系统的进行学习….继续吧，这次是函数式编程

简介

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

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
函数式编程也可以归结到面向过程的程序设计。

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

高阶函数

什么是高阶函数呢，比如举几个栗子：

  • 变量可以指向函数
    这点类似js，比如abs()这个函数，abs是函数本身，加括号就是调用

    1
    2
    3
    >>> f = abs
    >>> f(-10)
    10

  • 函数名也是变量
    还是用abs这个栗子，abs就是一个变量，你甚至可以给他赋值，他只是保存了计算绝对值这个函数的引用，也就是说他指向具体实现的地方
    注：由于abs函数实际上是定义在import builtins模块中的

  • 传入函数
    既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

  • 返回函数
    有时候我们并不需要立即执行函数，可以传入需要的参数然后让其返回一个函数，需要执行的时候再执行，后面会有详细介绍

1
2
def add(x, y, f):
    return f(x) + f(y)

f应该传入一个函数，比如abs()

map和reduce

Python内建了map()和reduce()函数。
先来看第一个map函数：它接收两个参数，一个是函数，一个是Iterable(可迭代对象)，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator(迭代器)返回。

1
2
3
# 将list转换成字符串
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：reduce(f, [x1, x2, x3, x4])等价于f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用reduce实现：

1
2
3
4
5
6
>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。

filter函数

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是：
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
比如过滤空字符的：

1
2
3
4
def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))

注意到filter()函数返回的是一个迭代器，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

sorted排序函数

它接受一个list对其进行排序，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序

1
2
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

key函数作用于每一项，并根据key函数返回的结果进行排序。
如果需要反向排序可以传入第三个参数reverse=True

返回函数

这部分刚开始简单的一些还好，后面的高级应用感觉是比较难的(比如..装饰器的时候)，一个简单的例子说明一切：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
>>> f1()
25
>>> f1 == f2
False

可以看出内部函数sum可以引用外部函数的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。每次调用都互不影响，比如上面f1和f2是不同的

闭包

想要返回函数时，内部函数还能引用外部函数的变量实现起来是不容易的
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量
返回的所有函数会引用变量最后的值
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

1
2
3
4
5
6
7
8
9
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

匿名函数

关键字lambda表示匿名函数，比如：lambda x: x * x冒号前面的x表示函数参数，写成一般的函数就是：

1
2
3
4
5
def f(x):
    return x * x
# 一个例子
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

匿名函数有个限制，就是只能有一个表达式，当然return也是不可以用的，同时你也可以把匿名函数赋给一个变量，可以通过这个变量来进行调用，或者用于返回函数

装饰器

函数对象有一个__name__属性，可以拿到函数的名字，比如

1
2
>>> str.__name__
'str'

至于什么是装饰器，比如我们定义了个函数，后来写某个功能的时候又想在原来的基础上增加一些功能，我们最好还是不要在原来的函数上进行改动，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数，它接受一个函数，经过装饰后，返回一个新函数
比如写一个在执行函数前先打印下函数名的装饰器：

1
2
3
4
5
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

装饰器写好了然后就是使用了，我们要借助Python的@语法，把decorator置于函数的定义处

1
2
3
4
5
6
7
@log
def now():
    print('2015-3-25')
# 调用now函数时，除了执行其本身还打印了其函数名
>>> now()
call now():
2015-3-25

其实把@log放到now()函数的定义处，相当于执行了语句:now = log(now)
但是原来的now函数还是存在的，只不过新的now指向了由装饰器构造的函数wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，需要三层嵌套

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

#使用
@log('execute')
def now():
    print('2015-3-25')
  
# 执行
>>> now()
execute now():
2015-3-25

如果把@语法还原就是这样：now = log('execute')(now)
到这里还有最后一个问题，前面我们说了装饰后的函数它指向了新的函数，也就是wrapper函数，我们并没有修改它的__name__ ，它有自己的name等属性，如果去看经过decorator装饰之后的函数，它们的name已经从原来的’now’变成了’wrapper’
想要解决这个问题不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import functools #导入模块

def log(func):
    # 注意写在函数的上面
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

# 或者那个三层嵌套的
import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。

decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。

偏函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。
在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。
functools.partial就是用来帮助我们创建一个偏函数的，它的作用就是：把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
比如设置一个新函数来用于2进制的转换

1
2
3
4
5
6
7
8
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000') # == int('1000000',base=2)
64

# 其实它只是设置了一个默认值，也可以这样调用
>>> int2('1000000', base=10)
1000000

创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，上面的新函数每次调用的时候都传了一个默认的参数就是

1
2
3
4
5
6
7
8
9
10
kw = { 'base': 2 }
int('10010', **kw)

# 如果是
max2 = functools.partial(max, 10)
# 实际上会把10作为*args的一部分自动加到左边
max2(5, 6, 7)
#等价于
args = (10, 5, 6, 7)
max(*args)

所以：当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

模块

模块和java中的分类、分包基本一致，不过Py有个很大的特点是：
每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是顶层目录的名。
模块的使用
以内建的sys模块为例，编写一个hello的模块：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '

__author__ = 'Michael Liao'

import sys

def test():
    args = sys.argv
    if len(args)==1:
            print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':
    test()

第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；
第六行就是声明下作者
当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。

作用域

在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的
类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，注意是不能直接被引用而不是不能被使用，不过我们一般是不会去引用的

第三方模块安装

在Python中，安装第三方模块，是通过包管理工具pip完成的。
比如：pip install Pillow

当我们试图加载一个模块时，Python会在指定的路径下搜索对应的.py文件，如果找不到，就会报错，默认情况下Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中

临时追加：
>>> import sys
>>> sys.path.append('/Users/michael/my_py_scripts')
永久追加：
设置环境变量PYTHONPATH，Python自己本身的搜索路径不受影响。

喜欢就请我吃包辣条吧！

评论框加载失败，无法访问 Disqus

你可能需要魔法上网~~