Functional Programming

Functional Programming

Functional programming is a programming paradigm that emphasizes the use of pure functions to solve problems. In functional programming, functions are treated as first-class citizens and are used to compose larger solutions. In this blog post, we will explore functional programming concepts and how they can be applied in Python.

Pure functions
A pure function is a function that always returns the same output for the same input and does not have any side effects. A side effect is any modification of state that is visible outside of the function, such as modifying a global variable or printing to the console. Pure functions are easy to reason about, test and compose. Here’s an example of a pure function that computes the area of a circle:

import math

def circle_area(radius):
    return math.pi * radius ** 2

Higher-order functions
A higher-order function is a function that takes one or more functions as arguments or returns a function as its result. Higher-order functions allow us to abstract over patterns of computation and express complex operations in a concise and modular way. Here’s an example of a higher-order function that applies a function to each element of a list:

def map(func, lst):
    return [func(x) for x in lst]

We can use the map function to apply a function to each element of a list:

def square(x):
    return x ** 2
lst = [1, 2, 3, 4, 5]
squared_lst = map(square, lst)
print(squared_lst)  # [1, 4, 9, 16, 25]

Lambda functions
A lambda function is a small anonymous function that can be defined inline. Lambda functions are useful when we need to pass a simple function as an argument to a higher-order function without defining a separate function. Here’s an example of a lambda function that adds two numbers:

add = lambda x, y: x + y

We can use the lambda function with the map function to add two numbers:

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
added_lst = map(lambda x, y: x + y, lst1, lst2)
print(added_lst)  # [5, 7, 9]

Filtering
Filtering is a common operation in functional programming that selects elements from a collection based on a predicate. We can use the filter function to select elements from a list that satisfy a condition:

def is_even(x):
    return x % 2 == 0

lst = [1, 2, 3, 4, 5]
even_lst = filter(is_even, lst)
print(even_lst)  # [2, 4]

Reducing
Reducing is a common operation in functional programming that combines the elements of a collection into a single value. We can use the reduce function to apply a binary function to the elements of a collection in a cumulative way:

from functools import reduce

def add(x, y):
    return x + y

lst = [1, 2, 3, 4, 5]
sum_lst = reduce(add, lst)
print(sum_lst)  # 15