Python学习第四部分 函数式编程

函数式编程主要学习：高阶函数、闭包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=3
    
    def inner():
        print("inner")
        nonlocal a # 闭包是由于函数内部使用了函数外部的变量，这个函数对象不销毁，则外部函数的局部变量也不会被销毁
        print(f"a:{a}")
   
    return inner

a = outer()
 
print("---------")
a()

outer

---

inner
a:3

闭包的作用：
隐藏变量，避免全局污染；可以读取函数内部的变量；
但是：闭包使用不当，导致变量不会被垃圾回收机制回收，造成内存消耗；也可能造成内存泄露的问题。

示例 使用全局变量实现变量自增，但是污染了其他程序

a = 10 
def add():
    global a
    a += 1
    print("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=10
    a += 1
    print("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=10
    def incrment():
        nonlocal a
        a += 1
        print("a:",a)
    return incrment

def 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 infuc

def 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 reduce

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

m=[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==1

L=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 -1
    if st1.age>st2.age:
        return 1
    return 0

st1=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