Procedural vs Object-Oriented Programming in Python

Python is a versatile language that supports multiple programming paradigms, including Object-Oriented programming and Procedural Programming. Each of the programming paradigms adopts a unique method for instructing code and managing the data.

Understanding the difference between these two paradigms is very important for writing efficient, maintainable, and scalable code. This guide, “Procedural vs Object-Oriented Programming in Python” looks at both programming styles. It explains their advantages, disadvantages, and best use cases.

What is Procedural Programming?

The Procedural Programming paradigm is a structured approach to coding where instructions are executed sequentially. This approach is based on functions that perform specific tasks, making the code straightforward to follow.

Features of Procedural Programming

• Function-based Structure: Code is divided into reusable functions, each handling a specific operation.
• Top-Down Approach: Procedural Programming executes the program step-by-step, following a structured flow.
• Global and Local Variable: Data is mostly stored in global variables, which can be accessed and modified by functions.
• Tight Coupling: Functions may directly depend on each other, leading to challenges in modification and maintenance.
• Readability: Easier to understand and implement, making it a good choice for beginners and small projects.

Example of Procedural Programming in Python

# Procedural Programming Example in Python

def calculate_area(length, width):
    return length * width

def main():
    length = 10
    width = 5
    area = calculate_area(length, width)
    print(f"Area: {area}")

main()

What is Object-Oriented Programming (OOP)?

Object-oriented programming is a widely used paradigm based on objects and classes. Objects are instances of classes that encapsulate data(attributes) and behavior (methods), promoting code reusability and flexibility by modeling hierarchical relationships.

Features of Object-Oriented Programming

• Encapsulation: Data and methods that operate on the data are grouped within objects, restricting direct access to some details.
• Abstraction: Exposing only essential functionality to the users and hiding complex implementation details.
• Inheritance: Classes can inherit properties and behaviors from other classes, reducing redundancy and improving code organization.
• Modularity and Maintainability: Code is organized into reusable components, making it easier to debug and extend.
• Polymorphism means objects from different classes can act like they belong to the same superclass. This allows for flexible and dynamic behavior.

Example of Object-Oriented Programming in Python

# Object-Oriented Programming Example in Pyhton

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def calculate_area(self):
        return self.length * self.width

rectangle = Rectangle(10, 5)
print(f"Area: {rectangle.calculate_area()}")

Procedural vs Object-Oriented Programming in Python with Examples

Object-oriented and procedural programming are both effective methods, but they differ in their structure and data management.

Let’s see some of the major differences between procedural vs object-oriented programming in Python

Data Handling

Example of Data Handling in Python

# Procedural Programming
name = "John"

def print_name():
  print(name)

# Object-oriented programming
class Person:
  def __init__(self, name):
    self.name = name

  def print_name(self):
    print(self.name)

person = Person("John")
person.print_name() 
# Prints "John"

Structure

Example of Structure in Python

# Procedural Programmingg

def print_data(report_data):
  pass

# Object-oriented Programming

class Reports:
  def __init__(self, data):
    self.data = data

  def print(self):
    pass

report = Reports(report_data)
report.print()

Reusability and Maintainability

Example of Reusability and Maintainability in Python

# Procedural Programming

def user_print(user):
  print(user["name"])

def admin_print(admin):
  print(admin["name"] + " (Admin)")

# Object-oriented Programming

class Users:
  def __init__(self, name):
    self.name = name

  def print(self):
    print(self.name)

class Admins(User):
  def print(self):
    print(f"{self.name} (Admin)")

user = Users("John")
user.print() 
# Prints "John"

admin = Admins("Jane")
admin.print() 
# Prints "Jane (Admin)"

These examples highlight the key differences between object-oriented programming (OOP) and procedural programming. They can help you decide which one to use for a specific task.

Other Difference Between Procedural and Object-Oriented Programming

Pros and Cons of Procedural and Object-Oriented Programming

Geeks, in this section we will discuss and summarize the pros and cons of each programming approach:

Pros and Cons of Procedural Programming

Pros and Cons of Object-Oriented Programming

When to use Procedural vs Object-Oriented Programming

Here are some general guidelines on when to use procedural or object-oriented programming paradigms.

Choose Procedural Programming When:

• You are developing small, straightforward scripts that need to run quickly.
• When performance is a key concern, and abstraction is not.
• Creating unique programs without the option for reuse.
• Simplicity and clarity are more important.

Choose Object-Oriented Programming When:

• You’re developing large-scale projects that require maintainability.
• Data security and encapsulation are key concerns.
• You need reusable and extendable code.
• Leveraging inheritance, encapsulation, and polymorphism

Procedural vs Object-Oriented Programming Example in Python

We’ll create a simple program with both procedural and object-oriented programming:

Program Condition:

• Read a text file.
• Output each line with an added line number.

Procedural Implementation

# Open file and read lines into a list
text_file = open("text_file.txt")
lines = text_file.readlines()
text_file.close()

# Print each line with line number
for i in range(len(lines)):
  print(str(i) + ": " + lines[i])
  
# This shows a straightforward script that allows open access to data.

OOP Implementation

class TextReader:
  def __init__(self, filename):
    self.filename = filename
    self.lines = self._load()

  def _load(self):
    text_file = open(self.filename)
    lines = text_file.readlines()
    text_file.close()
    return lines

  def print_lines(self):
    for i in range(len(self.lines)):
      print(str(i) + ": " + self.lines[i])

reader = TextReader("text_file.txt")
reader.print_lines()

# This combines the data and methods into a TextReader class.

The OOP version is more modular and reusable. However, it can be more complex for simple tasks like this one. In contrast, procedural programming is ideal for linear scripts such as this example.

However, for a more robust program that requires additional features and customizations, OOP is the better choice.

Related Blogs:

>> Encoding and Decoding Using Base64 Strings in Python

>> What is Threading Mutex in Python – Simple Way

Conclusion

Both Procedural and Object-Oriented Programming have their pros and cons. The choice between them depends on your project’s needs. Procedural Programming is great for small, quick scripts that are easy to run. OOP is better for large, complex applications that need to be modular and easy to maintain.

By understanding both paradigms, you can make a better decision and write more efficient and scalable Python programs.

Which paradigm do you prefer for your Python projects? Let us know in the comments!

Happy Development!