Python基础语法（十五）函数——函数加强：递归、lambda 表达式、高阶函数

目标

• 递归

• lambda 表达式

• 高阶函数

一. 递归

1.1 递归的应用场景

递归是一种编程思想，应用场景：

1. 在我们日常开发中，如果要遍历一个文件夹下面所有的文件，通常会使用递归来实现；

2. 在后续的算法课程中，很多算法都离不开递归，例如：快速排序。

1.1.1 递归的特点

• 函数内部自己调用自己

• 必须有出口，即结束条件

  当达到出口条件时，函数将一步一步结束递归计算

1.2 应用：3以内数字累加和

• 代码

"""
递归特点：
1. 函数内部也可调用
2. 须有出口, 即结束条件

函数返回值： 写法 和 返回的位置： 函数调用的位置
"""
# 3 + 2 + 1
# 6 = 3 + 2以内数字累加和
# 2以内数字累加和 = 2 + 1以内数字累加和
# 1以内数字累计和 = 1 # 出口：当达到结束条件，就开始一层一层结束     递归
def sum_numbers(num):
    # 1.如果是1，直接返回1 -- 出口
    if num == 1:   # 出口：结束条件
      return 1   # 当达到出口条件，就返回1结束递归
    # 2.如果不是1，重复执行累加并返回结果
    return num + sum_numbers(num-1)

 
sum_result = sum_numbers(3)
# 输出结果为6
print(sum_result)

• 执行结果

递归出口问题：

​ 当递归没有出口时，报错：超出最大递归深度。

二. lambda 表达式

2.1 lambda的应用场景

如果一个函数有一个返回值，并且只有一句代码，可以使用 lambda简化。

lambda作用是简化代码。

2.2 lambda语法

lambda 参数列表（即函数形参） ： 表达式

注意

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

• lambda表达式能接收任何数量的参数==但只能返回一个表达式的值==。

2.2.1 示例

# 函数
def fn1():
	return 100

ret1 = fn1()
print(ret1)

# lambda表达式, lambda也称匿名函数
# 语法：lambda 参数列表 ： 表达式（这里用上式中return后面的表达式）

fn2 = lambda: 100  #把lambda表达式保存到变量fn2中
print(fn2)  # lambda--也称匿名函数，此时打印的是lambda的内存地址
# 得到 100返回值 调用函数fn2()
print(fn2())

注意：直接打印lambda表达式，输出的是此lambda表达式的内存地址

2.3 示例：计算a + b

2.3.1 函数实现

# 计算a+b
# 自定义函数表达
def add(a, b):
	return a + b

ret1 = add(1, 2)
print(ret1)

思考：需求简单，是否代码多？

2.3.2 lambda实现

**注：**对于自定义函数，如果使用lambda表达式（其中，表达式中含形参数）简化时，调用时使用赋值变量加实参即可

# lambda表达式
fn1 = lambda a, b: a+b
print(fn1(1, 2))

2.4 lambda的参数形式

2.4.1.无参数

# 无参数
fn1 = lambda: 100 # 自定义函数没有参数时
print(fn1()) 

2.4.2.一个参数

fn1 = lambda a: a
print(fn1('hello world'))  # lambda有几个形参，函数调用时候就要传入几个数据

2.4.3.默认参数（缺省参数）

​ lambda表达式有几个形参，函数调用时就需要几个传入数据。

fn1 = lambda a, b, c=100: a + b + c
print(fn1(1, 2, 1000))
print(fn1(1, 2))

2.4.4.可变参数：*args

​ 可变参数：用于不确定调用的时候会传递多少个参数(不传参也可以)的场景

fn1 = lambda *args: args
print(fn1(10, 20, 20)) # 结果：(10, 20, 20)
print(fn1(12)) # 结果：(12,)

注意：这里的可变参数传入到lambda之后，返回值为元组。

用于位置参数传递数据，用于接收位置参数，但是不确定位置参数个数时，使用一个变量*args去接收参数，返回是元组类型，

2.4.5.可变参数：**kwargs

​ 可变参数：用于不确定调用的时候会传递多少个参数(不传参也可以)的场景

fn1 = lambda **kwargs: kwargs
print(fn1(name='python', age=20))

注意：这里的可变参数传入到lambda之后，返回值为字典。

用于关键字参数传递数据，用于接收关键字参数，但是不确定关键字参数个数时，使用一个变量 **kwargs去接收参数，返回是字典类型

2.5 lambda的应用

2.5.1. 带判断的lambda

fn1 = lambda a, b: a if a > b else b # a if a > b else b 三目运算符
print(fn1(1000, 500))

2.5.2. 列表数据按字典key的值排序

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'Jack', 'age': 22}
]
# 列表序列名.sort(key=lambda..., reverse=bool型(True或False))


# 按name key对应的值进行升序排序
students.sort(key=lambda x: x['name'])
# 默认按照升序排列，即reverse=false,可不写
print(students)

# 按name key对应的值进行降序排序
students.sort(key=lambda x: x['name'], reverse=True)
# 列表序列名.sort() 默认按照升序排列，即reverse=True
print(students)

# 按age key对应的值进行升序排序
students.sort(key=lambda x: x['age'])
# 列表序列名.sort() 默认按照升序排列，即reverse=false,可不写
print(students)

注意：students.sort(key=lambda x: x['name'])在这段代码中，x是一个lambda表达式的参数，用于表示students列表中的每个字典元素，在lambda函数中代表每个字典元素本身，也就是说x实际上就是一个字典。

该段代码将包含学生姓名及年龄等信息的字典按照姓名（name）的首字母进行升序排序。其中sort()函数的key参数指定了排序时所使用的关键字，而通过lambda函数定义的参数x则是用于提取字典元素中作为排序依据的name值，从而实现按照name值进行排序的功能。在这里，lambda表达式相当于一个匿名函数，用于提供sort()函数所需的关键字。

三. 高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

3.1 体验高阶函数

在Python中，abs()函数可以完成对数字求绝对值计算。

abs(-10)  # 10

round()函数可以完成对数字的四舍五入计算。

round(1.2)  # 1
round(1.9)  # 2

需求：任意两个数字，按照指定要求整理数字后再进行求和计算。

• 方法1

def add_num(a, b):
    return abs(a) + abs(b)


result = add_num(-1, 2)
print(result)  # 3

• 方法2

def sum_num(a, b, fun):
    return fun(a) + fun(b)


result = sum_num(-1, 2, abs)
print(result)  # 3

注意：两种方法对比之后，发现，方法2的代码会更加简洁，函数灵活性更高。

函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

3.2 内置高阶函数

3.1.1 map()—迭代

​ map(func, lst)，==将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(Python2)/**迭代器(Python3)**返回。==如果要转换为列表, 可以使用 list() 来转换。

需求：计算list1序列中各个数字的2次方。

list1 = [1, 2, 3, 4, 5]


def func(x):
    return x ** 2
# func = lambda x : x ** 2

result = map(func, list1)

print(result)  # <map object at 0x0000013769653198> # 打印计算后存在内存里的地址

print(list(result))  # [1, 4, 9, 16, 25] 把结果用列表list转换打印出来

3.2.2 reduce()—累积计算

​ reduce(func，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。

注意：reduce()传入的参数func必须接收2个参数。

需求：计算list1序列中各个数字的累加和。

# 导入模块
import functools

list1 = [1, 2, 3, 4, 5]

# 定义函数func
def func(a, b):
    return a + b


result = functools.reduce(func, list1)

print(result)  # 15

3.2.3 filter()—过滤

​ **filter(func, lst)**函数用于过滤序列, 过滤掉不符合条件的元素, 返回一个 filter 对象。如果要转换为列表, 可以使用 list() 来转换。

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def func(x):
    return x % 2 == 0


result = filter(func, list1)

print(result)  # <filter object at 0x0000017AF9DC3198> # 打印计算后存在内存里的地址
print(list(result))  # [2, 4, 6, 8, 10]

总结

• 递归

  • 函数内部自己调用自己
  • 必须有出口

• lambda

  • 语法

  lambda 参数列表: 表达式

  • lambda的参数形式

    • 无参数

    lambda: 表达式

    • 一个参数

    lambda 参数: 表达式

    • 默认参数

    lambda key=value: 表达式

    • 不定长位置参数

    lambda *args: 表达式

    • 不定长关键字参数

    lambda **kwargs: 表达式

• 高阶函数

  • 作用：把函数作为参数传入，化简代码
  • 内置高阶函数
    • map()
    • reduce()
    • filter()