1. 什么是高阶函数
高阶函数就是传入的参数或者输出的结果中有一个为函数的函数。
或者说：
如果函数传入的参数中，或者输出的结果（函数只有一个结果）中有任意一个为函数，那么这个原函数就是高阶函数。
def counter(base):
def inc(step=1):
base += step
return base
return inc
- 函数counter是不是一个高阶函数？
函数counter是一个高阶函数，因为return中的inc是一个函数。
- 上面代码有没有问题？如何改进。
base += step 将会改变变量base的值，base是上层函数的变量。
改进：可以使用nonlocal关键字。产生UnboundLocalError错误。
- 如何调用完成计算功能？
foo = counter(11)
- 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
11
看完还是很懵逼，，在“装饰器”里继续说说吧。。
更多欢迎访问：http://www.mykernel.cn/
网友评论