A programming paradigm is the model or approach used to logically organize a program.

It defines how different parts of a program interact and work together.

A programming paradigm encompasses three key aspects:

• how the code is organized
• how the program’s behavior is modeled
• how data is manipulated

Paradigms

Let’s explore the main types of programming paradigms

Imperative Paradigm

This paradigm involves giving the computer explicit, step-by-step instructions using variables, loops, and conditional statements. Each instruction is executed sequentially.

Functional Paradigm

This approach uses pure functions as the core building blocks of program logic.

OOP Paradigm (Object-Oriented Programming)

This paradigm structures code around objects that combine data (attributes) with related behaviors (methods).

Declarative Paradigm

This approach focuses on describing what result you want to achieve, rather than specifying how to achieve it.

Logical Paradigm

This paradigm defines formal logical rules and facts, allowing the program to determine the solution path.

Paradigms in Python

Python is a multi-paradigm language, which means it supports different programming styles within the same program.

Python supports functional programming, sequential programming, and object-oriented programming.

These paradigms can be mixed within the same program—one of Python’s most valuable features. This flexibility allows programmers to choose the best approach for solving specific problems.

Functional Programming in Python

Functional programming is built upon the foundation of functions as first-class citizens in the programming environment. It particularly emphasizes three types of functions: pure functions, which maintain consistency by producing identical outputs for identical inputs; higher-order functions, which can accept other functions as parameters or return them as results; and lambda functions, which provide concise, anonymous function definitions. This paradigm places great importance on predictability and reliability in code execution—functions consistently deliver the same results when given the same inputs, making the code easier to test and debug. Additionally, functional programming strongly emphasizes the avoidance of side effects, meaning functions should not modify state outside their scope or cause observable interactions with the external environment beyond their return values.

Here’s an example of functional programming in Python:

numbers = [1, 2, 3, 4, 5]
doubled = map(lambda x: x * 2, numbers)
evens = filter(lambda x: x % 2 == 0, doubled)
total = sum(evens)
print(total)  # Output: 12 (getting only the doubled even numbers)

Sequential Programming in Python

In this type of programming model, also known as imperative programming, the programmer writes instructions that are executed in a linear, sequential manner. The program flow follows a clear, step-by-step progression where each instruction is processed one after another in the order they are written. This paradigm relies heavily on fundamental programming constructs such as variables for storing and manipulating data, loops for repeating operations, conditional statements for making decisions, and sequential execution of commands. This straightforward approach makes it particularly suitable for beginners and for solving problems that naturally follow a linear sequence of operations.

Here is an example of sequential programming in Python:

numbers = [1, 2, 3, 4, 5]
total = 0
for number in numbers:
    if number % 2 == 0:
        total += number * 2
print(total)  # Output: 12 (getting only the doubled even numbers)

Object-Oriented Programming in Python

Data and behavior are encapsulated within classes, which function as comprehensive templates or blueprints for creating objects. These classes define both the attributes (data) that objects can possess and the methods (behaviors) they can perform. When instances of these classes are created, they become concrete objects with their unique state and capabilities. The entire software application is then structured as an organized collection of these interacting objects, each responsible for managing its data and implementing specific functionalities. This approach promotes code reusability, maintainability, and a clear separation of concerns within the program structure.

Python fully supports object-oriented programming with all its core features: encapsulation, inheritance, polymorphism, and abstraction.

Here is an example of OOP programming in Python:

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

rectangle = Rectangle(5, 3)
print(rectangle.area())      # Output: 15
print(rectangle.perimeter()) # Output: 16

Let’s imagine we need to solve this programming problem: we have a list of numbers and we want to double each number, then keep only the even ones and finally sum them.

Let’s solve this problem with the three paradigms

1. Sequential/imperative

numbers = [1, 2, 3, 4, 5, 6]

# Double each number
doubled = []
for number in numbers:
    doubled.append(number * 2)

# Filter even numbers
evens = []
for number in doubled:
    if number % 2 == 0:
        evens.append(number)

# Sum the even numbers
total = 0
for number in evens:
    total += number

print(total)  # Output: 28

1. Functional

from functools import reduce

numbers = [1, 2, 3, 4, 5, 6]

# Double each number
doubled = map(lambda x: x * 2, numbers)

# Filter even numbers
evens = filter(lambda x: x % 2 == 0, doubled)

# Sum the even numbers
total = reduce(lambda x, y: x + y, evens)

print(total)  # Output: 28

1. OOP

class ProcessNumbers:
    def __init__(self, numbers):
        self.numbers = numbers

    def double(self):
        self.numbers = [x * 2 for x in self.numbers]

    def filter_even(self):
        self.numbers = [x for x in self.numbers if x % 2 == 0]

    def sum(self):
        return sum(self.numbers)

# Create an instance of the class
process = ProcessNumbers([1, 2, 3, 4, 5, 6])

# Apply the transformations
process.double()    # Double the numbers
process.filter_even()  # Filter only even numbers
total = process.sum() # Sum the remaining numbers

print(total)  # Output: 28

Now let’s look at a program where multiple paradigms are applied:

from functools import reduce

class Calculator:
    def __init__(self, numbers):
        self.numbers = numbers

    def sum_doubled_even(self):
        # Using functional functions (map, filter, reduce) in an OOP class
        doubled = map(lambda x: x * 2, self.numbers)
        evens = filter(lambda x: x % 2 == 0, doubled)
        return reduce(lambda x, y: x + y, evens, 0)

numbers = [1, 2, 3, 4, 5]
calculator = Calculator(numbers)
print(calculator.sum_doubled_even())  # Output: 12

Sequential programming provides a direct and easy-to-follow approach, making it ideal for small scripts and linear program flows. While functional programming offers concise syntax, it can be more challenging to read and understand. Object-oriented programming shines in complex, structured projects where code reuse is important. Python’s multi-paradigm nature allows developers to leverage the strengths of each approach based on their specific program requirements.