--- title: Programming Paradigms in Python date: 2024-12-08T10:37:48Z modified: 2026-07-22T08:58:44Z permalink: "https://www.micheledpierri.com/2024/12/08/programming-paradigms-in-python/" type: post status: publish excerpt: "" wpid: 942 categories: - Data Analysis - Programming tags: - Data Analysis - Programming - Python featured_image: "https://www.micheledpierri.com/wp-content/uploads/2024/12/paradigms_programmation_.png" featured_image_alt: Vintage sepia-toned illustration comparing sequential, functional, and object-oriented programming through three network diagrams above three differently structured trees in an antique educational poster style. timestamp: 2026-07-22T08:58:44Z --- 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) ``` 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) ``` 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 ``` 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 ``` 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 ``` 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 ``` 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 ``` 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.