Python函数式编程

[toc]

什么是函数式编程?

函数式编程是一种抽象程度很高的编程范式,纯粹的函数式编程语言编写的函数没有变量,因此,任意一个函数,只要输入是确定的,输出就是确定的,这种纯函数我们称之为没有副作用。

而允许使用变量的程序设计语言,由于函数内部的变量状态不确定,同样的输入,可能得到不同的输出,因此,这种函数是有副作用的

函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数!

Python对函数式编程提供部分支持。由于Python允许使用变量,因此,Python不是纯函数式编程语言

高阶函数

Python中函数两个特性

变量可以指向函数

函数本身可以赋值给变量,通过变量可以调用函数

>>> f = abs
>>> f(-10)
10

函数名是变量

把函数名看作变量,可将其指向其他对象,则无法调用原函数

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

传入函数

由于变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数

一个最简单的高阶函数:

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

当调用add(-5, -6, abs)时,函数计算abs(-5)+abs(-6),返回11

把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式


Python内建高阶函数

map()函数

|map() 函数接收两个参数,一个是函数,一个是Iterablemap将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回

image

def f(x):
	return x * x
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce()函数

|reduce 把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:

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

filter()函数

该函用于过滤序列。

|filter() 接收一个函数和一个序列,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还时False决定保留还是丢弃该元素。

例如,删掉list中的偶数,保留奇数

def is_odd(n):
	return n % 2 == 1
>>> list(filter(is_odd, [1, 2, 3, 4, 5]))
[1, 3, 5]

用filter求素数

利用埃氏筛法

  • 先构造一个从3开始的奇数序列

利用生成器

def _odd_iter():
	n = 1
	while 1:
		n += 2
		yield n
  • 定义一个筛选函数
def _not_divisible(n):
	return lambda x: x % n > 0
  • 最后定义一个生成器,不断返回下一素数
def primes():
	yield 2
	it = _odd_iter()
	while 1:
		n = next(it)
		yield n
		it = filter(_not_divisible(n), it)
  • 调用得到1000内素数
for n in primes():
	if (n < 1000):
		print(n)
	else:
		break

|filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算,所以只有在取filter()结果的时候,才会真正筛选并每次返回下一个筛出的元素。

sorted()函数

它可以接收一个key函数来实现自定义的排序,例如按绝对值大小排序:

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

key指定的函数将作用于list的每一个元素上,并根据key函数返回的结果进行排序。 然后sorted()函数按照keys进行排序,并按照对应关系返回list相应的元素

返回函数&闭包

函数作为返回值

def lazy_f(x, y):
	def f():
		return x + y
	return f1	#返回函数
>>> f1 = lazy_f(1, 2) 
>>> f2 = lazy_f(1, 2)
>>> f1 == f2
False	#两次返回的函数并不同
>>> f1() #调用函数时,才真正计算求和结果
3
>>> f2()
3

闭包

lazy_f返回函数f时,相关参数和变量都保存在返回的函数中,这种称为“闭包(Closure)”的程序结构拥有极大的威力。

需要注意的是,返回的函数并没有立刻执行,而是直到调用了f()才执行 如

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()

在实际调用中

>>> f1()
9
>>> f2()
9
>>> f3()
9

注意:返回函数不要引用任何循环变量,或者后续会发生变化的变量

匿名函数

如匿名函数lambda x: x * x

关键字lambda表示匿名函数,冒号前面的x表示函数参数。

匿名函数只能有一个表达式,不写return,返回值就是该表达式的结果

Python对匿名函数的支持有限,只有一些简单的情况下可以使用匿名函数。

装饰器

函数对像有一个__name__属性,可以返回函数的名字

>>> now.__name__
'now'

现在,假设我们要增强now()函数的功能,比如,在函数调用前后自动打印日志,但又不希望修改now()函数的定义,这种在代码运行期间动态增加功能的方式,称之为“装饰器(Decorator)”。

定义一个能打印日志的decorator

def log(func):
	def wrapper(*args, **kw):	#*args是非关键字参数,用于元组,**kw是关键字参数,用于字典
		print('class %s():' % func.__name__)
		return func(*args, **kw)
	return wrapper

借助Python的@语法,把decorator置于函数的定义处:

@log
def now():
	print('2019/6/21')

调用函数now(),不仅会运行now()本身,还会在其之前打印一行日志

>>> now()
call now():
2019/6/21

相当于执行了语句:

now = log(now)

如果decorator本身需要传入参数,那就需要编写一个返回decorator的高阶函数,写出来会更复杂。比如,要自定义log的文本:

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('2019/6/21')
#相当于now = log('excute')(now)

以上两种decorator的定义都没有问题,但还差最后一步。因为我们讲了函数也是对象,它有__name__等属性,但你去看经过decorator装饰之后的函数,它们的__name__已经从原来的'now'变成了'wrapper'

>>> now.__name__
'wrapper'

因为返回的那个wrapper()函数名字就是'wrapper',所以,需要把原始函数的__name__等属性复制到wrapper()函数中,否则,有些依赖函数签名的代码执行就会出错。

不需要编写wrapper.__name__ = func.__name__这样的代码,Python内置的functools.wraps就是干这个事的,所以,一个完整的decorator的写法如下:

import functools

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

或者针对带参数的decorator:

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

偏函数

可借助functools.partial创建偏函数:把一个函数的某些参数设为某个默认值,返回一个新的函数,调用这个新函数会更简单

>>> int2 = functools.partial(int, base = 2)
>>> int2('10000')
16

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

Licensed under CC BY-NC-SA 4.0
comments powered by Disqus
蜀ICP备19030250号
Built with Hugo
Theme Stack designed by Jimmy