Python 30天：第 14 天 -- 高阶函数

<< 第 13 天 || 第 15 天 >>

第 14 天

高阶函数

在 Python 中，函数被视为一等公民，允许您对函数执行以下操作：

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

在本节中，我们将介绍：

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

作为参数的函数 

def sum_numbers(nums):  # normal function
    return sum(nums)    # a sad function abusing the built-in sum function :<

def higher_order_function(f, lst):  # function as a parameter
    summation = f(lst)
    return summation
result = higher_order_function(sum_numbers, [1, 2, 3, 4, 5])
print(result)       # 15

作为返回值的函数

def square(x):          # a square function
    return x ** 2

def cube(x):            # a cube function
    return x ** 3

def absolute(x):        # an absolute value function
    if x >= 0:
        return x
    else:
        return -(x)

def higher_order_function(type): # a higher order function returning a function
    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 中的一种设计模式，允许用户在不修改其结构的情况下向现有对象添加新功能。装饰器通常在定义要装饰的函数之前调用。

创建装饰器

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

例子：

# Normal function
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

## Let us implement the example above with a decorator

'''This decorator function is a higher order function
that takes a function as a parameter'''
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

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

'''These decorator functions are higher order functions
that take functions as parameters'''

# First Decorator
def uppercase_decorator(function):
    def wrapper():
        func = function()
        make_uppercase = func.upper()
        return make_uppercase
    return wrapper

# Second decorator
def split_string_decorator(function):
    def wrapper():
        func = function()
        splitted_string = func.split()
        return splitted_string

    return wrapper

@split_string_decorator
@uppercase_decorator     # order with decorators is important in this case - .upper() function does not work with lists
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 函数可以作为参数传递，lambda 函数的最佳用例是在 map、filter 和 reduce 等函数中。

Python - map 功能

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

    # syntax
    map(function, iterable)

例子：1

numbers = [1, 2, 3, 4, 5] # iterable
def square(x):
    return x ** 2
numbers_squared = map(square, numbers)
print(list(numbers_squared))    # [1, 4, 9, 16, 25]
# Lets apply it with a lambda function
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']  # iterable
numbers_int = map(int, numbers_str)
print(list(numbers_int))    # [1, 2, 3, 4, 5]

例子：3

names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham']  # iterable

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']

# Let us apply it with a lambda function
names_upper_cased = map(lambda name: name.upper(), names)
print(list(names_upper_cased))    # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']

实际上 map 所做的是遍历列表。例如，它将名称更改为大写并返回一个新列表。

Python - 过滤函数

filter() 函数调用指定的函数，该函数为指定的可迭代（列表）的每个项目返回布尔值。它过滤满足过滤条件的项目。

    # syntax
    filter(function, iterable)

例子：1

# Lets filter only even nubers
numbers = [1, 2, 3, 4, 5]  # iterable

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

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

例子：2

numbers = [1, 2, 3, 4, 5]  # iterable

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]

# Filter long name
names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham']  # iterable
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 ()函数在 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

练习： 第 14 天

countries = ['Estonia', 'Finland', 'Sweden', 'Denmark', 'Norway', 'Iceland']
names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham']
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

练习：1级

1. 解释 map、filter 和 reduce 之间的区别。
2. 解释高阶函数、闭包和装饰器的区别
3. 在 map、filter 或 reduce 之前定义调用函数，参见示例。
4. 使用 for 循环打印国家列表中的每个国家。
5. 使用 for 打印名称列表中的每个名称。
6. 使用 for 打印数字列表中的每个数字。

练习： 2级 

1. 使用地图通过将国家列表中的每个国家更改为大写来创建新列表
2. 使用地图通过将每个数字更改为其在数字列表中的正方形来创建新列表
3. 使用 map 将名称列表中的每个名称更改为大写
4. 使用过滤器过滤掉包含“土地”的国家。
5. 使用 filter 过滤掉恰好有六个字符的国家。
6. 使用过滤器过滤掉国家列表中包含六个字母及更多字母的国家。
7. 使用过滤器过滤掉以“E”开头的国家
8. 链接两个或多个列表迭代器（例如 arr.map(callback).filter(callback).reduce(callback)）
9. 声明一个名为 get_string_lists 的函数，它将一个列表作为参数，然后返回一个仅包含字符串项的列表。
10. 使用 reduce 对数字列表中的所有数字求和。
11. 使用 reduce 连接所有国家并产生这句话：爱沙尼亚、芬兰、瑞典、丹麦、挪威和冰岛是北欧国家
12. 创建一个返回字典的函数，其中键代表国家/地区的起始字母，值是以该字母开头的国家/地区名称的数量。
13. 声明一个 get_first_ten_countries 函数 - 它从数据文件夹中的 countries.js 列表中返回前十个国家的列表。
14. 声明一个 get_last_ten_countries 函数，返回国家列表中的最后十个国家。

🎉恭喜！🎉

<< 第 13 天 || 第 15 天 >>