Tag Archives: Python Best Practices

Programming, Tech Journey

Functional vs Object-Oriented Programming in Python: When to Use Each for Automation

Python is widely used for automation, scripting, and building real-world applications. Many developers start with functional or procedural programming because it’s simple and fits small automation tasks. However, object-oriented programming (OOP) is often introduced later, and it can feel confusing—especially if most of your work has been functional.

This article explains when to use functional programming versus OOP in Python, with practical examples from real automation tasks.

1. Functional Programming in Python

Functional or procedural programming focuses on functions that perform actions. It is widely used for automation because it is simple, linear, and stateless.

When functional works best:

  • Task is short-lived or linear
  • Little or no internal state to manage
  • Single developer or small scripts
  • Automation or ETL pipelines
  • Predictable input → output transformations

Example: Sending one-off emails

EMAIL_LIMIT = 3
sent_count = 0

def connect_smtp():
    return "smtp_connection"

def send_email(conn, to, subject, body):
    global sent_count
    if sent_count >= EMAIL_LIMIT:
        return False
    sent_count += 1
    return True

def close_smtp(conn):
    pass

Functional approach works, but as the task grows (multiple accounts, retries, logging), managing global state and passing parameters everywhere becomes messy.

2. Object-Oriented Programming (OOP) in Python

OOP organizes code around objects that hold state and behavior together. Each object can maintain its own data and provide related actions.

When OOP is useful:

  • The program has state that persists (counters, connections, sessions)
  • Multiple related operations work on the same entity
  • Multiple independent entities exist (e.g., different SMTP accounts)
  • The program will grow or evolve over time
  • Team collaboration or maintainable codebase is required
  • Frameworks, SDKs, or complex systems are being built

Example: Email sender with state and limits

class EmailSender:
    def __init__(self, limit):
        self.limit = limit
        self.sent_count = 0
        self.conn = None

    def connect(self):
        self.conn = "smtp_connection"

    def send(self, to, subject, body):
        if self.sent_count >= self.limit:
            return False
        self.sent_count += 1
        return True

    def close(self):
        self.conn = None

# Usage
alerts_sender = EmailSender(limit=2)
reports_sender = EmailSender(limit=5)

Benefits of OOP here:

  • State is encapsulated inside the object (sent_count, conn)
  • Multiple independent senders are easy to manage
  • Extending functionality (retries, logging) is straightforward
  • Cleaner and more maintainable as the project scales

3. Practical Decision Rule

A simple guideline to decide whether to use functional or OOP in Python:

Ask: “Does this thing need to remember its own state and do multiple related actions?”

  • Yes → Use OOP (class)
  • No → Functional is fine

Analogy:

  • Functional: a simple toaster you push to toast one slice
  • OOP: a programmable toaster that tracks # of toasts, settings, and multiple slots

4. Key Takeaways

  • Functional programming is perfect for small automation scripts.
  • OOP is valuable when state and behavior need to live together, or the system grows beyond simple scripts.
  • Experienced Python developers choose the simplest correct approach for the task.
  • Understanding both styles helps you scale your projects and work professionally.
Standard