高阶函数

主要包括：

定义函数的本质
传入函数
返回函数
变量作用域

高阶函数：函数的参数或函数的返回值是函数的函数。

这是一种代码复用的手段。

def handle (func,*param):
    return func(*param)

def my_sum(*param):
    '''
    累加
    '''
    sum = 0
    for v in range(len(param)):
        sum += param[v]
    return sum

def my_mul(*param):
    '''
    累乘
    '''
    mul = 1
    for v in param:
        mul *= v
    return mul    


print(handle(my_sum,1,2,3,4))
print(handle(my_mul,1,2,3,4))

10
24

变量可以指向函数

以求相反数的函数 my_abs() 为例，调用该函数用以下代码：

def my_abs(a):
    b = -a
    return b

my_abs(-10)

但是如果只写 abs 呢？

my_abs

从上面的例子可见：my_abs(-10) 是函数调用，而 my_abs 是函数对象。

为了获得函数调用结果，我们可以把结果赋值给变量: x = my_abs(-10) 但是，如果把函数本身赋值给了变量呢？

def my_abs(a):
    b = -a
    return b

f = my_abs
f

内存图

从上面的内存图中可以看出有一个全局变量 f 指向了函数对象 my_abs(),另外因为我们是在全局作用域下定义的函数，所以有一个全局变量 my_abs 指向了函数对象 my_abs()。

结论：函数本身也可以赋值给变量，也就是说：变量可以指向函数。

如果一个变量指向了一个函数，那么，可否通过该变量来调用这个函数？

f = abs
f(-10)

变量 f 现在已经指向了 abs 函数本身。直接调用abs() 函数和调用变量f() 完全相同。

函数名也是变量

从上面的分析我们也可以看出来了：函数名其实就是指向函数的变量！对于 my_abs()这个函数，完全可以把函数名 my_abs 看成变量，它指向一个可以计算相反数的函数！

如果把abs指向其他对象，会有什么情况发生？

abs = 10
abs(-10)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      1 abs = 10
----> 2 abs(-10)


TypeError: 'int' object is not callable

把 abs 指向 10 后，就无法通过 abs(-10) 调用该函数了！因为 abs 这个变量已经不指向求绝对值函数而是指向一个整数 10！

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复 abs 函数，请重启 Python 交互环境。

注：由于 abs 函数实际上是定义在 import builtins 模块中的，所以要让修改 abs 变量的指向在其它模块也生效，要用 import builtins; builtins.abs = 10。

其实这也是为什么在取变量名的时候不能取关键字的原因。

传入函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个最简单的高阶函数：

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

add(abs, -5, 6)

返回函数

返回函数比较麻烦，单独写了一篇博客，详见：https://www.jianshu.com/p/52a3ef7ec300

接下来我们看看高阶函数变量的作用域：

变量的作用域

首先先给出结论：

内层函数可以访问外层变量的值，但是不能修改，
内层函数访问变量时，会先从自己查找，如果找不到层层向上查找
python中变量的作用域是以函数为单位的，
global 修饰变量时，说明使用的是函数外的全局变量
nonloca 修饰变量时说明使用的是嵌套层函数的变量

我们先来看一个简单的高阶函数的例子，利用这个例子验证上述结果：

def outer():
    def inner():
        print("hello inner")
    print("hello outer")
    return inner

fo = outer()

hello outer

在上面的程序中 outer 函数中定义了一个函数 inner 并打印hello outer，如果我们调用 fo 就会执行函数 inner.

我们添加几个变量试试：

def outter():
    a = 10
    
    def inner():
        a = 20
        print('inner:',a)
        print("hello inner")
        
    print('outter:',a)
    return inner

fo = outter()

outter: 10

fo()

inner: 20
hello inner

outter()

outter: 10





.inner()>

从上面的例子中就可以看出外层函数的变量与内层函数变量互相不影响。两个a分别处于不同的作用域中。

那如果我们想在内层函数中修改外层函数变量怎么办呢？

如果变量定义在函数外，在函数中使用 global 关键字声明使用的是外部变量

如果变量定义在外部函数中，在内层函数中使用 nonlocal 关键字声明使用的是外层函数的变量

a = 10
def outter():
    #a = 10
    
    def inner():
        global a  # 说明使用的是外部变量
        a  = a - 1
        print('inner:',a)
        print("hello inner")
    print('outter:',a)
    return inner

fo = outter()
fo()
fo()
fo()
fo()

outter: 10
inner: 9
hello inner
inner: 8
hello inner
inner: 7
hello inner
inner: 6
hello inner

def outter():
    a = 10
    def inner():
        nonlocal a  # 说明使用的是外部变量
        a  = a - 1
        print('inner:',a)
        print("hello inner")
    print('outter:',a)
    return inner

fo = outter()
fo()
fo()
fo()

outter: 10
inner: 9
hello inner
inner: 8
hello inner
inner: 7
hello inner

我们再来看看内层函数能否访问外层的a：（不是修改哦）

a = 10
def outter():
    #a = 10
    
    def inner():
        #a = 20
        print('inner:',a)
        print("hello inner")
        
    print('outter:',a)
    return inner

fo = outter()
fo()

outter: 10
inner: 10
hello inner

也可以访问外层函数的变量：

def outter():
    a = 10
    
    def inner():
        #a = 20
        print('inner:',a)
        print("hello inner")
        
    print('outter:',a)
    return inner

fo = outter()
fo()

outter: 10
inner: 10
hello inner

如果内层函数中没有变量python的查找顺序是怎样的呢？

def f():
    a = 10
    def g():
        # a = 20
        def h():
            # a = 30
            print(a)
        h()
    g()
    
f()

这可以看出内层函数访问变量时，会先从自己查找，如果找不到层层向上查找