引言

通过前面的关于Python中进行函数式编程的系列文章的介绍，我们已经把函数式编程范式中的相关特性，以及Python内置的类、functools模块对函数式编程范式的支持，都介绍了一遍。

今天这篇文章，打算介绍一个支持Python更好地进行函数式编程的三方模块：funcy。

本文的主要内容有：

1、funcy模块的简单介绍

2、funcy中的三大件：map、filter和reduce

3、柯里化和偏函数的支持

4、组合函数的支持

5、funcy中的其他特性

funcy模块的简单介绍

funcy模块是一个用于函数式编程的Python三方模块，该模块提供了絮叨简洁且强大的函数和工具，用于简化函数式编程的开发。

funcy模块旨在使Python编程更具有声明性和功能性，进一步减少代码的冗余，同时提高代码的可读性和可维护性。

安装funcy
funcy模块的安装很简单，直接使用pip进行安装即可：

pip install funcy

说明：根据各自不同的环境，可能是pip3，不要机械的复制。

源码地址

https://github.com/Suor/funcy

感兴趣的可以自行查阅。

funcy中的三大件：map、filter和reduce

首先看下定义：

从定义中，我们可以看到，funcy模块中的map和filter是函数，但是函数体实现中，还是使用了Python内置的map和filter类。

不同于functools.reduce，funcy中的规约功能，函数名为reductions()。

下面，我们通过代码进行演示、验证：

import funcy as fn

# 测试funcy模块的map函数
square_nums = fn.map(lambda x: x * x, range(10))
print(square_nums)
# funcy模块的map函数的返回值，确实是内置类map的实例化对象
print(isinstance(square_nums, map))
print(list(square_nums))
print('=' * 40)
# 测试filter
odd_nums = fn.filter(lambda x: x % 2 == 1, range(10))
print(odd_nums)
print(isinstance(odd_nums, filter))
print(list(odd_nums))
print('=' * 40)
# 测试reduce
sum_result = fn.reductions(lambda x, y: x + y, range(10), acc=100)
print(sum_result)
print(sum_result.__next__())
print(sum_result.__next__())
print(sum_result.__next__())
print(fn.last(sum_result))

执行结果：

从定义及代码的验证中，可以得知：

1、funcy模块中的map()函数和filter()函数，本质上都是返回Python内置的map和filter内置类的实例化对象，从而实现map和filter算子的逻辑。

2、需要特别说明的是，funcy模块中的reductions()函数，不同于functools中的reduce()函数，reductions()是延迟计算的逻辑，返回的是一个生成器。

3、funcy模块中提供了快速访问序列、生成器等的实用函数，比如last()可以获取序列或者生成器中的最后一个元素。

柯里化和偏函数的支持

首先看下funcy模块中的curry()的定义：

通过代码验证一下funcy.curry()的使用：

import funcy as fn


# 模拟一个相加的多元函数
def add(x, y, z):
    return x + y + z


# 自定义实现柯里化的方法
def inner_curried_add(x):
    def add_y(y):
        def add_z(z):
            return x + y + z

        return add_z

    return add_y


# 使用funcy实现柯里化

funcy_curried_add = fn.curry(add)
print(funcy_curried_add)
print(add(1, 2, 3))
print('=' * 20)
print(inner_curried_add(1)(2)(3))
print('=' * 20)
print(funcy_curried_add(1)(2)(3))

执行结果：

接下来，再看下funcy模块中的偏函数的功能：

import funcy as fn
import functools


# 模拟一个相加的多元函数
def add(x, y, z):
    return x + y + z


# functools的偏函数功能
functools_add_one = functools.partial(add, 1)
print(functools_add_one)
print(functools_add_one(2, 3))
print('=' * 40)

# funcy的偏函数功能
funcy_add_one = fn.partial(add, 1)
print(funcy_add_one)
print(funcy_add_one(2, 3))

执行结果：

可以看到funcy模块中的偏函数本质上就是functools中的partial类。

从定义中也可以看出：

组合函数的支持

funcy模块中的compose()可以将多个函数组合，从而生成一个新的函数。可以用于进行纯函数的复用、组合，实现对数据的流水线式处理的功能。

从定义中可以看出，compose()函数的功能，是通过叠加map和functools.reduce()来实现的。

接下来，通过实例看下compose()函数的使用：

import funcy as fn

# 实现一个 y = (x + 1) ^ 2的功能
f = fn.compose(lambda x: x ** 2, lambda x: x + 1)

print(f)
print(f(1))
print(f(10))

执行结果：

需要注意的是，最先进行的计算操作写在最后，这个顺序决定了计算的顺序。

funcy中的其他特性

funcy模块的其他特性中，需要特别关注的有两个，一个是关于序列的操作，另一个就是一些好用的装饰器。

首先看序列的操作

funcy模块支持懒序列的操作，可以在需要时生成元素，具有延迟计算的特性，从前面的reductions()函数中可以看到这一点。

通过代码简单演示一下懒序列的使用：

import funcy as fn


# 定义一个斐波那契数列的生成器
def fibonacci():
    a, b = 0, 1
    for i in range(100):
        yield a
        a, b = b, a + b


fib = fibonacci()
# 第一个
print(fn.first(fib))
# 第二个
print(fn.second(fib))
# 第n个
print(fn.nth(50, fib))
# 最后一个
print(fn.last(fib))

执行结果：

还有更多的函数可以使用，感兴趣的同学可以自行尝试。

接下来看几个比较实用的装饰器

1、retry()：重试装饰器

通过代码简单试用一下：

import funcy as fn
import random


@fn.retry(3)
def random_with_fails():
    res = random.random()
    if res > 0.5:
        print(res)
        raise ValueError('Random value too large')
    return res


print(random_with_fails())

可以多运行几次，会发现有时正常返回，有时会抛异常：

2、memoize()：缓存装饰器

直接通过代码演示：

import funcy as fn
import time


@fn.memoize
def add(a, b):
    print('calculating...')
    time.sleep(1)
    return a + b


print(add(10, 20))
print('=' * 40)
print(add(10, 20))
print('=' * 40)
print(add(11, 20))

执行结果：

3、ignore()装饰：忽略指定异常

同样通过代码简单使用一下：

import funcy as fn


@fn.ignore((TypeError, ZeroDivisionError), default='出现异常')
def divide(a, b):
    return a / b


print(divide(10, 20))
print('=' * 40)
# TypeError被忽略，同时返回指定的默认值
print(divide('abc', 20))
print('=' * 40)
# ZeroDivisionError被忽略，同时返回指定的默认值
print(divide(10, 0))

执行结果：

总结

本文简单介绍了Python中的三方模块funcy中的各种特性，主要是在函数式编程中的一些支持，此外，还补充了几个比较实用的装饰器。

感谢您的拨冗阅读，希望对您有所帮助。