函数式编程¶

函数作为参数¶

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

add(-1, 1, abs)

2

map¶

map()作为高阶函数，它将运算规则抽象了。

r = map(lambda x: x*x, [1, 2, 3, 4])
list(r)

[1, 4, 9, 16]

reduce¶

from functools import reduce
def prod(List,f):
    return reduce(f, List)
def f(x, y):
    return x * y
prod([1,2,3], f)

6

str2int¶

from functools import reduce
num = {}
for i in range(10):
    num[str(i)] = i
    
def str2int(string:str) -> int:
    return reduce(lambda x, y: x*10 + y, map(char2num, string))
def char2num(s):
    return num[s]

str2int(‘123‘)

123

type(str2int(‘123‘))

int

str2float¶

from functools import reduce
num = {}
for i in range(10):
    num[str(i)] = i

def char2num(s):
    return num[s]
def str2float(string):
    s = string.split(‘.‘)
    f1 = lambda x, y: x * 10 + y
    f2 = lambda x, y: x * 0.1 + y
    return reduce(f1, map(char2num, s[0])) + 0.1 * reduce(f2, map(char2num, s[-1][::-1]))

str2float(‘1.234‘)

1.234

type(str2float(‘1.234‘))

float

filter¶

利用filter() 求素数(埃氏筛法)

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

def prime():
    yield 2
    it = odd_iter()
    while True:
        n = next(it)
        yield n
        it = filter(lambda x: x % n > 0, it)

for i in prime():
    if i < 20:
        print(i, end=‘ ‘)
    else:
        break

2 3 5 7 9 11 13 15 17 19

返回函数¶

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

f = lazy_sum(1, 2, 3)
f

<function __main__.lazy_sum.<locals>.sum>

f()

6

我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

闭包¶

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

f1, f2, f3 = count()

f1(), f2(), f3()

(9, 9, 9)

注：闭包返回的函数并没有立刻执行，而是直到调用了f()才执行。

<font color = red>返回函数不要包含任何循环变量，或者后续会发生变化的变量。</font>

如果一定要引入循环变量呢？方法是在 count() 中调用 f(),从而绑定循环变量当前值。

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

f1, f2, f3 = count()

f1(), f2(), f3()

(1, 4, 9)

example¶

def creat_counter():
    def g():
        n = 1
        while True:
            yield n
            n += 1
    it = g()
    def counter():
        return next(it)
    return counter

counterA = creat_counter()

counterA()

1

counterA()

2

注：creat_counter() 作为一个计数器函数。

转换简单的类为闭包¶

class sample:
    def __init__(self,value):
        self.value = value
    def func(self):
        print(‘n = ‘, self.value)
    def get_value(self):
        return self.value
    def set_value(self,new_value):
        self.value = new_value

test = sample(1)
test.func()

n =  1

def sample(n):
    value = n
    def func():
        print(‘n = ‘, value)
    def get_value():
        return value
    def set_value(new_value):
        nonlocal value
        value = new_value
    
    func.get_value = get_value
    func.set_value = set_value
    return func

test = sample(1)

test()

n =  1

test.get_value()

1

test.set_value(5)
test()

n =  5

注：将 get_value() 和 set_value() 作为函数 func()的属性，然后利用闭包返回 func() 函数

参考：访问闭包中定义的变量，里面有进一步内容。

装饰器¶

def now():
    print(‘2018/2/20‘)

now.__name__

‘now‘

现在希望增加 now() 函数的功能，但不改变他的定义，这种在代码运行期间动态增加功能的方式，称之为装饰器（Decorator）。

本质上，decorator 就是一个返回函数的高阶函数。下面，我们定义一个打印日志的 decorator。

def log(func):
    print(‘call {}‘.format(func.__name__))

log(now)

call now

但是这样就显式调用了 log()，说白了是两个函数

def log(func):
    def wrapper(*args, **kw):
        print(‘call {}‘.format(func.__name__))
        return func(*args, **kw)
    return wrapper

now = log(now)

now()

call now
2018/2/20

以上就实现了打印日志的 now() 函数,同时会调用 now() 函数实现功能。

@log
def now():
    print(‘2018/2/20‘)

now()

call now
2018/2/20

注：@log 相当于执行语句：

now = log(now)

log()就是一个 decorator，它返回 wrapper() 函数，执行 @log 后，wrapper 赋值给 now，再次执行 now() 后，我们会执行 wrapper() 函数，打印日志，然后执行原来的 now() 函数。

下面进一步。自定义日志内容

大致思想是下面两条语句：

now = log(‘text‘)(now)

now()

写一个3层嵌套的 decorator：log(‘text‘) 返回一个函数，返回相当于上一个例子的 log() 函数。

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print(‘{0}{1}():‘.format(text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

def now():
    print(‘2018/2/20‘)
now = log(‘execute‘)(now)
now()

execute now():
2018/2/20

用法如下：

@log(‘execute‘)
def now():
    print(‘2018/2/20‘)
now()

execute now():
2018/2/20

但是有一个问题：

now.__name__

‘wrapper‘

由于最后返回的是 wrapper 函数，因此 now 的 __name__ 属性就是 ‘wrapper‘。

完整代码：

例一：

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print(‘call {}‘.format(func.__name__))
        return func(*args, **kw)
    return wrapper

@log
def now():
    print(‘2018/2/20‘)

now()

call now
2018/2/20

now.__name__

‘now‘

例二：

import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print(‘{0}{1}():‘.format(text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log(‘execute‘)
def now():
    print(‘2018/2/20‘)

now()

execute now():
2018/2/20

now.__name__

‘now‘

最后，写一个打印函数执行时间的decorator

import time, functools
def meric(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        start = time.time()
        result = func(*args, **kw)
        end = time.time()
        print(‘{} executed in {} ms‘.format(func.__name__, end - start))
        return result
    return wrapper

@meric
def test(x, y):
    time.sleep(0.1)
    return x + y

test(1,2)

test executed in 0.10009908676147461 ms

3

zxzhu 2018/2/20

Reference:

廖雪峰Python3教程

Python3 Cookbook 中文版

Python3 函数式编程（高阶函数）