Python学习笔记-函数式编程

还没有到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

你可能需要魔法上网~~