> For the complete documentation index, see [llms.txt](https://ali-abdullah-nasiri.gitbook.io/python/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ali-abdullah-nasiri.gitbook.io/python/chapter-zero-introductions/basic-concepts-of-programming/programming-paradigms.md).
# Programming paradigms
I will try to break it down into parts and give a simple explanation of each paradigm. This way you can understand what people are talking about when they say `OOP`, `functional`, or `declarative`.
### What is a programming paradigm?
Programming paradigms are like different styles of building and organizing computer programs. Just like there are different ways to write a story or paint a picture, programming paradigms provide different ways to write code.
Think of it this way: Imagine you have a set of building blocks, and you can use those blocks to create different structures. Each programming paradigm is like a different set of rules or instructions for how to use those blocks.
For example, one programming paradigm might say to build a program by giving step-by-step instructions, like a recipe. Another paradigm might say to organize the program around different objects, like building with Lego blocks. Yet another paradigm might focus on using functions or mathematical concepts to solve problems.
These paradigms provide guidelines for how to structure your code, what tools or techniques to use, and how to think about solving problems. They help programmers write code in a consistent and organized way.
Different programming paradigms have their own advantages and are suited to different types of problems. Some paradigms are good for organizing large projects, while others are better for solving specific types of problems. The choice of which paradigm to use depends on the problem you're trying to solve and personal preference.
In simple terms, programming paradigms are just different ways to approach writing code, like different styles of building or creating things.
### Popular Programming Paradigms
Now that we have introduced what programming paradigms are and are not, let's go through the most popular ones, explain their main characteristics, and compare them.
Popular programming paradigms
Keep in mind that this list is not complete. There are other programming paradigms that are not covered here, although I will cover the most popular and widely used ones.
### Imperative Programming
Imperative programming consists of sets of detailed instructions that are given to the computer to execute in a given order. It's called `imperative` because as programmers we dictate exactly what the computer has to do, in a very specific way.
Imperative programming focuses on describing *how* a program operates, step by step.
Say you want to bake a cake. Your imperative program to do this might look like this:
```
- Pour flour in a bowl
- Pour a couple eggs in the same bowl
- Pour some milk in the same bowl
- Mix the ingredients
- Pour the mix in a mold
- Cook for 35 minutes
- Let chill
```
Here's an example of imperative programming in Python:
```python
# Imperative Programming Example in Python
def calculate_sum(numbers):
# Initialize sum variable
sum = 0
# Iterate over each number in the list
for num in numbers:
# Add the number to the sum
sum += num
# Return the calculated sum
return sum
# Example usage
numbers_list = [1, 2, 3, 4, 5]
result = calculate_sum(numbers_list)
print("Sum:", result)
```
In this example, we have a function `calculate_sum` that takes a list of numbers as input and calculates their sum. The approach used here is imperative programming.
The function iterates over each number in the list using a `for` loop. Inside the loop, the current number is added to the `sum` variable. After iterating through all the numbers, the final sum is returned.
The example demonstrates the step-by-step process of calculating the sum, explicitly stating how to achieve the desired result. Imperative programming focuses on describing the exact sequence of operations and how to change the program's state to accomplish a specific task.
When you run this code, it will output the sum of the numbers in the list, which in this case is `15`.
### Procedural Programming
Procedural programming is an extension of imperative programming that incorporates the use of functions, which are also referred to as `procedures` or `subroutines`.
Following our cake example, procedural programming may look like this:
```
function pourIngredients() {
- Pour flour in a bowl
- Pour a couple eggs in the same bowl
- Pour some milk in the same bowl
}
function mixAndTransferToMold() {
- Mix the ingredients
- Pour the mix in a mold
}
function cookAndLetChill() {
- Cook for 35 minutes
- Let chill
}
pourIngredients()
mixAndTransferToMold()
cookAndLetChill()
```
Here's an example of procedural programming in Python:
```python
# Procedural Programming Example in Python
def calculate_sum(numbers):
# Initialize sum variable
sum = 0
# Iterate over each number in the list
for num in numbers:
# Add the number to the sum
sum += num
# Return the calculated sum
return sum
def calculate_average(numbers):
# Calculate the sum using the calculate_sum function
sum = calculate_sum(numbers)
# Calculate the average by dividing the sum by the number of elements
average = sum / len(numbers)
# Return the calculated average
return average
# Example usage
numbers_list = [1, 2, 3, 4, 5]
result = calculate_average(numbers_list)
print("Average:", result)
```
In this example, we have two functions: `calculate_sum` and `calculate_average`. These functions follow a procedural programming approach.
The `calculate_sum` function calculates the sum of a list of numbers using a `for` loop, similar to the imperative programming example. It iterates over each number in the list and adds it to the sum variable.
The `calculate_average` function utilizes the `calculate_sum` function to calculate the sum of the numbers. It then divides the sum by the length of the list to calculate the average.
The example demonstrates the use of functions or procedures to break down the problem into smaller, reusable parts. Procedural programming focuses on organizing code into procedures or routines that perform specific tasks.
When you run this code, it will output the average of the numbers in the list, which in this case is `3.0`.
### Object-Oriented Programming
One of the most popular programming paradigms is object-oriented programming (OOP).
The core concept of OOP is to separate concerns into entities which are coded as objects. Each entity will group a given set of information (properties) and actions (methods) that can be performed by the entity.
OOP makes heavy usage of classes (which are a way of creating new objects starting out from a blueprint or boilerplate that the programmer sets). Objects that are created from a class are called instances.
Following our pseudo-code cooking example, now let's say in our bakery we have a main cook (called Frank) and an assistant cook (called Anthony) and each of them will have certain responsibilities in the baking process. If we used OOP, our program might look like this.
```
// Create the two classes corresponding to each entity
class Cook {
constructor constructor (name) {
this.name = name
}
mixAndBake() {
- Mix the ingredients
- Pour the mix in a mold
- Cook for 35 minutes
}
}
class AssistantCook {
constructor (name) {
this.name = name
}
pourIngredients() {
- Pour flour in a bowl
- Pour a couple eggs in the same bowl
- Pour some milk in the same bowl
}
chillTheCake() {
- Let chill
}
}
// Instantiate an object from each class
const Frank = new Cook('Frank')
const Anthony = new AssistantCook('Anthony')
// Call the corresponding methods from each instance
Anthony.pourIngredients()
Frank.mixAndBake()
Anthony.chillTheCake()
```
Here's an example of object-oriented programming (OOP) in Python:
```python
# Object-Oriented Programming Example in Python
class Circle:
def __init__(self, radius):
self.radius = radius
def calculate_area(self):
# Calculate the area of the circle using the formula: pi * r^2
area = 3.14 * (self.radius ** 2)
return area
def calculate_circumference(self):
# Calculate the circumference of the circle using the formula: 2 * pi * r
circumference = 2 * 3.14 * self.radius
return circumference
# Example usage
circle1 = Circle(5)
area = circle1.calculate_area()
circumference = circle1.calculate_circumference()
print("Area:", area)
print("Circumference:", circumference)
```
In this example, we define a `Circle` class that represents a circle object. The class has attributes such as `radius`, and methods such as `calculate_area` and `calculate_circumference`.
The `__init__` method is a special method called a constructor, which is invoked when a new `Circle` object is created. It initializes the `radius` attribute with the given value.
The `calculate_area` method calculates the area of the circle using the formula `π * r^2`, where `r` is the radius. The `calculate_circumference` method calculates the circumference of the circle using the formula `2 * π * r`.
We create an instance of the `Circle` class called `circle1` with a radius of 5. We then call the `calculate_area` and `calculate_circumference` methods on `circle1` to calculate the area and circumference of the circle.
The example demonstrates the principles of encapsulation and abstraction in OOP, where data and methods are encapsulated within a class, and objects are created from the class to interact with the data and perform operations.
When you run this code, it will output the calculated area and circumference of the circle with a radius of 5.
### Declarative Programming
Declarative programming is a programming paradigm that focuses on describing what needs to be accomplished, rather than explicitly detailing how to achieve it. In declarative programming, you specify the desired result or outcome, and the programming language or framework takes care of the implementation details.
In declarative programming, you define a set of rules, constraints, or relationships, and the program's execution is driven by these declarations. It emphasizes expressing the logic of a program without specifying the control flow explicitly. This approach allows for a more concise and abstract representation of the problem domain.
Declarative programming is often contrasted with imperative programming, where the emphasis is on specifying the step-by-step instructions or commands that the computer needs to execute to solve a problem.
Some examples of declarative programming languages and frameworks include `SQL` for querying databases, regular expressions for pattern matching, Prolog for logic programming, and `HTML`/`CSS` for describing the structure and style of a web page.
Declarative programming can provide benefits such as increased readability, modularity, and maintainability. It allows developers to focus on the problem domain rather than low-level implementation details, which can lead to more efficient and concise code.
Here's a simple example of declarative programming in Python using list comprehensions:
```python
# Declarative Programming Example using List Comprehensions
# Imperative approach: filtering odd numbers from a list
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_numbers = []
for num in numbers:
if num % 2 != 0:
odd_numbers.append(num)
# Declarative approach: using list comprehension to filter odd numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_numbers = [num for num in numbers if num % 2 != 0]
print(odd_numbers)
```
In this example, we have a list of numbers and we want to filter out the odd numbers. Here's how the declarative approach using list comprehension works:
* We define `numbers` as the original list of numbers.
* We use a list comprehension (`[num for num in numbers if num % 2 != 0]`) to create a new list called `odd_numbers`.
* Inside the list comprehension, we iterate over each element `num` in the `numbers` list.
* The condition `if num % 2 != 0` filters out the even numbers, leaving only the odd numbers.
* The resulting list of odd numbers is assigned to the `odd_numbers` variable.
* Finally, we print the `odd_numbers` list, which contains the filtered odd numbers.
This example demonstrates the declarative approach of using list comprehensions to express the desired outcome (filtering odd numbers) without explicitly specifying the step-by-step instructions to achieve it. The code becomes more concise and readable, emphasizing the intent rather than the implementation details.
### Functional Programming
Functional programming takes the concept of functions a little bit further.
In functional programming, functions are treated as **first-class citizens**, meaning that they can be assigned to variables, passed as arguments, and returned from other functions.
Another key concept is the idea of **pure functions**. A **pure** function is one that relies only on its inputs to generate its result. And given the same input, it will always produce the same result. Besides, it produces no side effects (any change outside the function's environment).
With these concepts in mind, functional programming encourages programs written mostly with functions. It also defends the idea that code modularity and the absence of side effects makes it easier to identify and separate responsibilities within the codebase. This therefore improves the code maintainability.
Here's an example of functional programming in Python:
```python
# Functional Programming Example in Python
def calculate_sum(numbers):
# Use the built-in sum function to calculate the sum of the numbers
return sum(numbers)
def calculate_average(numbers):
# Calculate the sum using the calculate_sum function
sum = calculate_sum(numbers)
# Calculate the average by dividing the sum by the number of elements
average = sum / len(numbers)
# Return the calculated average
return average
# Example usage
numbers_list = [1, 2, 3, 4, 5]
result = calculate_average(numbers_list)
print("Average:", result)
```
In this example, we have two functions: `calculate_sum` and `calculate_average`. These functions follow a functional programming approach.
The `calculate_sum` function uses the built-in `sum` function in Python, which takes a sequence of numbers and returns their sum. It directly applies the sum function to the `numbers` list without using any loops or mutating variables.
The `calculate_average` function utilizes the `calculate_sum` function to calculate the sum of the numbers. It then divides the sum by the length of the list to calculate the average.
The example demonstrates the use of higher-order functions and immutability, which are key concepts in functional programming. Functional programming focuses on writing code that is composed of pure functions, avoids mutable state, and emphasizes immutability and higher-order functions.
When you run this code, it will output the average of the numbers in the list, which in this case is `3.0`.
### Conclusion
As we've seen, programming paradigms are different ways in which we can face programming problems, and organize our code.
Imperative, procedural, functional, declarative, and object oriented paradigms are some of the most popular and widely used paradigms today. And knowing the basics about them is good for general knowledge and also for better understanding other topics of the coding world.