Making Your Python Codes More Functional

本篇文章是基于Joel Grus: Learning Data Science Using Functional Python视频的笔记。

常用的函数

currying

在Python中实现科里化的最佳方案是functools.partial。例如以下例子:

# 一般版本
def add1(x): return add(1, x)

# FP的版本
add1_functional = partial(add, 1)

reduce、map、filter

这几个是常见的FP中处理列表的函数,在此不做介绍。

注意:Python这得reducefunctools包中。

iterators(迭代器)

以下是个迭代器的例子:

In [4]: a  = [1,3,4]

In [5]: b = iter(a)

In [6]: next(b)
Out[6]: 1

In [7]: next(b)
Out[7]: 3

In [8]: next(b)
Out[8]: 4

In [9]: next(b)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
 in ()
----> 1 next(b)

StopIteration:

迭代器的特点主要包括:

  1. 一次只用一个

  2. 只有需要时才会产生数据。

这两个特点保证了其惰性的特点,而另一个好处是我们可以构造无穷序列

generator生成器

生成器所要生成的结果其实就是迭代器,如下:

def lazy_integers(n = 0):
    while True:
        yield n
        n += 1

xs = lazy_integers()

[next(xs) for _ in range(10)]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[next(xs) for _ in range(10)]
# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

上面的例子我们可以看出,生成器在此生成了一个无穷长度的序列,由于其惰性我们可以在有限内存之中储存这个无穷序列。
但值得注意的是,因为迭代器中的每个值只能使用一次,就会得到同样语句不同结果的例子(见上)。

一个高阶的用法

squares = (x ** 2 for x in lazy_integers())
doubles = (x * x for x in lazy_integers())

next(squares) #0
next(squares) #1
next(squares) #4

我们发现使用tuple可以直接改变迭代器中的每个元素,这个特性很方便;但值得注意的是,不能写成列表的形式,不然输出值就不为惰性迭代器,就会引起内存外溢。

生成器模拟pipeline

考虑一个文件之中出现某个单词(例如“prime”)的句子个数,采用函数式的方法,显然,如下:

with open("a.txt", "r") as f:
    lines = (line for line in f)
    prime_lines = filter(lambda line: "prime" in line.lower(), lines)
    
    
line_count = len(list(prime_lines))

itertools模块

itertools模块提供了大量用于操作迭代器的函数。

函数名 参数 作用
count [start=0], [step=1] 输出无穷序列(start, start + step, start + 2 * step...)
islice seq, [start=0], stop, [step=1] 输出序列的切片
tee it, [n=2] 复制序列,输出为多个相同序列组成的元组
repeat elem, [n=forever] 重复序列n次,输出为一个repeat元素
cycle p 无限重复cycle里的元素
chain p, q, ... 迭代p里的元素,然后再迭代q的元素,...
accumulate p, [func=add] 返回(p[0], func(p[0], p[1]), func(func(p[0], p[1]), p[2])...)

自定义一些常用的迭代工具

def take(n, it):
    """
    将前n个元素固定转为列表
    """
    return [x for x in islice(it, n)]
    
    
def drop(n, it):
    """
    剔除前n个元素
    """
    return islice(it, n, None)
    

# 获取序列的头
head = next

# 获取除第一个元素外的尾
tail = partial(drop, 1) 

此外,很常见的另一个函数是获得一个递推的迭代器函数,即已知x, f,获得(x, f(x), f(f(x)),...)

def iterate(f, x):
    yield x
    yield from iterate(f, f(x))

注意,要防止mutation,就是说到底复制的是指针还是指针代表的数,显然下面的写法是有问题的:

def iterate(f, x):
    while True:
        yield x
        x = f(x)

一个简单的避免方法是:

def iterate(f, x):
    return accumulate(repeat(x), lambda fx, _:f(fx))

使iterate

def lazy_integers():
    return iterate(add1, 0)

take(10, lazy_integers())

一个例子:斐波那契数列

基本写法

def fib(n):
    if n == 0: return 1
    if n == 1: return 1
    return fib(n - 1) + fib(n - 2)


[fib(i) for i in range(10)]

升级写法——mutable but functional

def fibs():
    a, b = 0, 1
    while True:
        yield b
        a, b = b, a + b
        
take(10, fibs())

Haskell-Like 写法

def fibs():
    yield 1
    yield 1
    yield from map(add, fibs(), tail(fibs()))

take(10, fibs())

尾递归的haskell-like版本

def fibs():
    yield 1
    yield 1
    fibs1, fibs2 = tee(fibs())
    yield from map(add, fibs1, tail(fibs2))

你可能感兴趣的:(python,data-science,函数式编程)