Functional Programming

Functional programming is a programming paradigm where functions are treated as first-class objects. Python provides several functional programming features that help write concise, reusable, and expressive code.

Topics Covered

In this module, you’ll learn:

Functions as Objects
Functions as First-Class Objects
Passing Functions as Arguments
Returning Functions
Higher-Order Functions
Anonymous (Lambda) Functions
map()
filter()
reduce()
Functional Programming Best Practices

Try Yourself: 💻 VS Code | 🚀 Colab | 📥 Download
Verify Solutions: 💻 VS Code | 🚀 Colab | 📥 Download

By the end of this module, you’ll be able to treat functions as data, write reusable higher-order functions, use lambda expressions effectively, and apply Python’s built-in functional programming utilities.

Functions as Objects

In Python, everything is an object, including functions. This means a function can be:

Assigned to a variable
Passed as an argument
Returned from another function
Stored in a collection

Let’s begin by assigning a function to another variable.

def greet():
    print("Hello!")

message = greet

message()

Output ?

Show Output

Hello!

Notice that we assigned the function itself, not its return value.

message = greet

If we write

message = greet()

the function executes immediately and the return value is assigned to message.

Function References

Both variables refer to the same function object.

def greet():
    print("Hello!")

message = greet

print(greet is message)

Output ?

Show Output

True

The is operator confirms that both variables reference the same function object.

Exercise 1

Assign a function named welcome() to another variable and invoke it. Sample Input

welcome()

Expected Output

Welcome

Solution

def welcome():
    print("Welcome")

func = welcome

func()

Exercise 2

Create a function named display() and assign it to another variable named show. Invoke both variables. Sample Input

display()
show()

Expected Output

Python
Python

Solution

def display():
    print("Python")

show = display

display()
show()

Functions as First-Class Objects

A programming language is said to support first-class functions if functions can be treated just like any other object. Since Python functions are objects, they can:

Be assigned to variables
Be stored in collections
Be passed as arguments
Be returned from functions

For example, functions can even be stored inside a list.

def add():
    print("Add")

def subtract():
    print("Subtract")

operations = [add, subtract]

operations[0]()
operations[1]()

Output ?

Show Output

Add
Subtract

Functions can also be stored in dictionaries.

def greet():
    print("Hello")

def bye():
    print("Good Bye")

messages = {
    "hello": greet,
    "bye": bye
}

messages["hello"]()
messages["bye"]()

Output ?

Show Output

Hello
Good Bye

Exercise 1

Store two functions in a list and invoke each function. Sample Input

operations[0]()
operations[1]()

Expected Output

Start
Stop

Solution

def start():
    print("Start")

def stop():
    print("Stop")

operations = [start, stop]

operations[0]()
operations[1]()

Exercise 2

Store functions inside a dictionary and invoke them using keys. Sample Input

actions["open"]()

Expected Output

Open File

Solution

def open_file():
    print("Open File")

def close_file():
    print("Close File")

actions = {
    "open": open_file,
    "close": close_file
}

actions["open"]()

Passing Functions as Arguments

Since functions are objects, they can be passed as arguments to other functions.

def greet():
    print("Hello!")

def execute(task):
    task()

execute(greet)

Output ?

Show Output

Hello!

Notice that we pass the function without parentheses.

execute(greet)

If we write

execute(greet())

the function executes first, and its return value is passed instead. Passing functions as arguments makes code more flexible and reusable.

Exercise 1

Create a function welcome() and pass it to another function named run(). Sample Input

run(welcome)

Expected Output

Welcome

Solution

def welcome():
    print("Welcome")

def run(task):
    task()

run(welcome)

Exercise 2

Create two greeting functions and execute each by passing it to another function. Sample Input

execute(hello)
execute(goodbye)

Expected Output

Hello
Good Bye

Solution

def hello():
    print("Hello")

def goodbye():
    print("Good Bye")

def execute(task):
    task()

execute(hello)
execute(goodbye)

Returning Functions

Functions can also return other functions.

def outer():

    def inner():
        print("Hello!")

    return inner

greet = outer()

greet()

Output ?

Show Output

Hello!

The returned function can be stored in a variable and executed later. This capability forms the foundation for higher-order functions, closures, and decorators.

Exercise 1

Create a function that returns another function displaying "Python". Sample Input

func = outer()

func()

Expected Output

Python

Solution

def outer():

    def inner():
        print("Python")

    return inner

func = outer()

func()

Exercise 2

Create a function that returns another function displaying "Functional Programming". Sample Input

func = create()

func()

Expected Output

Functional Programming

Solution

def create():

    def display():
        print("Functional Programming")

    return display

func = create()

func()

Higher-Order Functions

A higher-order function is a function that does at least one of the following:

Accepts one or more functions as arguments.
Returns a function.

Since Python functions are first-class objects, creating higher-order functions is straightforward.

Accepting a Function as an Argument

def greet():
    print("Hello!")

def execute(task):
    print("Starting...")
    task()
    print("Completed.")

execute(greet)

Output ?

Show Output

Starting...
Hello!
Completed.

Here, execute() is a higher-order function because it accepts another function as an argument.

Returning a Function

A higher-order function can also return another function.

def greeting():

    def greet():
        print("Hello!")

    return greet

message = greeting()

message()

Output ?

Show Output

Hello!

Why Higher-Order Functions?

Higher-order functions help:

Eliminate duplicate code.
Improve code reusability.
Separate behavior from implementation.
Build flexible and extensible programs.

They are widely used in Python libraries and frameworks.

Exercise 1

Create a higher-order function that accepts a function and executes it. Sample Input

run(display)

Expected Output

Python

Solution

def display():
    print("Python")

def run(task):
    task()

run(display)

Exercise 2

Create a higher-order function that returns a function displaying "Welcome". Sample Input

message = create()

message()

Expected Output

Welcome

Solution

def create():

    def welcome():
        print("Welcome")

    return welcome

message = create()

message()

Anonymous (Lambda) Functions

Sometimes a function is needed only once. Instead of defining a function using def, Python provides lambda functions, also known as anonymous functions.

Using a Regular Function

def square(number):
    return number ** 2

print(square(5))

Output ?

Show Output

Using a Lambda Function

square = lambda number: number ** 2

print(square(5))

Output ?

Show Output

The general syntax is:

lambda parameters: expression

A lambda function:

Can have any number of parameters.
Contains only one expression.
Automatically returns the result of the expression.

Multiple Parameters

multiply = lambda a, b: a * b

print(multiply(10, 20))

Output ?

Show Output

Using Conditional Expressions

maximum = lambda a, b: a if a > b else b

print(maximum(10, 25))

Output ?

Show Output

When Should You Use Lambda Functions?

Lambda functions are useful when:

The function is short.
The function is used only once.
Passing functions to map(), filter(), or sorted().

For complex logic, prefer a normal function using def.

Exercise 1

Create a lambda function that returns the cube of a number. Sample Input

cube(3)

Expected Output

Solution

cube = lambda number: number ** 3

print(cube(3))

Exercise 2

Create a lambda function that returns the smaller of two numbers. Sample Input

minimum(12, 5)

Expected Output

Solution

minimum = lambda a, b: a if a < b else b

print(minimum(12, 5))

Lambda Functions with Built-in Functions

Lambda functions become particularly useful when combined with Python’s built-in functional programming functions. The three most commonly used functions are:

map()
filter()
reduce()

These functions allow data to be transformed, filtered, and aggregated without writing explicit loops. In the following sections, you’ll learn how each of these functions works and when to use them.

Higher-Order Functions

A higher-order function is a function that either:

Accepts one or more functions as arguments.
Returns a function.

Higher-order functions make code more flexible and reusable by separating behavior from implementation.

Passing Functions as Arguments

def send_email(name):
    print(f"Email sent to {name}")

def notify(customer, action):
    action(customer)

notify("Alice", send_email)

Output ?

Show Output

Email sent to Alice

The notify() function is a higher-order function because it accepts another function as an argument.

Returning Functions

def get_discount(discount):

    def apply(price):
        return price - (price * discount / 100)

    return apply

festival_offer = get_discount(20)

print(festival_offer(1000))

Output ?

Show Output

800.0

Higher-order functions are widely used in web frameworks, event handling, decorators, and callback functions.

Exercise 1

Create a higher-order function that accepts a greeting function and a person’s name. Sample Input

notify("John", greet)

Expected Output

Welcome John

Solution

def greet(name):
    print(f"Welcome {name}")

def notify(name, action):
    action(name)

notify("John", greet)

Exercise 2

Create a function that returns another function to calculate a discount. Sample Input

discount = create_discount(15)

print(discount(1000))

Expected Output

850.0

Solution

def create_discount(percent):

    def apply(price):
        return price - (price * percent / 100)

    return apply

discount = create_discount(15)

print(discount(1000))

Anonymous (Lambda) Functions

A lambda function is a small anonymous function consisting of a single expression. Instead of writing

def square(number):
    return number ** 2

we can write

square = lambda number: number ** 2

print(square(5))

Output ?

Show Output

Multiple Parameters

total = lambda price, quantity: price * quantity

print(total(250, 4))

Output ?

Show Output

Conditional Expression

status = lambda marks: "Pass" if marks >= 40 else "Fail"

print(status(72))

Output ?

Show Output

Pass

When Should You Use Lambda Functions?

Use lambda functions when:

The function is small.
It is used only once.
It is passed to another function such as map(), filter(), or sorted().

For complex logic, prefer a regular function.

Exercise 1

Create a lambda function that calculates the area of a rectangle. Sample Input

area(20, 15)

Expected Output

Solution

area = lambda length, width: length * width

print(area(20, 15))

Exercise 2

Create a lambda function that returns "Eligible" if age is at least 18; otherwise, return "Not Eligible". Sample Input

check(16)

Expected Output

Not Eligible

Solution

check = lambda age: "Eligible" if age >= 18 else "Not Eligible"

print(check(16))

The `map()` Function

The map() function applies a function to every element of an iterable and returns an iterator.

Traditional Approach

Suppose we want to apply a 10% discount to all product prices.

prices = [500, 1200, 800, 1500]

discounted = []

for price in prices:
    discounted.append(price * 0.9)

print(discounted)

Output ?

Show Output

[450.0, 1080.0, 720.0, 1350.0]

Using `map()`

prices = [500, 1200, 800, 1500]

discounted = list(
    map(lambda price: price * 0.9, prices)
)

print(discounted)

Output ?

Show Output

[450.0, 1080.0, 720.0, 1350.0]

Another Example

Convert employee names to uppercase.

employees = [
    "Alice",
    "Bob",
    "Charlie"
]

result = list(
    map(lambda name: name.upper(), employees)
)

print(result)

Output ?

Show Output

['ALICE', 'BOB', 'CHARLIE']

Exercise 1

Convert all city names to title case. Sample Input

cities = ["hyderabad", "chennai", "mumbai"]

Expected Output

['Hyderabad', 'Chennai', 'Mumbai']

Solution

cities = ["hyderabad", "chennai", "mumbai"]

result = list(
    map(lambda city: city.title(), cities)
)

print(result)

Exercise 2

Add 18% GST to every product price. Sample Input

prices = [100, 250, 500]

Expected Output

[118.0, 295.0, 590.0]

Solution

prices = [100, 250, 500]

result = list(
    map(lambda price: price * 1.18, prices)
)

print(result)

The `filter()` Function

The filter() function selects only those elements that satisfy a condition.

Traditional Approach

Suppose we want to display only students who passed.

marks = [35, 82, 65, 28, 91, 42]

passed = []

for mark in marks:
    if mark >= 40:
        passed.append(mark)

print(passed)

Output ?

Show Output

[82, 65, 91, 42]

Using `filter()`

marks = [35, 82, 65, 28, 91, 42]

passed = list(
    filter(lambda mark: mark >= 40, marks)
)

print(passed)

Output ?

Show Output

[82, 65, 91, 42]

Another Example

Filter premium products costing more than ₹1000.

prices = [450, 1200, 350, 2500, 800]

premium = list(
    filter(lambda price: price >= 1000, prices)
)

print(premium)

Output ?

Show Output

[1200, 2500]

Exercise 1

Filter employees earning more than ₹50,000. Sample Input

salaries = [30000, 55000, 48000, 72000]

Expected Output

[55000, 72000]

Solution

salaries = [30000, 55000, 48000, 72000]

result = list(
    filter(lambda salary: salary > 50000, salaries)
)

print(result)

Exercise 2

Filter words having more than five characters. Sample Input

words = ["cat", "python", "java", "database"]

Expected Output

['python', 'database']

Solution

words = ["cat", "python", "java", "database"]

result = list(
    filter(lambda word: len(word) > 5, words)
)

print(result)

The `reduce()` Function

The reduce() function repeatedly applies a function to the elements of an iterable and reduces them to a single value. Unlike map() and filter(), which return iterators, reduce() produces a single result. The reduce() function is available in the functools module.

from functools import reduce

Traditional Approach

Suppose we want to calculate the total amount of items in a shopping cart.

cart = [450, 1200, 350, 800]

total = 0

for price in cart:
    total += price

print(total)

Output ?

Show Output

Using `reduce()`

from functools import reduce

cart = [450, 1200, 350, 800]

total = reduce(
    lambda x, y: x + y,
    cart
)

print(total)

Output ?

Show Output

Another Example

Find the highest employee salary.

from functools import reduce

salaries = [25000, 42000, 51000, 39000]

highest = reduce(
    lambda x, y: x if x > y else y,
    salaries
)

print(highest)

Output ?

Show Output

Exercise 1

Calculate the total quantity of products sold. Sample Input

quantities = [5, 8, 12, 10]

Expected Output

Solution

from functools import reduce

quantities = [5, 8, 12, 10]

total = reduce(
    lambda x, y: x + y,
    quantities
)

print(total)

Exercise 2

Find the minimum salary. Sample Input

salaries = [45000, 28000, 52000, 36000]

Expected Output

Solution

from functools import reduce

salaries = [45000, 28000, 52000, 36000]

minimum = reduce(
    lambda x, y: x if x < y else y,
    salaries
)

print(minimum)

Combining `map()`, `filter()`, and `reduce()`

In real-world applications, these functions are often combined to process data in multiple stages. Suppose a company wants to:

Increase every employee’s salary by 10%.
Consider only employees earning more than ₹50,000 after the increment.
Calculate the total payroll of those employees.

from functools import reduce

salaries = [35000, 48000, 55000, 62000, 40000]

updated = map(
    lambda salary: salary * 1.10,
    salaries
)

high_salary = filter(
    lambda salary: salary > 50000,
    updated
)

payroll = reduce(
    lambda total, salary: total + salary,
    high_salary
)

print(payroll)

Output ?

Show Output

181500.0

Processing Pipeline

Employee Salaries
        │
        ▼
map()
Increase by 10%
        │
        ▼
filter()
Salary > ₹50,000
        │
        ▼
reduce()
Total Payroll

Each function performs a specific task:

map() transforms every element.
filter() selects only the required elements.
reduce() combines all elements into a single result.

Comprehensive Exercise 1

Given the marks of students,

marks = [35, 82, 61, 28, 90, 75]

Perform the following operations:

Add 5 grace marks to every student.
Keep only students scoring 40 or above.
Calculate the total marks.

Expected Output

Solution

from functools import reduce

marks = [35, 82, 61, 28, 90, 75]

updated_marks = map(
    lambda mark: min(mark + 5, 100),
    marks
)

passed_students = filter(
    lambda mark: mark >= 40,
    updated_marks
)

total_marks = reduce(
    lambda x, y: x + y,
    passed_students
)

print(total_marks)

Comprehensive Exercise 2

Given the prices of products,

prices = [500, 1200, 350, 2500, 800]

Perform the following operations:

Apply a 10% discount to every product.
Keep only products costing more than ₹1000 after the discount.
Calculate the final bill.

Expected Output

3330.0

Solution

from functools import reduce

prices = [500, 1200, 350, 2500, 800]

discounted_prices = map(
    lambda price: price * 0.90,
    prices
)

premium_products = filter(
    lambda price: price > 1000,
    discounted_prices
)

final_bill = reduce(
    lambda x, y: x + y,
    premium_products
)

print(final_bill)

Comprehensive Exercise 3

Given the employee names,

employees = [
    "alice",
    "bob",
    "charlie",
    "david",
    "franklin"
]

Perform the following operations:

Convert all names to uppercase.
Keep only names having more than 5 characters.
Join them into a comma-separated string.

Expected Output

CHARLIE, FRANKLIN

Solution

from functools import reduce

employees = [
    "alice",
    "bob",
    "charlie",
    "david",
    "franklin"
]

uppercase_names = map(
    lambda name: name.upper(),
    employees
)

filtered_names = filter(
    lambda name: len(name) > 5,
    uppercase_names
)

result = reduce(
    lambda x, y: x + ", " + y,
    filtered_names
)

print(result)

Choosing the Right Function

Function	Purpose	Returns
`map()`	Transform every element	Iterator
`filter()`	Select elements matching a condition	Iterator
`reduce()`	Combine elements into a single value	Single Value