文章目录
- 高阶函数
- lambda 表达式和匿名函数
- 偏函数
- 闭包
- map函数
- reduce函数
- filter 函数
- sorted函数
函数式编程主要学习:高阶函数、闭包closure、匿名函数、偏函数,map函数、reduce函数、filter函数、sorted函数
函数式编程是个很古老的概念,最古老的函数式编程语言Lisp,新出现的函数式编程语言比如Erlang,Scala,clojure等,热门语言Python、java、JavaScript、C++等增加了函数式编程的一些特性。
函数式编程在有些时候非常方便。
高阶函数
函数是一等公民,可以赋值、可以作为参数传递、可以作为返回值。一个函数可以接收另一个函数作为参数,就称之为高阶函数。 python内建的高阶函数有map reduce filter sorted
def test():print("test function run!!")def test2(func,*args,**kwargs):print("test2 function run...")func(*args,**kwargs)def test03(a,b):print(f"test03,{a},{b}")a = test
#test2(a)
test2(test03,100,200)
test2 function run…
test03,100,200
lambda 表达式和匿名函数
lambda表达式可以用来声明匿名函数,只允许包含一个表达式,不能包含复杂语句。语法如下:
lambda arg1,arg2,arg3,...:<表达式>
arg1,arg2,arg3为函数的参数,表达式相当于函数体。
f= lambda a,b,c:a+b+c
print(f)
f(10+20,20,30)
f(10,20,30)
偏函数
Python的functools
模块提供了很多有用的功能,其中一个就是偏函数(Partialfunction)。要注意,这里的偏函数和数学意义的偏函数不一样。
偏函数:作用就是把一个函数某些参数固定住(也就是设置默认值),返回一个新的函数,调用这个新的函数会更简单。
举例如下: int()
函数可以把字符串转换为整数,当仅传入字符串时,int0函数默认按十进制转换,代码如下:
print(int('12345'))
但int()
函数还提供额外的base参数,默认值为10。如果阐述base参数,就可以做N进制转换。
print("转换为八进制: ",int('12345',base=8))
print("转换为十六进制:",int('12345',base=16))
print("转换为十进制:",int('12345',base=10))
转换为八进制: 5349
转换为十六进制: 74565
转换为十进制: 12345
可以利用functools.partial
创建偏函数
import functools
int2=functools.partial(int,base=2)print(int2('1010101'))
print(int2('1010101',base=10))
85
1010101
闭包
闭包的两部分,函数本身、外部函数的局部变量
根据字面意思,可以形象地把闭包理解为一个封闭的包裹,这个包裹就是一个函数。当然,还有函数内部对应的逻辑,包裹里面的东西就是自由变量(外部函数的局部变量),自由变量可以随着包裹到处游荡。
局部变量:如果名称绑定再一个代码块中,则为该代码块的局部变量,除非声明为`nonlocal或global`
全局变量:如果模块绑定在模块层级,则为全局变量
自由变量:如果变量在一个代码块中被使用但不是在其中定义,则为自由变量
闭包概念和第一个闭包程序
我们知道,函数作用域是独立的、封闭的,外部的执行环境是访问不了的,但是闭包具有这个能力和权限。
闭包是一个函数,只不过这个函数有超能力,可以访问到另一个函数的作用域。
闭包的特点:存在内外层函数嵌套的情况;内层函数应用了外层函数的变量或参数(自由变量);外层函数把内层的这个函数本身当做返回值进行返回。
def outer():print("outer")a=3def inner():print("inner")nonlocal a # 闭包是由于函数内部使用了函数外部的变量,这个函数对象不销毁,则外部函数的局部变量也不会被销毁print(f"a:{a}")return innera = outer()print("---------")
a()
outer
inner
a:3
闭包的作用:
隐藏变量,避免全局污染;可以读取函数内部的变量;
但是:闭包使用不当,导致变量不会被垃圾回收机制回收,造成内存消耗;也可能造成内存泄露的问题。
示例 使用全局变量实现变量自增,但是污染了其他程序
a = 10
def add():global aa += 1print("a:",a)def print_ten():if a == 10 :print("ten!!")else:print("全局变量a,不等于10")
add()
add()
add()
add()
print_ten()
a: 11
a: 12
a: 13
a: 14
全局变量a,不等于10
示例 未污染,但是未实现自增
a = 10
def add():a=10a += 1print("a:",a)def print_ten():if a == 10 :print("ten!!")else:print("全局变量a,不等于10")
add()
add()
add()
add()
print_ten()
a: 11
a: 11
a: 11
a: 11
ten!!
通过自由变量,实现递增,也不污染其他程序
a = 10
def add():a=10def incrment():nonlocal aa += 1print("a:",a)return incrmentdef print_ten():if a == 10 :print("ten!!")else:print("全局变量a,不等于10")
incrment=add()
incrment()
incrment()
incrment()
print_ten()
a: 11
a: 12
a: 13
ten!!
案例 用闭包实现不修改源码添加功能
def outfunc(func):def infuc():print("日志记录...")func()return infucdef fun1():print("使用功能1")def fun2():print("使用功能2")fun1=outfunc(fun1)
fun1()fun2=outfunc(fun2)
fun2()
map函数
map()
函数接收两组参数,一个是函数,一个是序列(可以传入多个序列),map
将传入的函数依次作用到序列的每个元素,并把结果作为新的list返回
。
比如我们有一个函数f(x)=x2
,要把这个函数作用在一个list [1,2,3,4,5,6,7,8,9]
上,就可以用map()
实现如下:
# 自己编写实现
def f(x):return x*x
L=[]
for i in [1,2,3,4,5,6,7,8,9]:L.append(f(i))
print(L)# map实现
L=map(lambda x:x*x,[1,2,3,4,5,6,7,8,9])
print(list(L))
# 或者
L=map(f,[1,2,3,4,5,6,7,8,9])
print(list(L))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
reduce函数
reduce位于 functools
模块
reduce把一个函数作用在一个序L[x1, x2,x3...]
上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
reduce(f,[x1,x2,x3,x4])= f(f(f(x1,x2),x3),x4)
示例:
from functools import reducedef add(x,y):return x+ym=[1,2,3,4,5,6,7,8,9,10]
print(reduce(add, m)) ## 结果是55
filter 函数
内置函数flter()
用于过滤序列。filter()
把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。true 保留,false 丢弃
def is_odd(n):return n%2==1L=filter(is_odd,[1,2,3,4,5,6])
print(list(L)) ## 结果是 [1, 3, 5]
sorted函数
排序算法,排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。
如果是数字,我们可以直接比较
如果是自定义对象呢?直接比较数学上的大小是没有意义的,因此,比较的过程必须通过函数抽象出来。通常规定,对于两个元素x和y,如果认为x<y,则返回-1,如果认为x== y,则返回0,如果认为x> y,则返回1,这样,排序算法就不用关心具体的比较过程,而是根据比较结果直接排序。
示例 sorted
对list进行排序
sorter1 = sorted([1,2,3,-1,-20,34])
print(sorter1 ) # 升序排序
sorted函数也是个高阶函数,还可以接收一个key
实现自定义排序
示例 自定义排序
sorter1 = sorted([1,2,3,-1,-20,34])
print(sorter1 ) # 升序排序sorter2 = sorted([1,2,3,-1,-20,34],key=abs)
print(sorter2 ) # 绝对值排序sorter3 = sorted([1,2,3,-1,-20,34],key=abs,reverse=True) #绝对值排序,反序
print(sorter3 )
[-20, -1, 1, 2, 3, 34]
[1, -1, 2, 3, -20, 34]
[34, -20, 3, 2, 1, -1]
def custom_sorted(st1,st2):if st1.age<st2.age:return -1if st1.age>st2.age:return 1return 0st1=Stutent(13,'zhangsan')
st2=Stutent(14,'lisi')
st3=Stutent(15,'wangwu')
st4=Stutent(12,'zhaoliu') stdent_list=sorted([st1,st2,st3,st4],key=cmp_to_key(custom_sorted)) for stu in stdent_list:print(stu.name,stu.age)
zhaoliu 12
zhangsan 13
lisi 14
wangwu 15