python之高阶函数

1. 什么是高阶函数

高阶函数就是传入的参数或者输出的结果中有一个为函数的函数。
或者说:
如果函数传入的参数中,或者输出的结果(函数只有一个结果)中有任意一个为函数,那么这个原函数就是高阶函数。

1
2
3
4
5
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不一样。

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

1
2
3
4
5
6
7
8
9
def counter1(base=20):
def inc(step=10):
nonlocal base
#print(base)
#print(step)
base += step
#print(base)
return base #将base的值再次作为count1的参数传入
return inc
1
foo = counter1()
1
2
3
foo()  #此处传入的值是内层inc的参数。。虽然不知道为啥,但就是这样表现的。
# 20 是内层函数counter1的参数默认值,
# 10 是外层函数inc的参数默认值
30
1
2
# 测试下给foo = counter1() 赋值  
foo = counter1(40)
1
foo()  #说明此处赋值是给外层函数counter1的参数赋值,内层函数inc的默认值无变化
50
1
2
# 测试下给foo() 赋值  
foo = counter1()
1
foo(25)  #说明此处赋值是给内层函数inc的参数赋值,外层函数counter1的默认值无变化
45

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

1
2
3
4
5
6
7
8
9
10
11
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)
1
foo(25) #第一次运行
35
1
foo(25) #第二次运行
60

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

2. 实现sort函数的功能

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

1. 实现排序功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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. 实现参数控制排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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]

特别说明:

1
2
3
4
5
6
7
8
9
10
11
12
#其中
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
#等效写法

控制符号的部分提取出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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函数的参数位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#引入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)的形式。

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

add(1,2)
3
1
2
3
4
5
6
def add(x):
def _add(y):
return x + y
return _add

add(5)(6) #5是传入到x 6传入到y
11

看完还是很懵逼,,在“装饰器”里继续说说吧。。

---------------- 谢谢光临 ----------------

本文标题:python之高阶函数

文章作者:pxrux

发布时间:2020年09月25日 - 11:09

最后更新:2020年09月30日 - 14:09

原始链接:http://www.mykernel.cn/python-function-2.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

0%