Partial Functions in Python

Last Updated : 21 Aug, 2024

Partial functions allow us to fix a certain number of arguments of a function and generate a new function. In this article, we will try to understand the concept of Partial Functions with different examples in Python.

What are Partial functions and the use of partial functions in Python?

Partial functions in Python is a function that is created by fixing a certain number of arguments of another function. Python provides a built-in module called functools that includes a function called partial that can be used to create partial functions. The partial function takes a callable (usually another function) and a series of arguments to be pre-filled in the new partial function. This feature is similar to bind in C++.

How do you implement a partial function in Python?

Partial functions support both positional and keyword arguments to be used as fixed arguments.

Example 1

In this example, we use default values to implement the partial function. The default values start replacing variables from the left. In the example, we have pre-filled our function with some constant values of a, b, and c. And g() just takes a single argument i.e. the variable x.

Python

from functools import partial

# A normal function
def f(a, b, c, x):
    return 1000*a + 100*b + 10*c + x

# A partial function that calls f with
# a as 3, b as 1 and c as 4.
g = partial(f, 3, 1, 4)

# Calling g()
print(g(5))

Output:

Example 2

In the example, we have used pre-defined value constant values in which we have assigned the values of c and b and add_part() takes a single argument i.e. the variable a.

Python

from functools import *

# A normal function
def add(a, b, c):
    return 100 * a + 10 * b + c

# A partial function with b = 1 and c = 2
add_part = partial(add, c = 2, b = 1)

# Calling partial function
print(add_part(3))

Output:

Uses of partial functions

Integration with Libraries: Partial functions can be used to customize the behavior of third-party functions or methods by providing partial arguments and can be used to integrate it with other libraries.
Simplifying Callbacks: Partial functions can be used to create specialized callback handlers by fixing some callback-specific parameters and providing a cleaner interface for the rest of the code.
Parameter Fixing: : Partial functions can be very useful when we have a function with multiple parameters and we frequently want to use it with some parameters fixed. Instead of repeatedly passing those fixed parameters, we can create a partial function and call it with the remaining arguments.
Reducing Duplication: If we are using the same arguments for a function in various places, creating a partial function with those fixed arguments can help to reduce code duplication and maintenance efforts.
Default Arguments: Python’s built-in functools.partial can be used to set default values for function arguments.
Reusability of code: Partial functions can be used to derive specialized functions from general functions and therefore help us to reuse our code.

Partial Functions in Python – FAQs

What is Partial Function of Function in Python?

In Python, a partial function from the functools module allows you to fix a certain number of arguments of a function and generate a new function. This is useful when you want to reduce the number of arguments to a function, pre-specifying some of them.

Example:
from functools import partial

def multiply(x, y):
    return x * y

# Create a new function that multiplies by 2
double = partial(multiply, 2)
print(double(4))  # Output: 8

What is the Difference Between a Full Function and a Partial Function?

A full function refers to a standard function that has not been modified or had any of its arguments pre-fixed. A partial function, on the other hand, is a version of a full function with some of its parameters fixed to certain values, thus requiring fewer arguments when called.

Example:
def full_function(x, y, z):
    return x + y + z

# Creating a partial function by fixing the first argument to 1
partial_function = partial(full_function, 1)

# The partial function only needs two more arguments instead of three
print(partial_function(2, 3))  # Output: 6

How Do Partials Work in Python?

Partials in Python work by using the partial function from the functools module to create a new function with some arguments of the original function fixed. This new function requires fewer arguments when called. The partial function effectively “remembers” the arguments you pass to it and combines them with those provided during subsequent calls.

What is the Difference Between Partial and Closure in `functools`?

Partial: A partial function is a function object that has some parameters fixed. It is specifically created to “freeze” some portion of a function’s arguments and keywords resulting in a new object.
Closure: In Python, a closure is not specifically an object from functools, but a technique where a function remembers the environment in which it was created. This means it can access variables that were in scope at the time of its creation, even after the outer function has finished executing.

What is a Partially Computable Function?

A partially computable function, in theoretical computer science, particularly in computability theory, refers to a function where there exists an algorithm that can provide an output for some inputs but might not halt or provide a result for others. This concept is related to Turing machines and the study of decidability and undecidability, where a partially computable function is computable on a subset of all possible inputs but not necessarily on all inputs.

These concepts help in understanding different types of function manipulations and theoretical aspects of functions in both practical programming and computer science theory.