Python之函数进阶-函数加强(上)（python函数的作用增强代码的可读性）

一. 递归

函数递归是一种编程技术，其中函数调用自身以解决问题。递归函数需要有一个或多个终止条件，以防止无限递归。

递归可以用于解决许多问题，例如排序、搜索、解析语法等。递归的优点是代码简洁、易于理解，并且可以解决某些问题更有效。但是，递归也有一些缺点，例如它可能会导致堆栈溢出和重复计算等问题。

递归的特点：

函数内部自己调用自己；

必须有出口。

递归应用：3以内数字累加和

# 3 + 2 + 1
def sum_numbers(num):
    # 1.如果是1，直接返回1 -- 出口口
    if num == 1:
        return 1
    # 2.如果不不是1，重复执行行行累加:
    result = num + sum_numbers(num-1)

    # 3.返回累加结果
    return result

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

执行结果：

二、lambda 表达式：

Lambda表达式是一种匿名函数，可以作为表达式的一部分。它允许您在函数内部定义简单的函数，并直接使用它们。Lambda函数通常用于简单的、临时的一次性操作，而不是用于解决复杂问题。

Lambda表达式的语法如下：

lambda arguments: expression

其中，arguments是函数参数的列表，用逗号分隔；expression是函数的返回值。Lambda函数没有自己的名称，因此它们被称为“匿名函数”。

下面是一个使用Lambda表达式的例子：

# 计算两个数字的和  
sum = lambda a, b: a + b
print(sum(1, 2))  # 输出：3  

# 将列表中的每个元素乘以2  
double = lambda x: x * 2
print(list(map(double, [1, 2, 3, 4, 5])))  # 输出：[2, 4, 6, 8, 10]

注意：

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

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

lambda的参数形式：

Lambda函数的参数形式与普通函数相同，可以使用位置参数、默认参数、可变数量参数等。

1.位置参数：

lambda argument1, argument2: expression

2.默认参数：

lambda argument1, argument2=value2: expression

3.可变数量参数：

lambda *args: expression

其中，args是一个包含所有位置参数的元组。

此外，Lambda函数还可以使用关键字参数：

lambda argument1=value1, argument2=value2: expression

需要注意的是，Lambda函数的参数名称必须是唯一的，不能与之前的参数重名。

lambda的应用：

1.带判断的lambda

print((lambda a, b: a if a > b else b)(1000, 500))

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

students = [
    {'name': 'TOM', 'age': 20},
    {'name': 'ROSE', 'age': 19},
    {'name': 'Jack', 'age': 22}
    ]

# 按name值升序排列列
students.sort(key=lambda x: x['name'])
print(students)
# 按name值降序排列列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)
# 按age值升序排列列
students.sort(key=lambda x: x['age'])
print(students)

三、高阶函数

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

体验高阶函数：一个函数完成计算任意两个数字的绝对值之和。

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

abs(-10) # 10

方法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, f):
    return f(a) + f(b)

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

两种方法对比之后，发现，方法2的代码会更更加简洁，函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。

内置高阶函数

map(func, lst)，将传入的函数变量func作用到lst变量量的每个元素中，并将结果组成新的列表(a)/迭代器(b)返回。计算list1序列中各个数字的2次方：

list1 = [1, 2, 3, 4, 5]
def func(x):
    return x ** 2
result = map(func, list1)

print(result) # <map object at 0x0000013769653198>
print(list(result)) # [1, 4, 9, 16, 25]

reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。计算list1序列中各个数字的累加和：

import functools

list1 = [1, 2, 3, 4, 5]
def func(a, b):
    return a + b

result = functools.reduce(func, list1)
print(result) # 15

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

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]