Open In App

Function Composition in Python

Improve
Improve
Like Article
Like
Save
Share
Report

Prerequisite: reduce(), lambda

Function composition is the way of combining two or more functions in such a way that the output of one function becomes the input of the second function and so on. For example, let there be two functions “F” and “G” and their composition can be represented as F(G(x)) where “x” is the argument and output of G(x) function will become the input of F() function.

Example:




# Function to add 2 
# to a number
def add(x):
    return x + 2
  
# Function to multiply 
# 2 to a number
def multiply(x):
    return x * 2
  
# Printing the result of 
# composition of add and 
# multiply to add 2 to a number 
# and then multiply by 2
print("Adding 2 to 5 and multiplying the result with 2: "
      multiply(add(5)))


Output:

Adding 2 to 5 and multiplying the result with 2: 14

Explanation
First the add() function is called on input 5. The add() adds 2 to the input and the output which is 7, is given as the input to multiply() which multiplies it by 2 and the output is 14

Better way to implement composition

There is a better way to implement the composition of Function. We can create a special function which can combine any two functions.




# Function to combine two
# function which it accepts 
# as argument
def composite_function(f, g):
    return lambda x : f(g(x))
  
# Function to add 2
def add(x):
    return x + 2
  
# Function to multiply 2
def multiply(x):
    return x * 2
  
# Composite function returns
# a lambda function. Here add_multiply
# will store lambda x : multiply(add(x))
add_multiply = composite_function(multiply, add)
  
print("Adding 2 to 5 and multiplying the result with 2: ",
      add_multiply(5))


Output:

Adding 2 to 5 and multiplying the result with 2: 14

Composing N number of function
We can compose any number of function by modifying the above method.




# Function to combine two 
# function which it accepts
# as argument
def composite_function(f, g):
      
    return lambda x : f(g(x))
  
# Function to add 2
def add(x):
    return x + 2
  
# Function to multiply 2
def multiply(x):
    return x * 2
  
# Function to subtract 2
def subtract(x):
    return x - 1
  
# Composite function returns
# a lambda function. Here
# add_subtract_multiply will 
# store lambda x : multiply(subtract(add(x)))
add_subtract_multiply = composite_function(composite_function(multiply,
                                                              subtract), 
                                           add)
  
  
print("Adding 2 to 5, then subtracting 1 and multiplying the result with 2: ",
      add_subtract_multiply(5))


Output:

Adding 2 to 5, then subtracting 1 and multiplying the result with 2: 12

Now we will modify our composite_function to a function that can compose any number of function instead of two by using reduce() function from functools library.




# importing reduce() from functools
from functools import reduce
  
# composite_function accepts N
# number of function as an 
# argument and then compose them
def composite_function(*func):
      
    def compose(f, g):
        return lambda x : f(g(x))
              
    return reduce(compose, func, lambda x : x)
  
# Function to add 2
def add(x):
    return x + 2
  
# Function to multiply 2
def multiply(x):
    return x * 2
  
# Function to subtract 2
def subtract(x):
    return x - 1
  
# Here add_subtract_multiply will 
# store lambda x : multiply(subtract(add(x))) 
add_subtract_multiply = composite_function(multiply,
                                           subtract,
                                           add)
  
print("Adding 2 to 5, then subtracting 1 and multiplying the result with 2: "
      add_subtract_multiply(5))


Output:

Adding 2 to 5, then subtracting 1 and multiplying the result with 2: 12

Explanation
The reduce() function is taking first two function from *func and composing them using compose() and then composing the third function to the previous composed function and so on. Here the multiply() and subtract() is composed first (multiply(subtract(x)) and then add() is composed (multiply(subtract(add(x))).



Last Updated : 07 Aug, 2020
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads