Python学习笔记：Python函数式编程

Python学习笔记：Python函数式编程

学自廖雪峰巨佬的Python3教程：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317848428125ae6aa24068b4c50a7e71501ab275d52000

1.我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。而函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

2.高阶函数

• map()和reduce()

map()接收两个参数，一个是函数，一个是Iterable对象，map将传入的函数依次作用到Iterable对象里的每个元素，并把结果作为新的Iterator返回

>>> 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]

由于结果r是一个Iterator，因此需要通过list()函数将整个序列都计算出来并返回一个list()

reduce()把一个函数作用在一个一个序列上，这个函数必须接收两个参数，reduce把结果和序列的下一个元素做累积计算

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

还可以通过reduce函数写出一个str2int的函数

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))

 

代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


def normalize(name):
    return str.upper(str.lower(name)[:1]) + str.lower(name)[1:len(str.lower(name))]


# 测试:
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import reduce


def prod(L):
    def fn(x, y):
        return x * y

    return reduce(fn, L)


# 测试
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
    print('测试成功!')
else:
    print('测试失败!')

 代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import reduce


def str2float(s):
    def char2num(s):
        digit = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        return digit[s]

    def fn(x, y):
        return x * 10 + y

    s1 = s[:s.index('.')]
    s2 = s[s.index('.') + 1:]

    return reduce(fn, map(char2num, s1)) + reduce(fn, map(char2num, s2)) / pow(10, len(s2))


# 测试
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
    print('测试成功!')
else:
    print('测试失败!')

• filter

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

比如只保留序列里的奇数

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

用filter求素数，使用筛法

首先构造一个从3开始的奇数序列，这是一个生成器，并且是一个无限序列：

def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

 然后定义一个筛选函数，这里使用了lambda表达式，构建了一个闭包：

def _not_divisible(n):
    return lambda x: x % n > 0

最后定义一个生成器，不断返回下一个素数：

def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列

 调用primes()生成器，并且设置退出循环的条件：

# 打印1000以内的素数:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


def is_palindrome(n):
    count = 0
    i = 0

    if 0 < n < 9:
        return True
    else:
        while i < len(str(n)) // 2:
            if str(n)[i] == str(n)[len(str(n)) - 1 - i]:
                count += 1
            i += 1

    return count == len(str(n)) // 2


# 测试:
output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))
if list(filter(is_palindrome, range(1, 200))) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101,
                                                  111, 121, 131, 141, 151, 161, 171, 181, 191]:
    print('测试成功!')
else:
    print('测试失败!')

• sorted

Python内置的sorted()函数用于对list进行排序，默认顺序从小到大，还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

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

key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

对字符串排序则是按照ASCII的大小比较的，如果要实现反向排序，则可以传入第三个参数reverse=True

代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]


def by_name(t):
    return t[0]


L2 = sorted(L, key=by_name)
print(L2)


def by_score(t):
    return -t[1]


L2 = sorted(L, key=by_score)
print(L2)

3.返回函数

• 函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

实现一个可变参数的求和很简单，但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算呢？答案就是可以不反悔求和的结果，而是返回求和的函数：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

 当调用lazy_sum()的时候，返回的并不是求和结果，而是求和函数，调用函数f的时候，才真正计算求和的结果：

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

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种程序结构称为闭包。

再注意一点，每次调用lazy_sum()时，都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的调用结果互不影响 

• 闭包（我可以吐槽一下这个东西真的很毒吗）

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

f1, f2, f3 = count()

在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。你可能认为调用f1(),f2(),f3()结果应该是1，4，9，但实际结果是：

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

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行，等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9

返回闭包时牢记一点：返回函数不要引用循环变量，或者后续会发生变化的变量。

代码如下：（这里引用大佬代码= =因为我闭包学的还不够好呜呜）

方法1：使用list在函数内部引用其地址，并改变其值

def createCounter():
    a = [0]
    def counter():
        a[0] += 1
        return a[0]
    return counter

执行分析：

调用createCounter，实例化counterA对象，给a赋初值[0]，给counterA的返回值是counter()函数；
print语句内调用counterA，开始执行函数counter()，a[0]+=1->a[0]=1，返回a[0]的值给counter()，然后再返回给counterA()，
循环5次这个过程。

方法2：利用生成器，完成数值加1

def createCounter():
    def counter():
        n = 1
        while True:
            yield n
            n += 1
    c = counter()  
    def g():
        return next(c)
    return g

执行分析：

调用createCounter，实例化counterA对象，内部调用counter()并实例化c对象，返回值为函数g；

print语句内调用CounterA，获取返回值为函数g，调用函数g，获取返回值为next(c)，调用函数counter()，生成器返回值1，n+=1，循环5次这个过程。

理解容易实现难啊！

4.匿名函数

当传入函数时，有些时候，不需要显式的定义函数，直接传入匿名函数更方便。

以map()函数为例，计算f(x)=x^2，关键字lambda表示匿名函数，冒号前的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。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


# def is_odd(n):
#    return n % 2 == 1


# L = list(filter(is_odd, range(1, 20)))

L = list(filter(lambda x: x % 2 != 0, range(1, 20)))

print(L)

5.装饰器

由于函数也是一个对象，而且函数对象可以被复制给变量，所以通过变量也能调用该函数。
函数对象有一个__name__属性，可以拿到函数的名字：

>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
>>> now.__name__
'now'
>>> f.__name__
'now'

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

本质上，decorator就是一个返回函数的高阶函数，所以定义一个打印日志的装饰器如下：

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

然后将修饰器置于函数的定义前

@log
def now():
    print('2015-3-25')

相当于执行了语句

now = log(now)

调用now()函数时，相当于现在指向了新的函数，即在log()函数中返回的wrapper()函数，wrapper()函数的参数定义是(*args,**kw)，因此，wrapper()函数可以接受任意参数的调用，在wrapper函数内，首先打印日志，再紧接着在return处调用原始函数。

如果修饰器本身需要传入参数，那就需要编写一个返回修饰器的高阶函数。比如要自定义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('2015-3-25')

>>> now()
execute now():
2015-3-25

>>>print(now.__name__)
wrapper

首先执行now函数的时候，就会先执行log('execute')，传入参数为text='execute'，返回的是decorator函数，再调用返回的decorator函数，返回的是wrapper函数，再调用返回的wrapper函数，打印传入的text和函数名，然后调用now函数本身，输出日期。

但是看经过decorator装饰之后的函数，它的__name__已经从原来的now变成了wrapper，因为返回的那个wrapper()函数名字就是wrapper，所以需要把原始函数的__name__等属性复制到wrapper()函数中，否则有些依赖函数签名的代码执行就会出错。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

带参数的

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

def metric(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kw):
        t1 = time.time()
        fx = fn(*args, **kw)
        t2 = time.time()
        print('%s executed in %s ms' % (fn.__name__, t2 - t1))
        return fx

    return wrapper

代码如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


def begin_call(func):
    def wrapper(*args, **kw):
        print("begin")
        x = func(*args, **kw)
        print("end")

    return wrapper

def log(func):
    def wrapper(*args,**kw):
        print("xxxxxxxxxx")
        return func(*args,**kw)
    return wrapper


def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print(text)
            return func(*args, **kw)
        return wrapper
    return decorator


@log('love')
def one_plus(x):
    print(x + 1)


one_plus(1)

6.偏函数

Python的偏函数和数学意义上的不一样，在介绍函数参数的时候，通过设定参数的默认值，可以降低函数调用的难度，而偏函数也可以做到这一点。

假设要转换大量的二进制字符串，每次都传入Int(x,base=2)非常麻烦，因此可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):
    return int(x, base)

而使用functools.partial就是帮助我们创建偏函数的，不需要自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

创建出来的偏函数也是可以传入其他值的