学习python的第十四天之函数——高阶函数和偏函数

学习python的第十四天之函数——高阶函数和偏函数

高阶函数

高阶函数是指那些可以接受一个或多个函数作为参数，或者返回一个函数作为结果的函数。高阶函数是函数式编程范式中的一个重要概念，它们使得代码更加灵活和模块化。

sorted()

sorted()函数用于对一个可迭代对象（如列表、元组、字符串等）中的元素进行排序，并返回一个新的排序后的列表。sorted() 函数不会改变原始的可迭代对象，而是返回一个新的列表。

语法：sorted(iterable, key=None, reverse=False)

• iterable: 一个可迭代对象，如列表、元组、字符串等，需要对其进行排序。
• key（可选）: 一个函数，接收一个参数并返回一个用于排序的值。这个函数通常用于指定排序的依据，例如按照元素的某个属性或经过某种变换后的值进行排序。如果没有提供 key，则默认使用元素本身的值进行排序。
• reverse（可选）: 一个布尔值，如果为 True，则按照降序排序；如果为 False（默认），则按照升序排序。

工作原理：

sorted() 函数会对 iterable 中的元素进行排序，并返回一个新的排序后的列表。排序的依据是 key 函数返回的值（如果提供了 key），或者元素本身的值（如果没有提供 key）。排序的顺序由 reverse 参数决定。

对列表进行排序

# 对一个列表进行升序排序
numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers = sorted(numbers)print(sorted_numbers)  # 输出: [1, 2, 5, 5, 6, 9]

使用 key 参数

# 对一个包含字符串的列表按照字符串长度进行排序
words = ['apple', 'banana', 'cherry', 'date']
sorted_words_by_length = sorted(words, key=len)print(sorted_words_by_length)  # 输出: ['date', 'apple', 'cherry', 'banana']

‌使用 reverse 参数

# 对一个列表进行降序排序
numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers_desc = sorted(numbers, reverse=True)print(sorted_numbers_desc)  # 输出: [9, 6, 5, 5, 2, 1]

对元组列表按照特定元素排序

# 对一个包含元组的列表按照元组的第二个元素进行排序
students = [('John', 90), ('Jane', 85), ('Dave', 92), ('Eva', 88)]
sorted_students_by_score = sorted(students, key=lambda student: student)print(sorted_students_by_score)  # 输出: [('Jane', 85), ('Eva', 88), ('John', 90), ('Dave', 92)]

对字典按照特定元素排序

# 按照键排序
# 创建一个字典
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}# 按照键排序
sorted_keys = sorted(my_dict.keys())# 输出排序后的键
print(sorted_keys)  # 输出: ['apple', 'banana', 'orange', 'pear']# 如果需要排序后的字典，可以使用字典推导式
sorted_dict_by_keys = {k: my_dict[k] for k in sorted_keys}
print(sorted_dict_by_keys)  # 输出: {'apple': 4, 'banana': 3, 'orange': 2, 'pear': 1}# 按照值排序
# 创建一个字典
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}# 按照值排序，并获取键-值对组成的列表
sorted_items_by_values = sorted(my_dict.items(), key=lambda item: item)# 输出排序后的键-值对
print(sorted_items_by_values)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]# 如果需要排序后的字典，可以使用字典推导式
sorted_dict_by_values = {k: v for k, v in sorted_items_by_values}
print(sorted_dict_by_values)  # 输出: {'pear': 1, 'orange': 2, 'banana': 3, 'apple': 4}# 按照键-值对排序（实际上这是按照键排序的另一种形式，因为键-值对中的键是主要的排序依据）
# 创建一个字典
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}# 按照键-值对排序（这里实际上是根据键排序）
sorted_items = sorted(my_dict.items())# 输出排序后的键-值对
print(sorted_items)  # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]# 注意：这里不需要使用字典推导式来转换回字典，因为 sorted_items 已经是一个键-值对的列表了。
# 如果确实需要字典形式，可以直接使用 dict(sorted_items)，但这样做通常没有意义，因为排序后的列表已经足够表达排序结果。

**map()**‌

map()函数接受两个参数：一个函数和一个可迭代对象（如列表）。它会将这个函数应用到可迭代对象的每个元素上，并返回一个迭代器（在Python 3中，需要用list()将其转换为列表）。

语法：map(function, iterable, …)

• function: 一个函数，接收一个或多个参数，并返回一个值。这个函数可以是已定义的函数，也可以是一个匿名函数（使用 lambda 表达式）。
• iterable: 一个或多个可迭代对象。如果提供了多个可迭代对象，function 必须能够接受对应数量的参数，并且这些可迭代对象的长度必须相同（或者最短的长度将被用作结束点）。

工作原理：

map() 函数会对提供的每个可迭代对象中的元素按位置依次应用 function，并返回一个包含所有函数结果的迭代器。

# 定义一个函数，将数值加倍
def double(n):return n * 2# 使用 map() 将列表中的每个元素加倍
numbers = [1, 2, 3, 4, 5]
doubled_numbers = map(double, numbers)# 由于 map() 返回的是一个迭代器，我们需要将其转换为列表以查看结果
print(list(doubled_numbers))  # 输出: [2, 4, 6, 8, 10]

或者使用lambda表达式：

# 使用 lambda 表达式和 map() 将列表中的每个元素加倍
numbers = [1, 2, 3, 4, 5]
doubled_numbers = map(lambda n: n * 2, numbers)# 转换为列表以查看结果
print(list(doubled_numbers))  # 输出: [2, 4, 6, 8, 10]

对多个可迭代对象应用函数

# 定义一个函数，接收两个参数并返回它们的和
def add(x, y):return x + y# 使用 map() 对两个列表中的元素逐对相加
list1 = [1, 2, 3]
list2 = [4, 5, 6]
added_numbers = map(add, list1, list2)# 转换为列表以查看结果
print(list(added_numbers))  # 输出: [5, 7, 9]# 注意：如果两个列表长度不同，map() 会以较短的列表为准
list3 = [1, 2]
list4 = [3, 4, 5]
added_numbers_short = map(add, list3, list4)
print(list(added_numbers_short))  # 输出: [4, 6]

注意事项

• map() 返回的是一个迭代器，而不是一个列表。如果你需要直接查看结果，可以使用 list() 函数将其转换为列表。
• 在 Python 2 中，map() 返回的是一个列表，而不是迭代器。这是 Python 2 和 Python 3 之间的一个重要区别。
• 如果提供了多个可迭代对象，它们必须具有相同的长度（或者最短的长度将被用作结束点），否则 map() 会引发 ValueError。

**filter()**‌

filter()函数也接受两个参数：一个函数和一个可迭代对象。用于从一个可迭代对象（如列表、元组、字符串等）中筛选出符合特定条件的元素。它会创建一个迭代器，包含可迭代对象中所有通过提供的函数测试的元素。

语法：filter(function, iterable)

• function: 一个函数，接收一个参数并返回布尔值 True 或 False。function 可以是一个已定义的函数，也可以是一个匿名函数（使用 lambda 表达式）。
• iterable: 一个可迭代对象，如列表、元组、字符串等。

工作原理：

filter() 函数会对 iterable 中的每个元素应用 function，并返回一个包含所有 function 返回 True 的元素的迭代器。

# 定义一个函数，判断一个数是否为偶数
def is_even(n):return n % 2 == 0# 使用 filter() 筛选出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter(is_even, numbers)# 由于 filter() 返回的是一个迭代器，我们需要将其转换为列表以查看结果
print(list(even_numbers))  # 输出: [2, 4, 6, 8, 10]

或者使用lambda表达式：

# 使用 lambda 表达式和 filter() 筛选出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter(lambda n: n % 2 == 0, numbers)# 转换为列表以查看结果
print(list(even_numbers))  # 输出: [2, 4, 6, 8, 10]

筛选字符串中的特定字符

# 筛选出字符串中所有的字母 'a'
letters = ['a', 'b', 'c', 'a', 'd', 'e', 'a', 'f']
filtered_letters = filter(lambda x: x == 'a', letters)# 转换为列表以查看结果
print(list(filtered_letters))  # 输出: ['a', 'a', 'a']

与其他函数结合使用

# 结合 map() 和 filter() 使用，先对列表中的元素进行平方，然后筛选出平方后的偶数
numbers = [1, 2, 3, 4, 5]
squared_even_numbers = filter(lambda x: x % 2 == 0, map(lambda x: x * x, numbers))# 转换为列表以查看结果
print(list(squared_even_numbers))  # 输出: [4, 16]

注意事项

• filter() 返回的是一个迭代器，而不是一个列表。如果你需要直接查看结果，可以使用 list() 函数将其转换为列表。
• 在 Python 2 中，filter() 返回的是一个列表，而不是迭代器。这是 Python 2 和 Python 3 之间的一个重要区别。
• filter() 函数不会改变原始的可迭代对象，而是返回一个新的迭代器。

**reduce()**‌

reduce()函数在Python 3中被移到了functools模块中。它接受两个参数：一个函数和一个可迭代对象。这个函数必须接受两个参数，并返回一个值。reduce()会将这个函数应用到可迭代对象的第一个和第二个元素上，得到的结果再和第三个元素一起作为参数传递给这个函数，依此类推，直到处理完整个可迭代对象。

语法：

from functools import reduce （需要从 functools 模块导入 reduce() 函数）

reduce(function, iterable[, initializer])

• function: 一个接收两个参数的函数。这两个参数通常是序列中的元素，但在第一次调用时，如果提供了 initializer，则第一个参数是 initializer，第二个参数是序列的第一个元素。
• iterable: 一个可迭代对象，如列表、元组等。
• initializer（可选）: 一个初始值，用于在第一次调用 function 时作为第一个参数。如果没有提供 initializer，则默认使用 iterable 中的第一个元素作为初始值，并从第二个元素开始迭代。

工作原理：

reduce() 函数会对 iterable 中的元素从左到右依次应用 function，每次应用都会将当前结果和下一个元素作为参数传递给 function，直到迭代结束。最终，reduce() 返回的是一个单一的值，即最后一次调用 function 的结果。

from functools import reduce# 定义一个函数，接收两个参数并返回它们的和
def add(x, y):return x + y# 使用 reduce() 计算列表的和
numbers = [1, 2, 3, 4, 5]
sum_of_numbers = reduce(add, numbers)print(sum_of_numbers)  # 输出: 15

或者使用lambda表达式：

from functools import reduce# 使用 lambda 表达式和 reduce() 计算列表的乘积
numbers = [1, 2, 3, 4, 5]
product_of_numbers = reduce(lambda x, y: x * y, numbers)print(product_of_numbers)  # 输出: 120

使用 initializer

from functools import reduce# 使用 initializer 和 reduce() 计算列表的和，但初始值设为 10
numbers = [1, 2, 3, 4, 5]
sum_with_initializer = reduce(add, numbers, 10)print(sum_with_initializer)  # 输出: 25（10 + 1 + 2 + 3 + 4 + 5）

注意事项

• reduce() 函数在 Python 3 中位于 functools 模块中，因此在使用前需要导入。
• 提供的 function 必须接收两个参数，并且这两个参数的类型应该与 iterable 中的元素类型兼容。
• 如果 iterable 为空且没有提供 initializer，reduce() 会引发 TypeError。
• 如果提供了 initializer，它会在第一次调用 function 时作为第一个参数，这对于某些累计运算可能很有用。

自定义高阶函数

def with_logging(func):def wrapper(*args, **kwargs):print(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")result = func(*args, **kwargs)print(f"{func.__name__} returned {result}")return resultreturn wrapper@with_logging  # 这是一个装饰器语法，等价于 square = with_logging(square)
def square(x):return x * xprint(square(4))  # 输出日志信息，并返回 16

在这个例子中，with_logging是一个高阶函数，它接受一个函数作为参数，并返回一个新的函数，这个新函数在执行原始函数之前和之后都会打印日志信息。通过使用装饰器语法@with_logging，我们可以方便地将这个高阶函数应用到其他函数上。

偏函数

偏函数（Partial Function）允许我们固定函数的某些参数，从而创建一个新的函数。这样做可以让我们在多次调用同一个函数时，避免重复传递那些不变的参数。Python标准库中的functools模块提供了partial函数来实现这一功能。

使用偏函数的好处

1. ‌代码复用‌：通过固定某些参数，我们可以创建更加通用的函数，减少代码的重复。
2. ‌提高可读性‌：偏函数可以让调用更加清晰，因为那些固定的参数不需要在每次调用时都显式地传递。
3. ‌简化参数传递‌：当某个函数有多个参数，而其中的一些参数在多次调用中都不变时，使用偏函数可以简化调用。

functools.partial的使用

functools.partial的基本语法如下：

from functools import partial

创建一个偏函数
partial_func = partial(原始函数, 参数1, 参数2, …)

调用偏函数
result = partial_func(剩余参数1, 剩余参数2, …)

示例

假设我们有一个函数add，它接受两个参数a和b，并返回它们的和。如果我们经常需要将某个固定的值加到不同的数上，我们可以使用偏函数来简化这个过程。

from functools import partial# 原始函数
def add(a, b):return a + b# 创建一个偏函数，固定参数a的值为5
add_five = partial(add, 5)# 使用偏函数
print(add_five(10))  # 输出15
print(add_five(20))  # 输出25

在这个例子中，add_five是一个偏函数，它将add函数的第一个参数a固定为5。因此，当我们调用add_five时，只需要传递一个参数，即b的值。

注意事项

1. ‌参数顺序‌：在创建偏函数时，需要按照原始函数的参数顺序来传递那些要固定的参数。
2. ‌剩余参数‌：偏函数创建后，调用时传递的参数会按顺序替换原始函数中未被固定的参数。
3. ‌关键字参数‌：functools.partial也支持通过关键字参数来固定某些参数的值。例如，partial(func, a=1, b=2)会固定a和b的值。