python之高阶函数

1. 什么是高阶函数

高阶函数就是传入的参数或者输出的结果中有一个为函数的函数。 或者说： 如果函数传入的参数中，或者输出的结果（函数只有一个结果）中有任意一个为函数，那么这个原函数就是高阶函数。

def counter(base):
    def inc(step=1):
        base += step
        return base
    return inc

1. 函数counter是不是一个高阶函数？

   函数counter是一个高阶函数，因为return中的inc是一个函数。

2. 上面代码有没有问题？如何改进。

   base += step 将会改变变量base的值，base是上层函数的变量。 改进：可以使用nonlocal关键字。产生UnboundLocalError错误。

3. 如何调用完成计算功能？

   foo = counter(11)

4. f1 = counter(5)和f2 =counter(5),f1和f2 是否相等？为什么。

   f1 == f2 is false 两者id不一样。

理解不了代码，只能测试一下了。。但是为啥会出现这样的情况呢？

def counter1(base=20):
    def inc(step=10):
        nonlocal base 
        #print(base)
        #print(step)
        base += step
        #print(base)
        return base  #将base的值再次作为count1的参数传入
    return inc

foo = counter1()

foo()  #此处传入的值是内层inc的参数。。虽然不知道为啥，但就是这样表现的。
# 20 是内层函数counter1的参数默认值，
# 10 是外层函数inc的参数默认值
30

# 测试下给foo = counter1（） 赋值  
foo = counter1(40)

foo()  #说明此处赋值是给外层函数counter1的参数赋值，内层函数inc的默认值无变化
50

# 测试下给foo() 赋值  
foo = counter1()

foo(25)  #说明此处赋值是给内层函数inc的参数赋值，外层函数counter1的默认值无变化
45

参数传入的问题解决了，但是为什么一直运行foo(25)，值会一直变化呢？

def coun(base=20):
    def inc(step=10):
        nonlocal base 
        #print(base)
        #print(step)
        base += step
        #print(base)
        return base  #将base的值再次作为count1的参数传入
    return inc 
​
foo = coun(10)

foo(25) #第一次运行
35

foo(25) #第二次运行
60

因为nonlocal关键字将base的变量拿到内层函数inc的内部，然后base += step 将base的值改变了。因为coun函数未结束，所以变量改变的值会一直替换原来的值。 最终这样就实现按照步长（step）一直累加的功能。step = 1 就是简单的计数功能。 由于博客的格式问题，把代码中的#去掉，就可以很明显的看到效果了。

2. 实现sort函数的功能

sort将原来的函数进行排序，输出一个新的列表，可以控制正序还是逆序。 思路： 1，两个列表一个原列表（需要进行排序的列表），一个新列表（输出的列表）； 2，依次取出原列表的数字，和新列表的数字进行比较，比较大的放在前面（实现了逆序，从大到小排列）； 3，第一次输出的列表没有值，需要在原列表中取一个直接放入。

1. 实现排序功能

oldlst = [1,4,5,21,4,22,23,-11]
​
def sort(lst):
    newlst = []
    for x in oldlst:  #取出x
        for i,y in enumerate(newlst): #取出y和y的索引
            if x>y: #如果x>y
                newlst.insert(i,x) #在列表lst1的索引i位置插入x的值
                break
        else:
            newlst.append(x)
    return newlst
  
    
print(sort(oldlst))
​
#此处的初始列表为oldlst = [1,4,5,2]
#第一次循环，x=1 newlst=[1] 
#第二次循环，x=4 y = 1 y的索引为0 x>y 将x的值放在索引为0的位置  newlst = [4,1]
#第三次循环，x=5 y1= 4 y1的索引为0  y2 = 1 y2的索引为1 5>4 将x的值放在索引0的位置上 newlst = [5,4,1]
#第四次循环，x=2 y1 = 5 y2 = 4 y3 =1 ==> 2<5 ,2< 4 2>1 将x的值放在索引为2的位置上 newlst = [5,4,2,1]
#返回newlst = [5,4,2,1]
[23, 22, 21, 5, 4, 4, 1, -11]

2. 实现参数控制排序

lst = [1,4,5,2]
​
def sort(lst,reverse=False):
    lst1 = []
    for x in lst:  
        for i,y in enumerate(lst1): 
            #if reverse:   # reverse 为false 时候 x< y 实现逆序
            #    a= x < y
            #else:
            #    a = x > y  #reverse 为true 时候 x> y 实现正序
            a = x>y if reverse else x<y #等效写法
            
            if a: #如果x>y
                lst1.insert(i,x) 
                break
        else:
            lst1.append(x)
    return lst1
    
print(sort([1,4,5,2]))
[1, 2, 4, 5]

特别说明：

#其中
if reverse:   # reverse 为false 时候 x< y 实现逆序
    a= x < y
else:
    a = x > y  #reverse 为true 时候 x> y 实现正序
​
#等效于
​
a = x>y if reverse else x<y
​
#可以理解为 a = x>y 但是当reverse的值为false时候 a = x < y 
#等效写法

控制符号的部分提取出来

def compare(a,b,reverse=False):
    return a>b if reverse else a<b 
​
 
lst = [1,4,5,2]
​
def sort(lst):
    lst1 = []
    for x in lst:  
        for i,y in enumerate(lst1): 
            
            if compare(x,y): #把x y的值传入到外部函数，得到一个x>y的结果，再进行后续处理。
                
                lst1.insert(i,x) 
                break
        else:
            lst1.append(x)
    return lst1
    
print(sort([1,4,5,2]))
[1, 2, 4, 5]

3. 把compare函数放在sort函数的参数位置

#引入lambda函数
def sort(lst,compare=lambda a,b : a>b):  #高阶函数
    lst1 = []
    for x in lst:  
        for i,y in enumerate(lst1): 
            
            if compare(x,y): #把x y的值传入到外部函数，得到一个x>y的结果，再进行后续处理。
                
                lst1.insert(i,x) 
                break
                
        else:
            lst1.append(x)
    return lst1
    
print(sort([1,4,5,2]))
[5, 4, 2, 1]

3. 柯里化

柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。 z = f(x,y) 转换为z=f(x)(y)的形式。

def  add(x,y):
    return x + y
​
add(1,2)
3

def add(x):
    def _add(y):
        return x + y 
    return _add 
​
add(5)(6) #5是传入到x  6传入到y