Python3学习笔记之-函数式编程（第一篇）

最新推荐文章于 2022-09-07 21:05:19 发布

是小先生

最新推荐文章于 2022-09-07 21:05:19 发布

阅读量160

点赞数

分类专栏： python学习笔记文章标签： python

本文链接：https://blog.csdn.net/weixin_45895096/article/details/119167959

版权

python学习笔记专栏收录该内容

33 篇文章 1 订阅

订阅专栏

Python3学习笔记之-函数式编程（第一篇）

文章目录

Python3学习笔记之-函数式编程（第一篇）

一、高阶函数

前言

函数是Python内建支持的一种封装，就是把大量的代码拆开写成函数，然后进行调用，这种分解可以称为面向过程的程序设计，函数就是面向过程的程序设计的基本单元。

在计算机层面上，cpu执行的是加减乘除以及各种判断和跳转的指令，因此汇编语言最贴近计算机语言。越贴近计算机的语言，抽象程度就低，执行效率就高，比如C语言。

函数式编程就是一种抽象程度很高的编程模型，确定输入输出的叫没副作用的纯函数，内部变量不确定的，叫有副作用的函数。函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。但是Python不是纯函数式编程语言，因为Python允许使用变量。

一、高阶函数

1、map、reduce

Python内建了map()和reduce()函数。

map()

map()函数接收两个参数，一个是函数、一个是迭代器，map将传入的函数依次作用到序列的每个元素，并把结果作为新的迭代器返回。

也就是说序列里每一个元素都被当做x变量，放到一个函数f(x)里，其结果是f(x1)、f(x2)、f(x3)......组成的新序列。

举个例子，假如我们有函数 $f(x)=x^{2}$ ,要把这个函数作用在一个list[1,2,3,4,5,6,7,8,9]上，就可以用map函数实现：

代码：

def f(x):
    return x*x

r=map(f,[1,2,3,4,5,6,7,8,9])
list(r)
结果：[1,4,9,16,25,36,49,64,81]

map()传入的第一个参数是f，即函数对象本身，由于结果r是一个迭代器，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

记住map()作为高阶函数，事实上它把运算规则抽象了，我们可以用它计算任意的复杂函数，比如把列表所有数字转换成字符串：

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

reduce()

reduce的工作过程是：在迭代序列的过程中，首先把 前两个元素（只能两个）传给函数，函数加工后，然后把 得到的结果和第三个元素 作为两个参数传给函数参数， 函数加工后得到的结果又和第四个元素 作为两个参数传给函数参数，依次类推。

reduce把一个函数作用在一个序列[x1,x2,x3,....]上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比如说对一个序列求和，就可以用reduce实现：

from functools import reduce
def add(x, y):
    return x + y

reduce(add, [1, 3, 5, 7, 9])
25

当然求和运算可以直接用Python内建函数sum(),没必要动用reduce，但是如果把序列[1,3,5,7,9]变成整数13579，reduce就发挥作用了：

from functools import reduce
def fn(x, y):
    return x * 10 + y

reduce(fn, [1, 3, 5, 7, 9])
13579

如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

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]

reduce(fn, map(char2num, '13579'))
13579

整理成一个str2int的函数就是：

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)

还可以用lambda函数进一步简化成：

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 char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

也就是说，假设Python没有提供int()函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！

lambda函数的用法在后面介绍。

2、filter

Python内建的filter()函数用于过滤序列，和map()类似,filter()也接收一个函数和一个序列，和map不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

举例:

#在一个list中，删掉偶数，只保留奇数，可以这么写：
def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

#把一个序列中的空字符串删掉，可以这么写：
def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

用filter求素数

计算素数的一个方法是埃氏筛法，这个方法理解起来简单：

首先列出从2开始的所有自然数，构造一个序列：2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ...

取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：3, 5, 7, 9, 11,13, 15, ...

取新序列的第一个数3，它一定是素数，然后把3的倍数筛掉：5,7,11,13,17,19...

取新序列的第一个数5，然后用5把新序列的5的倍数筛掉：7,11,13,17,19....

不断筛下去，就可以得到所有素数。

用Python来实现，先构造从3开始的奇数序列:

def _odd_iter():
    n = 1
    while True:
        n = n + 2
        yield n

注意：这是一个生成器，并且是一个无限序列，然后定义一个筛选函数：

def _not_divisible(n):
    return lambda x: x % n>0

最后定义一个生成器，不断返回下一个素数：

def primes():
    yield 2
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列

这个生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列。

由于primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件：

# 打印1000以内的素数:
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

注意到Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

3、sorted

排序算法，也是程序中经常用到的算法，无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

Python内置的sorted()函数就可以对list进行排序：

sorted([36, 5, -12, 9, -21])
#结果：[-21, -12, 5, 9, 36]

此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

sorted([36, 5, -12, 9, -21], key=abs)
#结果：[5, 9, -12, -21, 36]

我们再看一个字符串排序的例子：

sorted(['bob', 'about', 'Zoo', 'Credit'])
#结果：['Credit', 'Zoo', 'about', 'bob']

默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。

现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，只要我们能用一个key函数把字符串映射为忽略大小写排序即可。忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写（或者都变成小写），再比较。

这样，我们给sorted传入key函数，即可实现忽略大小写的排序：

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
#结果：['about', 'bob', 'Credit', 'Zoo']

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
#结果：['Zoo', 'Credit', 'bob', 'about']

从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。

是小先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python3学习笔记之-函数式编程（第一篇）

Python3学习笔记之-函数式编程（第一篇）文章目录目录Python3学习笔记之-函数式编程（第一篇）文章目录前言一、高阶函数1、map、reducemap()reduce()2、filter用filter求素数3、sorted 前言函数是Python内建支持的一种封装，就是把大量的代码拆开写成函数，然后进行调用，这种分解可以称为面向过程的程序设计，函数就是面向过程的程序设计的基本单元。在计算机层面上，cpu执行的是加减乘除以及...
复制链接

扫一扫