【Python】初学自用笔记第七篇函数式编程

令夏二十三

已于 2023-07-10 21:00:25 修改

阅读量85

点赞数

分类专栏： # Python 文章标签： python Powered by 金山文档

于 2023-02-17 18:23:49 首次发布

本文链接：https://blog.csdn.net/Summerison/article/details/129091794

版权

Python 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

函数式编程的抽象度很高，接近于真正意义上的数学计算，而非简单的计算机操作，其显著特点是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。

高阶函数

在python里，变量可以指向函数，也就是可以给函数起别名，将别名用到函数调用中可以正常使用；

因此，函数名也是变量；

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数称为高阶函数。例如：

f=abs
def add(x,y,f):
    return f(x)+f(y)
a=123
b=-321
print(add(a,b,f))
'''
444
'''

map/reduce

map()函数

map()函数接收两个参数，一个是函数，另一个是Iterable（集合数据类型和生成器）

map将传入的函数依次作用到序列的每个元素，把结果作为新的Iterator返回

例如，将平方函数作用在一个list上：

def f(x):
    return x*x
r=map(f,[1,2,3,4,5,6,7,8,9])
print(list(r))#r是Iterator，作为惰性序列，需要通过list()函数将它们都计算出来
'''
[1, 4, 9, 16, 25, 36, 49, 64, 81]
'''

再如，第一个参数设置为一个内置函数str，将整型转化为字符型：

print(list(map(str,[1,2,3,4,5,6,7,8,9])))
'''
['1', '2', '3', '4', '5', '6', '7', '8', '9']
'''

reduce()函数

reduce把一个函数作用在一个序列[a,b,c,d,e]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做计算，效果如下：

reduce ( f , [ a ,b , c , d , e ]) = f ( f ( f ( f ( a , b ) , c ) , d ) , e )

序列求和

对序列[1,3,5,7,9]求和：

from functools import reduce
def add(x,y):
    return x+y
print(reduce(add,[1,3,5,7,9]))
'''
25
'''

将字符转化为整数 str2int

给定字符'13579'，要求将其转化为整数13579。

from functools import reduce
def fn(x,y):
    return x*10+y
def char2num(s):
    digits={'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
    return digits[s]
print(reduce(fn,map(char2num,'13579')))

将上面的过程整理成函数：

from functools import reduce
DIGITS={'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
def str2int(s):
    def fn(x,y):
        return x*10+y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn,map(char2num,s))

filter

filter()函数用于过滤序列；

filter()函数也接收一个函数和一个序列，它把传入的函数依次作用于序列中的每一个元素，若返回值为True，则保留该元素；若返回值为False,则丢弃该元素。

保留序列中的奇数

def is_odd(n):
    return n%2==1
print(list(filter(is_odd,[1,2,4,6,8,34,56,67,88,99])))
'''
[1, 67, 99]
'''

删除序列中的空白字符

list1=['q','',' ','   ','ASD','123']
def not_empty(s):
    return s and s.strip()#and语句中，有假返回第一个假值，全真则返回最后一个值，直接返回s会出错，所有使用s.strip()来返回
print(list(filter(not_empty,list1)))

sorted

sorted()函数可以对list进行由小到大的排序：

print(sorted([36,5,-12,9,-21]))
'''
[-21,-12,5,9,36]
'''

sorted作为高阶函数，还可以接收一个赋值给key的函数来实现自定义排序，如按绝对值大小排序：

print(sorted([36,5,-12,9,-21],key=abs))
'''
[5,9,-12,-21,36]
'''

在sorted的参数中增加一句 reverse=True，则从大到小排序：

print(sorted([1,2,3,-11,-22,33],key=abs,reverse=True))
'''
[33, -22, -11, 3, 2, 1]
'''

返回函数

函数作为返回值

def lazy_sum(*args):
    def sum():#定义一个求和函数，它没有参数，但可以使用外部函数的参数
        ax=0
        for n in args:
            ax=ax+n
        return ax
    return sum#将求和函数作为返回值，返回给外层的函数
f=lazy_sum(1,3,5,7,9)#先将带参数的函数赋值给f
print(f())#调用f()时，才计算出结果，再返回
f1=lazy_sum(1,3,5,7,9)#注意函数f和f1是不同的两个函数

在上面的例子中，我们在函数lazy_sum中又定义了没有参数的函数sum，并且内部函数可以引用外部函数的参数和局部变量，当外部函数将内部函数作为返回值返回时，相关的参数和变量都保存在返回的函数中，没有进行计算，这种程序结构称为闭包 Clousure.

闭包

通过闭包返回的函数没有立即执行，而是直到调用了f()才执行：

def count():
    fs=[]
    for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
    return fs
f1,f2,f3=count()#每次循环都会创建一个新函数，但是循环了三次之后i才不变，所以最后i=3，接下来的三个函数值都为9
print(f1())
print(f2())
print(f3())
‘’‘
9
9
9
’‘’

由上可知，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

若一定要用到循环变量，那就在外面再套一个函数：

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs=[]
    for i in range(1,4):
        fs.append(f(i))#f(i)立刻被执行，，因此i的当前值被传入f()
    return fs
f1,f2,f3=count()
print(f1())
print(f2())
print(f3())
'''
1
4
9
'''

若在闭包的内部函数里，要改变其引用的外部参数或局部变量的值，需先声明该变量不是当前函数的局部变量，使用nonlocal来声明：

def inc():
    x=0
    def fn():
        nonlocal x
        x=x+1
        return x
    return fn
f=inc()
print(f())
print(f())
'''
1
2
'''

匿名函数

在传入函数时，也可以不显式地定义函数，直接传入匿名函数。

匿名函数的关键字是lambda，其后跟着函数参数和冒号：

print(list(map(lambda x:x*x,[1,2,3,4,5,6,7,8,9]))
'''
[1,4,9,16,25,36,49,64,81]
'''

实际上，该匿名函数就是：

def f(x):
    return x*x

匿名函数没有return语句，而且也只能写一个表达式。

装饰器

函数可以赋值给变量，通过__name__属性（前后各两个下划线），可以返回函数的原名：

def f():
    print('Hello World!')
a=f
print(a())
print(a.__name__)
'''
Hello World!
f
'''

若要增强函数功能，比如在函数调用前自动打印函数名称，但又不修改函数定义，这种在代码运行期间动态增加功能的方式，称为装饰器 decorator 。

装饰器实质上是一个返回函数的高阶函数，下面是一个能打印日志的decorator的定义：

def log(func):#定义一个装饰器
    def wrapper(*args,**kw):#用了可变参数和关键字参数，因此这个函数可以接收所有参数
        print('call %s():'%func.__name__)#先打印日志
        return func(*args,**kw)#再调用原始函数
    return wrapper
@log#使用python的@语法，把decorator置于函数的定义处，相当于执行了语句：now=log(now)
def now():
    print('2023-2-18')
print(now())
'''
call now():
2023-2-18
'''

若装饰器本身需要传入参数，就需要写一个返回decorator的高阶函数，比如要自定义log的文本：

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)#因为返回给装饰器的函数是wrapper，而这样就改变了原函数，所以需要先声明一下
        def wrapper(*args,**kw):
            print('%s %s():'%(text,func.__name__))
            return func(*args,**kw)
        return wrapper
    return decorator
@log('execute')
def now():
    print('2023-2-18')
print(now())
'''
execute now():
2023-2-18
'''

偏函数

偏函数是functool模块里的功能，可以帮助固定原函数的一些参数，返回一个新函数，调用新函数来进行某些操作会比较简单。

import functools
int2=functools.partial(int,base=2)#int是强制转化为整型的函数，将其转化进制参数固定为2，即可将字符由字面上的二进制数转化为十进制数
print(int2('100000'))
'''
32
'''