【Python初学】高阶函数的使用

前言：初学高阶函数，没有深入的了解函数的具体运行方法，暂时归纳。

目录

1.高阶函数的概念 

2.常用的内置高阶函数

2.1 map()

2.2 reduce()

2.3 filter() 

2.4 sorted()

3.decorator装饰器

4.偏函数 

---

 

---

1.高阶函数的概念 

要理解高阶函数，必须先理解两个概念：

1. 变量可以指向函数
2. 函数名其实就是指向函数的变量

f = abs
print f(-5)
#输出为5

abs = len
print abs[-10]
#报错，int没有len()函数
print abs(['a', 'b'])
#输出为2

高阶函数就是可以使用函数作为参数的函数，如下所示：

def abs_add(x, y, f):
    return f(x) + f(y)
print abs_add(-5, 9, abs)
#结果为14

2.常用的内置高阶函数

Python中常用的高阶函数有map()、reduce()、filter()等，下面初步介绍一下用法及注意事项

2.1 map()

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

def format_name(s):
    return s[0:1].upper() + s[1:].lower(); 
print map(format_name, ['adam', 'LISA', 'barT'])
#输出结果为['Adam', 'Lisa', 'Bart']

注意：map()函数不改变原有的 list，而是返回一个新的 list。

2.2 reduce()

reduce()同map()类似，也接受一个函数 f 和一个 list ，不同在于reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

def prod(x, y):
    return x * y
print reduce(prod, [2, 4, 5, 7, 12])
#运行结果为3360
#2*4*5*7*12

#reduce()还可以接收第3个可选参数，作为计算的初始值。
print reduce(prod, [2, 4, 5, 7, 12], 100)
#运行结果为336000
#100*2*4*5*7*12

2.3 filter() 

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

import math

def is_sqr(x):
    return x and math.sqrt(x)%1 == 0
#在return语句中，if语句通常可以使用and来代替，因为和运算符一个为否均为否
print filter(is_sqr, range(1, 101))
#输出结果为[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2.4 sorted()

sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0

def cmp_ignore_case(s1, s2):
    if s1.lower() < s2.lower():
        return -1
    if s1.lower() > s2.lower():
        return 1
    return 0

print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

3.decorator装饰器

在了解decorator装饰器之前我们需要了解两个概念：

1.返回函数：顾名思义，函数可以被函数返回

def calc_prod(lst):
    def prod( x, y ):
        return x * y
    def g():
        return reduce(prod, lst)
    return g
#返回g函数，可以起到“延迟计算”的作用，只有在调用的时候才会计算
f = calc_prod([1, 2, 3, 4])
print f()
#此时才计算，输出24

2.闭包：

内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。如要使用，看以下代码：

def count():
    fs = []
    for i in range(1, 4):
        def f(temp):
            def g():
                return temp * temp
            return g
        r = f(i)
        fs.append(r)
    return fs
#如果没有f()函数，计算的时候只会计算i=3的情况，因为此时for会执行到i=3
f1, f2, f3 = count()
print f1(), f2(), f3()
#输出结果为1,4,9

 

 decorator装饰器主要是用于增强函数的功能，避免给每个函数额外编写重复代码，比如给函数增加日志、检测性能等，为了简化装饰器的调用，python通常使用@

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

import time

def performance(f):
    def fn(x):
        print 'call '+ f.__name__ + '() in ' , time.localtime(time.time());
        return f(x)
    return fn
#这样就给原函数f增加了一个打印日志和时间的功能
#这是不带参数的decorator
@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
#@performance就相当于 factorial = performance(factorial)
print factorial(10)
#带参数的decorator相比于不带参数的需要额外增加一些代码

def performance(unit):
    def performance_decorator(f):
        def wrapper(*args, **kw):
            print 'call '+ f.__name__ + '()' + unit , time.localtime(time.time()) 
            return f(*args, **kw)
        return wrapper
    return performance_decorator
#这样就可以为decorator传入一些参数
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial(10)

注：@decorator可以动态实现函数功能的增加，但是，经过@decorator“改造”后的函数，和原函数相比，除了功能多一点外，有没有其它不同的地方？

其实@decorator是创建了一个新的函数，函数名、__doc__等函数的属性都已经改变，我们可以使用Python内置的functools来把原函数的一些属性复制到新函数中

import time, functools

def performance(unit):
    def perf_decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kw):
            print "call " + f.__name__ + '()'
            return f(*args, **kw)
        return wrapper
    return perf_decorator
#@functool.wraps(f)可以将函数f的属性赋值给wrapper函数
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

print factorial.__name__
#输出的结果为factorial，如果不增加@functool.wraps(f)，输出结果为wrapper

 

4.偏函数 

import functools

sorted_ignore_case = functools.partial(sorted, cmp=lambda s1, s2: cmp(s1.upper(), s2.upper()))
#利用functools.partial()可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，有点类似于偏导数，一个不变，只考虑另一个参数，在这里，不变的参数需要指定
print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])
#输出结果为['about', 'bob', 'Credit', 'Zoo']