Introduction to Currying and Partial Application in Python

Welcome to our lesson on "Introduction to Currying and Partial Application" in Python. Today, we’ll explore these functional programming techniques and understand their benefits. The goals for this lesson include grasping the concepts of currying and partial application and implementing them in Python.

Currying and partial application transform functions to be more modular and reusable. Understanding these techniques helps you write cleaner and more maintainable Python code.

Currying is a technique where a function is transformed into a sequence of functions, each with a single argument. Instead of a function taking multiple arguments, you have a series of functions, each taking one argument.

For example, consider a function add that takes two arguments, a and b, and returns their sum:

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

When we curry this function, it becomes:

def curried_add(a):
    return lambda b: a + b

Let's see currying in action with an example:

def curried_add(a):
    return lambda b: a + b

if __name__ == "__main__":
    # Create a function add5 which adds 5 to its argument
    add5 = curried_add(5)
    print(f"Currying: 5 + 3 = {add5(3)}")  # Outputs: Currying: 5 + 3 = 8

In the code above, curried_add takes an integer a and returns a lambda that takes another integer b. The function add5 is created by calling curried_add with 5, resulting in a function that adds 5 to its argument. Calling add5(3) adds 5 and 3, giving us 8. This method makes functions more modular and reusable.

Partial application is similar to currying but less strict. Instead of transforming a function to take a single argument at a time, you can fix a few arguments, creating a new function with fewer arguments.

For example, the same add function can be partially applied using functools.partial:

from functools import partial

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

if __name__ == "__main__":
    # Partially apply 'add' with the first argument as 5
    add5_partial = partial(add, 5)
    print(f"Partial Application: 5 + 3 = {add5_partial(3)}")  # Outputs: Partial Application: 5 + 3 = 8

In this code:

1. functools.partial creates a new function add5_partial where the first argument of add is fixed to 5.
2. The new function still requires one argument.
3. Calling add5_partial(3) adds 5 and 3, resulting in 8.

Partial application lets you pre-set arguments, making functions more adaptable and your code cleaner.