Python 简明教程

Python - Higher Order Functions

Python 中的高阶函数允许你操作函数，以提高代码的灵活性和可重用性。你可以使用嵌套范围或可调用对象来创建高阶函数。

Higher-order functions in Python allows you to manipulate functions for increasing the flexibility and re-usability of your code. You can create higher-order functions using nested scopes or callable objects.

此外， functools 模块提供了与高阶函数一起使用的实用程序，使其更容易创建装饰器和其他函数操作构造。本教程将探讨 Python 中高阶函数的概念，并演示如何创建它们。

Additionally, the functools module provides utilities for working with higher-order functions, making it easier to create decorators and other function-manipulating constructs. This tutorial will explore the concept of higher-order functions in Python and demonstrate how to create them.

What is a Higher-Order Function?

高阶函数是一种函数，它或者将一个或多个函数作为参数，或者将函数作为其结果返回。下面你可以观察到 Python 中高阶函数的一些属性： −

A higher-order function is a function that either, takes one or more functions as arguments or returns a function as its result. Below you can observe the some of the properties of the higher-order function in Python −

  1. A function can be stored in a variable.

  2. A function can be passed as a parameter to another function.

  3. A high order functions can be stored in the form of lists, hash tables, etc.

  4. Function can be returned from a function.

要使用 Python 创建高阶函数，你可以使用嵌套范围或可调用对象。下面我们将简要讨论它们。

To create higher-order function in Python you can use nested scopes or callable objects. Below we will discuss about them briefly.

Creating Higher Order Function with Nested Scopes

在 Python 中定义高阶函数的一种方法是使用嵌套范围。这涉及在另一个函数内定义一个函数并返回内层函数。

One way to defining a higher-order function in Python is by using nested scopes. This involves defining a function within another function and returns the inner function.

Example

我们观察一下以下创建 Python 高阶函数的示例。在这个示例中， multiplier 函数需要一个参数 a，并返回另一个函数 multiply，用于计算值 a * b

Let’s observe following example for creating a higher order function in Python. In this example, the multiplier function takes one argument, a, and returns another function multiply, which calculates the value a * b

def multiplier(a):
   # Nested function with second number
   def multiply(b):
      # Multiplication of two numbers
      return a * b
   return multiply

# Assigning nested multiply function to a variable
multiply_second_number = multiplier(5)
# Using variable as high order function
Result = multiply_second_number(10)
# Printing result
print("Multiplication of Two numbers is: ", Result)

Output

通过执行以上的程序，你会得到以下结果：

On executing the above program, you will get the following results −

Multiplication of Two numbers is:  50

Creating Higher-Order Functions with Callable Objects

创建高阶函数的另一种方法是使用可调用对象。这涉及定义一个具有 call 方法的类。

Another approach to create higher-order functions is by using callable objects. This involves defining a class with a call method.

Example

以下是创建高阶函数的另一种方法，即使用可调用对象。

Here is the another approach to creating higher-order functions is using callable objects.

class Multiplier:
   def __init__(self, factor):
      self.factor = factor

   def __call__(self, x):
      return self.factor * x

# Create an instance of the Multiplier class
multiply_second_number = Multiplier(2)

# Call the  Multiplier object to computes factor * x
Result = multiply_second_number(100)

# Printing result
print("Multiplication of Two numbers is: ", Result)

Output

通过执行以上的程序，你会得到以下结果：

On executing the above program, you will get the following results −

Multiplication of Two numbers is:  200

Higher-order functions with the 'functools' Module

functools 模块提供对其他函数执行操作或返回其他函数的高阶函数。任何可调用对象都可以视为本模块的一个函数。

The functools module provides higher-order functions that act on or return other functions. Any callable object can be treated as a function for the purposes of this module.

Working with Higher-order functions using the wraps()

在这个示例中， my_decorator 是一个高阶函数，它使用 functools.wraps() 函数修改 invite 函数的行为。

In this example, my_decorator is a higher-order function that modifies the behavior of invite function using the functools.wraps() function.

import functools

def my_decorator(f):
   @functools.wraps(f)
   def wrapper(*args, **kwargs):
      print("Calling", f.__name__)
      return f(*args, **kwargs)
   return wrapper

@my_decorator
def invite(name):
   print(f"Welcome to, {name}!")

invite("Tutorialspoint")

Output

通过执行以上的程序，你会得到以下结果：

On executing the above program, you will get the following results −

Calling invite
Welcome to, Tutorialspoint!

Working with Higher-order functions using the partial()

functools 模块的 partial() 函数用于创建一个可调用的“部分”对象。这个对象本身的行为像一个函数。 partial() 函数接收另一个函数作为参数，并冻结函数部分参数，从而产生一个具有简化签名的新对象。

The partial() function of the functools module is used to create a callable 'partial' object. This object itself behaves like a function. The partial() function receives another function as argument and freezes some portion of a function’s arguments resulting in a new object with a simplified signature.

Example

在下面的示例中，用户定义的函数 myfunction() 用作部分函数的参数，方法是在原始函数的参数之一上设置默认值。

In following example, a user defined function myfunction() is used as argument to a partial function by setting default value on one of the arguments of original function.

import functools
def myfunction(a,b):
   return a*b

partfunction = functools.partial(myfunction,b = 10)
print(partfunction(10))

Output

通过执行以上的程序，你会得到以下结果：

On executing the above program, you will get the following results −

100

Working with Higher-order functions using the reduce()

与上述方法类似， functools 模块提供了 reduce() 函数，该函数接收两个参数，即函数和可迭代对象。并且，它返回一个单一的值。参数函数累积应用于列表中的两个参数，从左到右。函数在第一次调用中的结果成为第一个参数，列表中的第三个项成为第二个参数。如此重复，直至用完列表中项。

Similar to the above approach the functools module provides the reduce() function, that receives two arguments, a function and an iterable. And, it returns a single value. The argument function is applied cumulatively two arguments in the list from left to right. Result of the function in first call becomes first argument and third item in list becomes second. This is repeated till list is exhausted.

Example

import functools
def mult(x,y):
   return x*y

# Define a number to calculate factorial
n = 4
num = functools.reduce(mult, range(1, n+1))
print (f'Factorial of {n}: ',num)

Output

通过执行以上的程序，你会得到以下结果：

On executing the above program, you will get the following results −

Factorial of 4:  24