高阶函数

在Python中，函数被视为一等公民，这意味着您可以对函数执行以下操作：

• 一个函数可以接受一个或多个函数作为参数
• 一个函数可以作为另一个函数的返回值
• 一个函数可以被修改
• 一个函数可以被赋值给一个变量

在这一部分，我们将介绍：

1. 如何处理函数作为参数的情况
2. 如何返回函数作为另一个函数的返回值
3. 如何使用Python闭包和装饰器

函数作为参数

def sum_numbers(nums):  # 正常的函数
    return sum(nums)    # 一个滥用内置的sum函数的悲伤函数。:<

def higher_order_function(f, lst):  # 将函数作为参数
    summation = f(lst)
    return summation
result = higher_order_function(sum_numbers, [1, 2, 3, 4, 5])
print(result)       # 15

函数作为返回值

def square(x):          # 平方函数
    return x ** 2

def cube(x):            # 立方函数
    return x ** 3

def absolute(x):        # 绝对值函数
    if x >= 0:
        return x
    else:
        return -(x)

def higher_order_function(type): # 一个更高阶的函数返回函数
    if type == 'square':
        return square
    elif type == 'cube':
        return cube
    elif type == 'absolute':
        return absolute

result = higher_order_function('square')
print(result(3))       # 9
result = higher_order_function('cube')
print(result(3))       # 27
result = higher_order_function('absolute')
print(result(-3))      # 3

您可以从上面的示例中看到，高阶函数根据传递的参数返回不同的函数。

Python闭包

Python允许嵌套函数访问封闭函数的外部范围。这被称为闭包。让我们看看Python中闭包的工作原理。在Python中，闭包是通过将一个函数嵌套在另一个封装函数内部，然后返回内部函数来创建的。请看下面的示例。

示例：

def add_ten():
    ten = 10
    def add(num):
        return num + ten
    return add

closure_result = add_ten()
print(closure_result(5))  # 15
print(closure_result(10))  # 20

Python装饰器

装饰器是Python中的一种设计模式，它允许用户在不修改其结构的情况下向现有对象添加新功能。装饰器通常在要装饰的函数的定义之前调用。

创建装饰器

要创建装饰器函数，我们需要一个具有内部包装函数的外部函数。

示例：

# 普通函数
def greeting():
    return 'Welcome to Python'
def uppercase_decorator(function):
    def wrapper():
        func = function()
        make_uppercase = func.upper()
        return make_uppercase
    return wrapper
g = uppercase_decorator(greeting)
print(g())          # WELCOME TO PYTHON

## 让我们使用装饰器实现上面的示例

'''这个装饰器函数是一个高阶函数，
		它将一个函数作为参数'''
def uppercase_decorator(function):
    def wrapper():
        func = function()
        make_uppercase = func.upper()
        return make_uppercase
    return wrapper
@uppercase_decorator
def greeting():
    return 'Welcome to Python'
print(greeting())   # WELCOME TO PYTHON

将多个装饰器应用于单个函数

'''这个装饰器函数是一个高阶函数，
		它将一个函数作为参数'''

# 第一个装饰器
def uppercase_decorator(function):
    def wrapper():
        func = function()
        make_uppercase = func.upper()
        return make_uppercase
    return wrapper

# 第二个装饰器
def split_string_decorator(function):
    def wrapper():
        func = function()
        splitted_string = func.split()
        return splitted_string

    return wrapper

@split_string_decorator
@uppercase_decorator     # 在这种情况下，装饰器的顺序很重要 - .upper()函数不能用于列表
def greeting():
    return 'Welcome to Python'
print(greeting())   # WELCOME TO PYTHON

接受参数的装饰器函数

大多数情况下，我们需要我们的函数接受参数，因此我们可能需要定义一个接受参数的装饰器。

def decorator_with_parameters(function):
    def wrapper_accepting_parameters(para1, para2, para3):
        function(para1, para2, para3)
        print("I live in {}".format(para3))
    return wrapper_accepting_parameters

@decorator_with_parameters
def print_full_name(first_name, last_name, country):
    print("I am {} {}. I love to teach.".format(
        first_name, last_name, country))

print_full_name("Asabeneh", "Yetayeh",'Finland')

内置高阶函数

本部分介绍的一些内置高阶函数包括map()，filter()和reduce()。Lambda函数可以作为参数传递，最佳使用情况是在像map、filter和reduce这样的函数中使用lambda函数。

Python-Map函数

map()函数是一个内置函数，它将函数和可迭代对象作为参数。

# 语法
map(function, iterable)

示例1：

numbers = [1, 2, 3, 4, 5] # 可迭代对象
def square(x):
    return x ** 2
numbers_squared = map(square, numbers)
print(list(numbers_squared))    # [1, 4, 9, 16, 25]
# 让我们使用 lambda 函数来应用它
numbers_squared = map(lambda x : x ** 2, numbers)
print(list(numbers_squared))    # [1, 4, 9, 16, 25]

示例2：

numbers_str = ['1', '2', '3', '4', '5']  # 可迭代对象
numbers_int = map(int, numbers_str)
print(list(numbers_int))    # [1, 2, 3, 4, 5]

示例3：

names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham']  # 可迭代对象

def change_to_upper(name):
    return name.upper()

names_upper_cased = map(change_to_upper, names)
print(list(names_upper_cased))    # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']

# 让我们使用 lambda 函数来应用它
names_upper_cased = map(lambda name: name.upper(), names)
print(list(names_upper_cased))    # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']

map 函数实际上是对列表进行迭代的操作。例如，将名称更改为大写并返回一个新列表。

Python 中的 filter 函数

Python 中的 filter 函数是将指定函数过滤输入可迭代对象中的每个项目（列表）。它会过滤满足过滤条件的项。

# 语法
filter(function, iterable)

示例1：

# 让我们筛选出仅为偶数的数字
numbers = [1, 2, 3, 4, 5]  # 可迭代对象

def is_even(num):
    if num % 2 == 0:
        return True
    return False

even_numbers = filter(is_even, numbers)
print(list(even_numbers))       # [2, 4]

Example:2

numbers = [1, 2, 3, 4, 5]  # 可迭代对象

def is_odd(num):
    if num % 2 != 0:
        return True
    return False

odd_numbers = filter(is_odd, numbers)
print(list(odd_numbers))       # [1, 3, 5]

# 选出长名字
names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham']  # 可迭代对象
def is_name_long(name):
    if len(name) > 7:
        return True
    return False

long_names = filter(is_name_long, names)
print(list(long_names))         # ['Asabeneh']

Python - Reduce 函数

reduce() 函数在 functools 模块中定义，我们需要从这个模块中导入它。与 map 和 filter 类似，它接受两个参数，一个函数和一个可迭代对象。但是，它不返回另一个可迭代对象，而是返回一个单独的值。

示例1：

numbers_str = ['1', '2', '3', '4', '5']  # iterable
def add_two_nums(x, y):
    return int(x) + int(y)

total = reduce(add_two_nums, numbers_str)
print(total)    # 15