《Python从小白到大牛》第10章函数式编程

原创

tony关东升 2022-11-09 10:01:11 博主文章分类：Python从小白到大牛 ©著作权

文章标签 Python Python开发 Python零基础 Python小白 python 文章分类 OpenStack 云计算

©著作权归作者所有：来自51CTO博客作者tony关东升的原创作品，请联系作者获取转载授权，否则将追究法律责任

《Python从小白到大牛》第10章函数式编程

定义函数
函数参数

使用关键字参数调用函数
参数默认值
可变参数

函数返回值

无返回值函数
多返回值函数

函数变量作用域
生成器
嵌套函数
函数式编程基础

函数类型

上述代码第①行重构了calculate_fun()函数的定义，现在只接收一个参数opr。代码第②行是在opr

Lambda表达式
三大基础函数

本章小结
配套视频
配套源代码

《Python从小白到大牛》已经上市！

程序中反复执行的代码可以封装到一个代码块中，这个代码块模仿了数学中的函数，具有函数名、参数和返回值，这就是程序中的函数。

Python中的函数很灵活，它可以在模块中，但类之外定义，即函数，作用域是当前模块；也可以在别的函数中定义，即嵌套函数；还可以在类中定义，即方法。

定义函数

在前面的学习过程中也用到了一些函数，如果len()、min()和max()，这些函数都由Python官方提供的，称为内置函数（Built-in
Functions, 缩写BIF）。

注意
Python作为解释性语言函数必须先定义后调用，也就是定义函数必须在调用函数之前，否则会有错误发生。

本节介绍自定义函数，自定义函数的语法格式如下：

def 函数名(参数列表) : 
    函数体
    return 返回值

在Python中定义函数时，关键字是def，函数名需要符合标识符命名规范；多个参数列表之间可以用逗号（,）分隔，当然函数也可以没有参数。如果函数有返回数据，就需要在函数体最后使用return语句将数据返回；如果没有返回数据，则函数体中可以使用return
None或省略return语句。

函数定义示例代码如下：

# coding=utf-8
# 代码文件：chapter10/ch10.1.py


def rectangle_area(width, height): ①
    area = width * height
    return area ②


r_area = rectangle_area(320.0, 480.0) ③

print("320x480的长方形的面积:{0:.2f}".format(r_area))

上述代码第①行是定义计算长方形面积的函数rectangle_area，它有两个参数，分别是长方形的宽和高，width和height是参数名。代码第②行代码是通过return返回函数计算结果。代码第③行是调用rectangle_area函数。

函数参数

Python中的函数参数很灵活，具体体现在传递参数有多种形式上。本节介绍几种不同形式参数和调用方式。

使用关键字参数调用函数

为了提高函数调用的可读性，在函数调用时可以使用关键字参数调用。采用关键字参数调用函数，在函数定义时不需要做额外的工作。

示例代码如下：

# coding=utf-8
# 代码文件：chapter10/ch10.2.1.py


def print_area(width, height):
    area = width * height
    print("{0} x {1} 长方形的面积:{2}".format(width, height, area))


print_area(320.0, 480.0)  # 没有采用关键字参数函数调用   ①
print_area(width=320.0, height=480.0)  # 采用关键字参数函数调用②
print_area(320.0, height=480.0)  # 采用关键字参数函数调用 ③
# print_area(width=320.0, height)  # 发生错误 ④
print_area(height=480.0, width=320.0)  # 采用关键字参数函数调用 ⑤

print_area函数有两个参数，在调用时没有采用关键字参数函数调用，见代码第①行，也可以使用关键字参数调用函数，见代码第②行、第③行和第⑤行，其中width和height是参数名。从上述代码比较可见采用关键字参数调用函数，调用者能够清晰地看出传递参数的含义，关键字参数对于有多参数函数调用非常有用。另外，采用关键字参数函数调用时，参数顺序可以与函数定义时参数顺序不同。

注意
在调用函数时，一旦其中一个参数采用了关键字参数形式传递，那么其后的所有参数都必须采用关键字参数形式传递。代码第④行的函数调用中第一个参数width采用了关键字参数形式，而它后面的参数没有采用关键字参数形式，因此会有错误发生。

参数默认值

在定义函数的时候可以为参数设置一个默认值，当调用函数的时候可以忽略该参数。来看下面的一个示例：

# coding=utf-8
# 代码文件：chapter9/ch10.2.2.py

def make_coffee(name="卡布奇诺"):
    return "制作一杯{0}咖啡。".format(name)

上述代码定义了makeCoffee函数，可以帮助我做一杯香浓的咖啡。由于我喜欢喝卡布奇诺，就把它设置为默认值。在参数列表中，默认值可以跟在参数类型的后面，通过等号提供给参数。

在调用的时候，如果调用者没有传递参数，则使用默认值。调用代码如下：

coffee1 = make_coffee("拿铁")  ①
coffee2 = make_coffee() ②

print(coffee1)  # 制作一杯拿铁咖啡。
print(coffee2)  # 制作一杯卡布奇诺咖啡。

其中第①行代码是传递"拿铁"参数，没有使用默认值。第②行代码没有传递参数，因此使用默认值。

提示
在其他语言中make_coffee函数可以采用重载实现多个版本。Python不支持函数重载，而是使用参数默认值的方式提供类似函数重载的功能。因为参数默认值只需要定义一个函数就可以了，而重载则需要定义多个函数，这会增加代码量。

可变参数

Python中函数的参数个数可以变化，它可以接受不确定数量的参数，这种参数称为可变参数。Python中可变参数有两种，在参数前加*或**形式，*可变参数在函数中被组装成为一个元组，**可变参数在函数中被组装成为一个字典。

*可变参数

下面看一个示例：

def sum(*numbers, multiple=1):
    total = 0.0
    for number in numbers:
        total += number
    return total * multiple

上述代码定义了一个sum()函数，用来计算传递给它的所有参数之和。*numbers是可变参数。在函数体中参数numbers被组装成为一个元组，可以使用for循环遍历numbers元组，计算他们的总和，然后返回给调用者。

下面是三次调用sum()函数的代码：

print(sum(100.0, 20.0, 30.0))  # 输出150.0
print(sum(30.0, 80.0))  # 输出110.0
print(sum(30.0, 80.0, multiple=2))  # 输出220.0 ①

double_tuple = (50.0, 60.0, 0.0)  # 元组或列表 ②
print(sum(30.0, 80.0, *double_tuple))  # 输出220.0 ③

可以看到，每次所传递参数的个数是不同的，前两次调用时都省略了multiple参数，第三次调用时传递了multiple参数，此时multiple应该使用关键字参数传递，否则有错误发生。

如果已经有一个元组变量（见代码第②行），能否传递给可变参数呢？这需要使用对元组进行拆包，见代码第③行在元组double_tuple前面加上单星号（*），单星号在这里表示将double_tuple拆包为50.0,
60.0, 0.0形式。另外，double_tuple也可以是列表对象。

注意
*可变参数不是最后一个参数时，后面的参数需要采用关键字参数形式传递。代码第①行30.0,
80.0是可变参数，后面multiple参数需要关键字参数形式传递。

**可变参数

下面看一个示例：

def show_info(sep=':', **info):
    print('-----info------')
    for key, value in info.items():
        print('{0} {2} {1}'.format(key, value, sep))

上述代码定义了一个show_info()函数，用来输出一些信息，其中参数sep信息分隔符号，默认值是冒号（:）。**info是可变参数，在函数体中参数info被组装成为一个字典。

注意 **可变参数必须在正规参数之后，如果本例函数定义改为show_info(**info,sep=’:’)形式，会发生错误。

下面是三次调用show_info()函数的代码：

show_info('->', name='Tony', age=18, sex=True)  ①
show_info(sutdent_name='Tony', sutdent_no='1000', sep='-') ②

stu_dict = {'name': 'Tony', 'age': 18}  # 创建字典对象 
show_info(**stu_dict, sex=True, sep='=')  # 传递字典stu_dict ③

上述代码第①行是调用函数show_info()，第一个参数’->'是传递给sep，其后的参数name=‘Tony’,
age=18,
sex=True是传递给info，这种参数形式事实上就是关键字参数，注意键不要用引号包裹起来。

代码第②行是调用函数show_info()，sep也采用关键字参数传递，这种方式sep参数可以放置在参数列表的任何位置，其中的关键字参数被收集到info字典中。

代码第③行是调用函数show_info()，其中字典对象stu_dict，传递时stu_dict前面加上双星号（**），双星号在这里表示将stu_dict拆包为key=value对的形式。

函数返回值

Python函数的返回值也是比较灵活的，主要有三种形式：无返回值、单一返回值和多返回值。前面使用的函数基本都单一返回值，本节重点介绍无返回值和多返回值两种形式。

无返回值函数

有的函数只是为了处理某个过程，此时可以将函数设计为无返回值的。所谓无返回值，事实上是返回None，None表示没有实际意义的数据。

无返回值函数示例代码如下：

# coding=utf-8
# 代码文件：chapter9/ch10.3.1.py

def show_info(sep=':', **info): ①
    """定义**可变参数函数"""
    print('-----info------')
    for key, value in info.items():
        print('{0} {2} {1}'.format(key, value, sep))
    return  # return None 或省略   ②


result = show_info('->', name='Tony', age=18, sex=True)
print(result)  # 输出 None 


def sum(*numbers, multiple=1): ③
    """定义*可变参数函数"""
    if len(numbers) == 0:
        return  # return None 或省略 ④
    total = 0.0
    for number in numbers:
        total += number
    return total * multiple


print(sum(30.0, 80.0))  # 输出110.0
print(sum(multiple=2)) # 输出 None ⑥

上述代码定义了两个函数，这个两个函数事实上是在10.3.2节示例基础上的重构。其中代码第①行的show_info()只是输出一些信息，不需要返回数据，因此可以省略return语句。如果一定要使用return语句，见代码第②行在函数结束前使用return或return
None。

对于本例中的show_info()函数强加return语句显然是多此一举，但是有时使用return或return
None是必要的。代码第③行定义了sum()函数，如果numbers中数据是空的，后面的求和计算也就没有意义了，可以在函数的开始判断numbers中算法有数据，如果没有数据则使用return或return
None跳出函数，见代码第④行。

多返回值函数

有时需要函数返回多个值，实现返回多个值的实现方式有很多，简单实现是使用元组返回多个值，因为元组作为数据结构可以容纳多个数据，另外元组是不可变的，使用起来比较安全。

下面来看一个示例：

# coding=utf-8
# 代码文件：chapter9/ch10.3.2.py


def position(dt, speed):  ①
    posx = speed[0] * dt  ②
    posy = speed[1] * dt  ③
    return (posx, posy)  ④


move = position(60.0, (10, -5)) ⑤

print("物体位移：({0}, {1})".format(move[0], move[1])) ⑥

这个示例是计算物体在指定时间和速度时的位移。第①行代码是定义position函数，其中dt参数是时间，speed参数是元组类型，speed第一个元素X轴上的速度，speed第二个元素Y轴上的速度。position函数的返回值也是元组类型。

函数体中的第②行代码是计算X方向的位移，第③行代码是计算Y方向的位移。最后，第④行代码将计算后的数据返回，(posx,
posy)是元组类型实例。

第⑤行代码调用函数，传递的时间是60.0秒，速度是(10,
-5)。第⑥行代码打印输出结果，结果如下：

物体位移：(600.0, -300.0)

函数变量作用域

变量可以在模块中创建，作用域是整个模块，称为全局变量。变量也可以在函数中创建，默认情况下作用域是整个函数，称为局部变量。

示例代码如下：

# coding=utf-8
# 代码文件：chapter9/ch10.4.py

# 创建全局变量x
x = 20 ①

def print_value():
    print("函数中x = {0}".format(x)) ②

print_value()
print("全局变量x = {0}".format(x))

输出结果：

函数中x = 20
全局变量x = 20

上述代码第①行是创建全局变量x，全局变量作用域是整个模块，所以在print_value()函数中也可以访问变量x，见代码第②行。

修改上述示例代码如下：

# 创建全局变量x
x = 20 

def print_value():
    # 创建局部变量x
    x = 10  ①
    print("函数中x = {0}".format(x)) 

print_value()
print("全局变量x = {0}".format(x))

输出结果：

函数中x = 10
全局变量x = 20

上述代码的是print_value()函数中添加x =
10语句，见代码第①行，这会函数中创建x变量，函数中的x变量与全局变量x命名相同，在函数作用域内会屏蔽全局x变量。

函数中创建的变量默认作用域是当前函数，这可以防止程序员少犯错误，因为函数中创建的变量，如果作用域是整个模块，那么在其他函数中也可以访问，Python无法从语言层面定义常量，所以在其他函数中由于误操作修改了变量，这样一来很容易导致程序出现错误。即便笔者不赞同，但Python提供这种可能，通过在函数中将变量声明为global的，可以把变量的作用域变成全局的。

修改上述示例代码如下：

# 创建全局变量x
x = 20 

def print_value():
    global x  ①
    x = 10   ②
    print("函数中x = {0}".format(x)) 

print_value()
print("全局变量x = {0}".format(x))

输出结果：

函数中x = 10
全局变量x = 10

代码第①行是在函数中声明x变量作用域为全局变量，所以代码第②行修改x值，就是修改全局变量x的数值。

生成器

在一个函数中使用return关键字返回数据，但是有时候会使用yield 关键字返回数据。yield 关键字的函数返回的是一个生成器（generator）对象，生成器对象是一种可迭代对象。

如果想计算平方数列，通常的实现代码如下：

def square(num):  ①
    n_list = []

    for i in range(1, num + 1):
        n_list.append(i * i) ②

    return n_list ③

for i in square(5):  ④
    print(i, end=' ')

返回结果是：

1 4 9 16 25

首先定义一个函数，见代码第①行。代码第②行通过循环计算一个数的平方，并将结果保存到一个列表对象n_list中。最后返回列表对象，见代码第③行。代码第④行是遍历返回的列表对象。

在Python中还可以有更加好解决方案，实现代码如下：

def square(num):

    for i in range(1, num + 1):
        yield i * i    ①


for i in square(5):  ②
    print(i, end=' ')

返回结果是：

1 4 9 16 25

代码第①行使用了yield关键字返回平方数，不再需要return关键字了。代码第②行调用函数square()返回的是生成器对象。生成器对象是一种可迭代对象，可迭代对象通过__next__()方法获得元素，代码第②行的for循环能够遍历可迭代对象，就是隐式地调用生成器的__next__()方法获得元素的。

显式地调用生成器的__next__()方法，在Python Shell中运行示例代码如下：

>>> def square(num):

    for i in range(1, num + 1):
            yield i * i

        
>>> n_seq = square(5)
<generator object square at 0x000001C8F123CE60>
>>> n_seq.__next__()  ①
1
>>> n_seq.__next__()
4
>>> n_seq.__next__()
9
>>> n_seq.__next__()
16
>>> n_seq.__next__()
25
>>> n_seq.__next__() ②
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    n_seq.__next__()
StopIteration
>>>

上述代码第①行~第②行调用了6次__next__()方法，但第6次调用则会抛出StopIteration异常，这是因为已经没有元素可迭代了。

生成器函数是通过yield返回数据，与return不同的是：return语句一次返回所有数据，函数调用结束；而yield语句只返回一个元素数据，函数调用不会结束，只是暂停，直到__next__()方法被调用，程序继续执行yield语句之后的语句代码。这个过程如图10-1所示。

《Python从小白到大牛》第10章函数式编程_python_02

注意
生成器特别适合用于遍历一些大序列对象，它无须将对象的所有元素都载入内存后才开始进行操作。而是仅在迭代至某个元素时才会将该元素载入内存。

嵌套函数

在本节之前定义的函数都是全局函数，并将他们定义在全局作用域中。函数还可定义在另外的函数体中，称作“嵌套函数”。

示例代码：

# coding=utf-8
# 代码文件：chapter10/ch10.6.py

def calculate(n1, n2, opr):
    multiple = 2

    # 定义相加函数
    def add(a, b): ①
        return (a + b) * multiple

    # 定义相减函数
    def sub(a, b): ②
        return (a - b) * multiple

    if opr == '+':
        return add(n1, n2)
    else:
        return sub(n1, n2)

print(calculate(10, 5, '+'))  # 输出结果是30
# add(10, 5) 发生错误 ③
# sub(10, 5)  发生错误 ④

上述代码中定义了两个嵌套函数：add()和sub()，见代码第①行和第②行。嵌套函数可以访问所在外部函数calculate()中的变量multiple，而外部函数不能访问嵌套函数局部变量。另外，嵌套函数的作用域在外部函数体内，因此在外部函数体之外直接访问嵌套函数会发生错误，见代码第③行和第④行。

函数式编程基础

函数式编程（functional
programming）与面向对象编程一样都一种编程范式，函数式编程，也称为面向函数的编程。

Python并不是彻底的函数式编程语言，但是还是提供了一些函数式编程必备的技术，主要有：函数类型和Lambda表达式，他们是实现函数式编程的基础。

函数类型

Python提供了一种函数类型function，任何一个函数都有函数类型，但是函数调用时，就创建了函数类型实例，即函数对象。函数类型实例与其他类型实例一样，在使用场景上没有区别：它可以赋值给一个变量；也可以作为参数传递给一个函数；还可以作为函数返回值使用。

为了理解函数类型，先重构10.6节中嵌套函数的示例，示例代码如下：

# coding=utf-8
# 代码文件：chapter10/ch10.7.1.py

def calculate_fun(opr): ①
    # 定义相加函数
    def add(a, b):
        return a + b

    # 定义相减函数
    def sub(a, b):
        return a - b

    if opr == '+':
        return add ②
    else:
        return sub ③

f1 = calculate_fun('+')  ④
f2 = calculate_fun('-')  ⑤

print(type(f1))

print("10 + 5 = {0}".format(f1(10, 5)))  ⑥
print("10 - 5 = {0}".format(f2(10, 5)))  ⑦

输出结果：

<class 'function'>
10 + 5 = 30
10 - 5 = 10

上述代码第①行重构了calculate_fun()函数的定义，现在只接收一个参数opr。代码第②行是在opr

'+'为True时返回add函数名，否则返回sub函数名，见代码第③行。这里的函数名本质上函数对象。calculate_fun()函数与10.5节示例calculate()函数不同之处在于，calculate_fun()函数返回的是函数对象，calculate()函数返回的是整数（相加或相减计算之后的结果）。所以代码第④行的f1是add()函数对象，代码第⑤行的f2是sub()函数对象。

函数对象是可以与函数一样进行调用的。事实上在第⑥行之前没有真正调用add()函数进行相加计算，f1(10,
5)表达式才真的调用了add()函数。第⑦行的f2(10, 5)表达式是调用sub()函数。

Lambda表达式

理解了函数类型和函数对象，学习Lambda表达式就简单了。Lambda表达式本质上一种匿名函数，匿名函数也是函数有函数类型，也可以创建函数对象。

定义Lambda表达式语法如下：

lambda 参数列表 : Lambda体

lambda是关键字声明这是一个Lambda表达式，“参数列表”与函数的参数列表是一样的，但不需要小括号包裹起来，冒号后面是“Lambda体”，Lambda表达式主要的代码在此处编写，类似于函数体。

注意
Lambda体部分不能是一个代码块，不能包含多条语句，只有一条语句，语句会计算一个结果返回给Lambda表达式，但是与函数不同是，不需要使用return语句返回。与其他语言中的Lambda表达式相比，Python中提供Lambda表达式只能处理一些简单的计算。

重构10.7.1节示例，代码如下：

# coding=utf-8
# 代码文件：chapter10/ch10.7.2.py

def calculate_fun(opr):
    if opr == '+':
        return lambda a, b: (a + b) ①
    else:
        return lambda a, b: (a - b) ②

f1 = calculate_fun('+')
f2 = calculate_fun('-')

print(type(f1))

print("10 + 5 = {0}".format(f1(10, 5)))
print("10 - 5 = {0}".format(f2(10, 5)))

输出结果：

<class 'function'>
10 + 5 = 30
10 - 5 = 10

上述代码第①行替代了add()函数，第②行替代了sub()函数，代码变的非常的简单。

三大基础函数

函数式编程本质是通过函数处理数据，过滤、映射和聚合是处理数据的三大基本操作。针对但其中三大基本操作Python提供了三个基础的函数：filter()、map()和reduce()。

filter()

过滤操作使用filter()函数，它可以对可迭代对象的元素进行过滤，filter()函数语法如下：

filter(function, iterable)

其中参数function是一个函数，参数iterable是可迭代对象。filter()函数调用时iterable会被遍历，它的元素逐一传入function函数，function函数返回布尔值，在function函数中编写过滤条件，如果为True的元素被保留，如果为False的元素被过滤掉。

下面通过一个示例介绍一下filter()函数使用，示例代码如下：

users = ['Tony', 'Tom', 'Ben', 'Alex']

users_filter = filter(lambda u: u.startswith('T'), users) ①
print(list(users_filter))

输出结果：

['Tony', 'Tom']

代码第①行调用filter()函数过滤users列表，过滤条件是T开通的元素，lambda u:
u.startswith(‘T’)是一个Lambda表达式，它提供了过滤条件。filter()函数还不是一个列表，需要使用list()函数转换过滤之后的数据为列表。

再看一个示例：

number_list = range(1, 11)
nmber_filter = filter(lambda it: it % 2 == 0, number_list)
print(list(nmber_filter))

该示例实现了获取1~10数字中的偶数，输出结果如下：

[2, 4, 6, 8, 10]

map()

映射操作使用map()函数，它可以对可迭代对象的元素进行变换，map()函数语法如下：

map(function, iterable)

其中参数function是一个函数，参数iterable是可迭代对象。map()函数调用时iterable会被遍历，它的元素逐一传入function函数，在function函数中对元素进行变换。

下面通过一个示例介绍一下map()函数使用，示例代码如下：

users = ['Tony', 'Tom', 'Ben', 'Alex']

users_map = map(lambda u: u.lower(), users) ①  
print(list(users_map))

输出结果：

['tony', 'tom', 'ben', 'alex']

上述代码第①行调用map()函数将users列表元素转换为小写字母，变换使用Lambda表达式lambda
u:
u.lower()。map()函数返回的还不是一个列表，需要使用list()函数将过滤之后的数据转换为列表。

函数式编程时数据可以从一个函数“流”入另外一个函数，但是遗憾的是Python并不支持“链式”API。例如想获取users列表中“T”开通的名字，再将其转换为小写字母，这样的需求需要使用filter()函数进行过滤，再使用map()函数进行映射变换。实现代码如下：

users = ['Tony', 'Tom', 'Ben', 'Alex']

users_filter = filter(lambda u: u.startswith('T'), users)

# users_map = map(lambda u: u.lower(), users_filter) ①
users_map = map(lambda u: u.lower(), filter(lambda u: u.startswith('T'), users)) ②

print(list(users_map))

上述代码第①行和第②行实现相同功能。

reduce()

聚合操作会将多个数据聚合起来输出单个数据，聚合操作中最基础的是归纳函数reduce()，reduce()函数会将多个数据按照指定的算法积累叠加起来，最后输出一个数据。

reduce()函数语法如下：

reduce(function, iterable[, initializer])

参数function是聚合操作函数，该函数有两个参数，参数iterable是可迭代对象；参数initializer初始值。

下面通过一个示例介绍一下reduce()函数使用。下面示例实现了对一个数列求和运算，代码如下：

from functools import reduce ①

a = (1, 2, 3, 4)
a_reduce = reduce(lambda acc, i: acc + i, a)  # 10 ②
# a_reduce = reduce(lambda acc, i: acc + i, a, 2)  # 12 ③
print(a_reduce)

reduce()函数是在functools模块中定义的，所以要使用reduce()函数需要导入functools模块，见代码第①行。代码第②行是调用reduce()函数，其中lambda
acc, i: acc +
i是进行聚合操作的Lambda表达式，该Lambda表达式有两个参数，其中acc参数是上次累积计算结果，i当前元素，acc
+
i表达式是进行累加。reduce()函数最后的计算结果是一个数值，直接可以使用通过reduce()函数返回。代码第行是传入了初始值2，则计算的结果是12。