Python functools.partial Function

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The functools.partial function in Python's functools module allows you to fix a certain number of arguments of a function and generate a new function. This is useful for creating specialized versions of general-purpose functions.

Table of Contents

1. Introduction
2. functools.partial Function Syntax
3. Examples
   • Basic Usage
   • Using with Positional Arguments
   • Using with Keyword Arguments
   • Combining with Other Functions
4. Real-World Use Case
5. Conclusion

Introduction

The functools.partial function helps in creating new functions with some of the arguments of the original function fixed. This is particularly useful when you need to repeatedly call a function with some common arguments.

functools.partial Function Syntax

Here is how you use the functools.partial function:

import functools

partial_function = functools.partial(func, /, *args, **keywords)

Parameters:

• func: The original function you want to partially apply arguments to.
• *args: The positional arguments to be fixed.
• **keywords: The keyword arguments to be fixed.

Returns:

• A new function with some arguments of the original function fixed.

Examples

Basic Usage

Fix a few arguments of a simple function.

Example

import functools

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

# Create a new function that multiplies any number by 2
double = functools.partial(multiply, 2)

print(double(5))  # Output: 10
print(double(10)) # Output: 20

Using with Positional Arguments

Fix the first argument of a function.

Example

import functools

def add(a, b, c):
    return a + b + c

# Create a new function that always adds 10 as the first argument
add_ten = functools.partial(add, 10)

print(add_ten(20, 30))  # Output: 60
print(add_ten(5, 15))   # Output: 30

Using with Keyword Arguments

Fix keyword arguments of a function.

Example

import functools

def greet(greeting, name):
    return f"{greeting}, {name}!"

# Create a new function that always uses "Hello" as the greeting
say_hello = functools.partial(greet, greeting="Hello")

print(say_hello("Alice"))  # Output: Hello, Alice!
print(say_hello("Bob"))    # Output: Hello, Bob!

Combining with Other Functions

Use partial to fix arguments in combination with other functions.

Example

import functools

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

# Create a new function that always squares the number
square = functools.partial(power, exponent=2)

print(square(4))  # Output: 16
print(square(5))  # Output: 25

Real-World Use Case

Configuring Logger

Configure a logger with a fixed format.

Example

import functools
import logging

def configure_logger(name, level, format):
    logger = logging.getLogger(name)
    handler = logging.StreamHandler()
    formatter = logging.Formatter(format)
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    logger.setLevel(level)
    return logger

# Create a new function that always uses INFO level and a specific format
info_logger = functools.partial(configure_logger, level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

logger = info_logger('my_logger')
logger.info('This is an info message')

Conclusion

The functools.partial function is used for creating specialized versions of functions by fixing some of their arguments. It enhances code reusability and readability, especially when working with functions that require certain arguments to be fixed across multiple calls. Proper usage can lead to more concise and maintainable code.