Partial Functions in Python

Note#82

notes
Published

2023-05-02

Introduction

A partial function is a function derived from another function by fixing some of its arguments, effectively reducing the number of required arguments to call the new function. This can be useful for creating specialized versions of more general functions or preconfiguring a function with some arguments for later use. Python’s functools module provides the partial function to create partial functions.

Use Cases

  • Code reusability
  • Functional programming
  • Customizing callbacks

Examples

Basic Example

import functools

def add(x, y):
    return x + y

add_three = functools.partial(add, 3)

result = add_three(5)
print(result)
>>>
8

Using with Higher-Order Functions

import functools

def power(base, exponent):
    return base ** exponent

square = functools.partial(power, exponent=2)

numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(square, numbers))
print(squared_numbers)
>>>
[1, 4, 9, 16, 25]

Advantages

Readability

Partial functions can improve the readability of your code, especially when dealing with higher-order functions like map, filter, and reduce. By creating a partially-applied function, you can give it a meaningful name that makes the intent of your code clearer to readers. This can be particularly helpful when the function’s arguments are not immediately obvious or when the function is used multiple times with the same fixed arguments.

Code reusability

Creating partial functions allows you to reuse the same base function with different fixed arguments, which can lead to more modular and maintainable code. Instead of writing separate functions for each specialized case, you can have one general function and create partial functions for the specific cases. This can help prevent code duplication and make it easier to update or extend the base function.

Easier refactoring

In some cases, the original function may be part of a library or third-party code that you don’t have control over. By using partial functions, you can adapt the original function to your specific needs without modifying the original code. This can make it easier to refactor your code or switch to a different library or implementation in the future.

Customizing callbacks

When working with libraries or frameworks that expect you to provide a callback function, sometimes you need to supply additional arguments to the callback that aren’t provided by the library or framework itself. Partial functions allow you to preconfigure the callback with the necessary arguments while still satisfying the expected function signature.

Example

Here’s an example to illustrate how using partial functions can improve readability:

import functools

def multiply(a, b):
    return a * b

# Without using partial functions
doubled_numbers = list(map(lambda x: multiply(2, x), [1, 2, 3, 4, 5]))

# With partial functions
double = functools.partial(multiply, 2)
doubled_numbers = list(map(double, [1, 2, 3, 4, 5]))

# The output is the same: [2, 4, 6, 8, 10]

In this example, we have a multiply function that takes two arguments. Without using partial functions, we use a lambda expression to create an anonymous function that calls multiply with the first argument fixed as 2. This can be less readable, especially for more complex functions or when multiple arguments need to be fixed.

By using a partial function, we can create a new function called double that has a meaningful name and fixes the first argument of multiply to 2. This makes the code more readable and easier to understand.