Python：高阶函数、返回函数、匿名函数、装饰器及偏函数

函数式编程

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

高阶函数

①变量可指向函数

f = abs
f(-10)

#结果为10

②函数的参数可传入函数

def add(x, y, f):
    return f(x) + f(y)
print(add(-5, 6, abs))

#结果为11。

③map()函数：map()函数接收两个参数，一个是函数，一个是Iterable（Iterator是惰性序列），map()将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
例如把发f(x)=x^2和str作用在list的[1,2,3,4,5,6,7,8,9]上：

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]

list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
#结果为['1', '2', '3', '4', '5', '6', '7', '8', '9']

④reduce()：把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

from functools import reduce

def add(x, y):
	return x + y
	
reduce(add, [1, 3, 5, 7, 9])
#结果为25

def fn(x, y):
	return x * 10 + y
def char2num(s):
	digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
	return digits[s]
	
reduce(fn, map(char2num, '13579'))
#结果为13579

⑤filter()：把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素(True丢弃）。

def is_odd(n):
    return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

#结果为[1, 5, 9, 15]

def not_empty(s):
    return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))

# 结果: ['A', 'B', 'C']

⑥sorted()：将list的内容进行排序，key()决定安排依据。
key的解释是这样的：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

sorted([36, 5, -12, 9, -21])#从小到大
#结果为[-21, -12, 5, 9, 36]

sorted([36, 5, -12, 9, -21], key=abs)#按绝对大小排序
#结果为[5, 9, -12, -21, 36]

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)#按小写（大写）排序
#结果为['about', 'bob', 'Credit', 'Zoo']

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)#反向排序
#结果为['Zoo', 'Credit', 'bob', 'about']

返回函数

①函数作为返回值

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9)
f()
#结果为25

函数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。

都返回9的原因：每次count赋值都不计算i*i，而i的最终值为3存在fs中，调用时才用i计算。

③返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
“闭包”的最大的作用——保存局部信息不被销毁。会一直保留上一次调用函数后外部函数的局部变量值

def count():
    def f(j):
        def g():
            return j*j
        return g
fs = []
for i in range(1, 4):
	fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
    
f1, f2, f3 = count()
f1()
#结果为1 4 9

python自增算法：a = a+1或a+=1

匿名函数

匿名函数不需要定义函数名，直接使用。

list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))#将列表组元带入匿名函数中返回x*x的结果
#结果为[1, 4, 9, 16, 25, 36, 49, 64, 81]
#效果同：
def f(x):
    return x * x
list(map(f,[......])

装饰器

装饰器：不希望修改某个函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

偏函数

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

import functools

int2 = functools.partial(int, base=2)
int2('1000000')
#结果为64

#效果同：
def int2(x, base=2):
    return int(x, base)
int2('1000000')
#结果为64