Imagine you own two very different businesses in the bustling tourist town of El Nido, Palawan: a high‑energy disco hub and a cozy shawarma store. Both generate daily sales, incur daily expenses, and pay workers’ salaries. But each has unique costs — the disco pays a DJ fee, the shawarma shop loses money to ingredient waste. How can you model these businesses in Python without duplicating code and while keeping the ability to treat them uniformly?

The answer is polymorphism through inheritance and method overriding. The BusinessUnit base class captures everything common to both businesses: sales, expenses, salaries, and basic profit calculations. Then DiscoHub and ShawarmaStore inherit from it, overriding only the methods that need to account for their unique costs. Thanks to polymorphism, you can store both types in a single list and call the same methods (generate_report()) — Python automatically runs the correct version for each object.

This guide walks through every line of the program, explaining not just what the code does, but why each design choice was made — from using super() to extend parent logic, to the importance of keeping method signatures identical for polymorphism.

The program consists of one base class and two subclasses. The flow is simple: create instances, store them in a list, loop over the list, and call generate_report() on each. The magic of polymorphism ensures each object’s overridden methods are used automatically.

# This program uses only built-in Python features.
# No import statements are needed.

Unlike many real‑world programs that rely on external modules, this example stays completely self‑contained. Everything you need — classes, methods, string formatting, and the if __name__ == "__main__" guard — is part of Python’s core. This keeps the focus on OOP concepts without distractions.

class BusinessUnit:
    def __init__(self, name: str, daily_sales: float, daily_expenses: float, workers_salary: float):
        self.name = name
        self.daily_sales = daily_sales
        self.daily_expenses = daily_expenses
        self.workers_salary = workers_salary

    def calculate_net_expenses(self) -> float:
        return self.daily_expenses + self.workers_salary

    def calculate_gross_profit(self) -> float:
        return self.daily_sales - self.daily_expenses

    def calculate_net_profit(self) -> float:
        return self.daily_sales - self.calculate_net_expenses()

    def generate_report(self):
        print(f"\n{'='*60}")
        print(f"EL NIDO BUSINESS TRACKER - {self.name}")
        print(f"{'='*60}")
        print(f"Daily Sales          : PHP {self.daily_sales:,.2f}")
        print(f"Daily Expenses       : PHP {self.daily_expenses:,.2f}")
        print(f"Workers' Salary      : PHP {self.workers_salary:,.2f}")
        print(f"Net Expenses         : PHP {self.calculate_net_expenses():,.2f}")
        print(f"Gross Profit         : PHP {self.calculate_gross_profit():,.2f}")
        print(f"Net Profit           : PHP {self.calculate_net_profit():,.2f}")
        print(f"{'='*60}\n")

The BusinessUnit class is the foundation. It defines four attributes that every business shares and four methods that calculate various profit metrics. The type hints (name: str, etc.) serve as documentation; Python does not enforce them at runtime. The generate_report() method prints a well‑formatted summary, using f‑strings with the :,.2f format specifier to display numbers with commas and two decimal places — essential for readability when dealing with Philippine Peso amounts.

Notice that calculate_net_profit() calls self.calculate_net_expenses() rather than repeating the formula. This is a deliberate design: it ensures that any subclass that overrides calculate_net_expenses() will automatically affect the net profit calculation. This is the key to polymorphism — the base method uses a hook that child classes can customise.

class DiscoHub(BusinessUnit):
    def __init__(self, name: str, daily_sales: float, daily_expenses: float,
                 workers_salary: float, dj_entertainment_fee: float):
        super().__init__(name, daily_sales, daily_expenses, workers_salary)
        self.dj_entertainment_fee = dj_entertainment_fee

    def calculate_net_expenses(self) -> float:
        base_net = super().calculate_net_expenses()
        return base_net + self.dj_entertainment_fee

A disco hub has an extra cost that a generic business does not: the DJ entertainment fee. The constructor takes this additional parameter, then calls the parent constructor using super().__init__(...) to initialise the common attributes. This avoids duplicating the four lines of attribute assignment from BusinessUnit.

The overridden calculate_net_expenses() first retrieves the base net expenses by calling super().calculate_net_expenses() — which returns daily_expenses + workers_salary — and then adds the DJ fee. This is the canonical way to extend a parent method: reuse the parent logic and then augment it. The method signature (no parameters, returns float) is identical to the parent’s, satisfying the Liskov substitution principle.

class ShawarmaStore(BusinessUnit):
    def __init__(self, name: str, daily_sales: float, daily_expenses: float,
                 workers_salary: float, ingredient_waste: float):
        super().__init__(name, daily_sales, daily_expenses, workers_salary)
        self.ingredient_waste = ingredient_waste

    def calculate_gross_profit(self) -> float:
        return self.daily_sales - self.daily_expenses - self.ingredient_waste

The shawarma store introduces a different kind of unique cost: ingredient waste. Unlike the disco’s fee, waste directly reduces the gross profit rather than increasing expenses. Therefore, the class overrides calculate_gross_profit() instead of calculate_net_expenses(). It does not call super() because it completely replaces the parent’s logic — the parent formula (daily_sales - daily_expenses) is no longer sufficient.

Notice that the method signature remains the same: no parameters, returns a float. This consistency is vital for polymorphism. Also, the overridden version still uses the parent’s attributes (daily_sales, daily_expenses) because they are inherited. The new attribute ingredient_waste is used only here.

if __name__ == "__main__":
    print("🚀 El Nido Business Tracker - Disco Hub & Shawarma Store")
    print("Demonstrating Polymorphism in Python\n")

    disco = DiscoHub(
        name="Vibe Palace Disco Hub",
        daily_sales=85000,
        daily_expenses=32000,
        workers_salary=15000,
        dj_entertainment_fee=8000
    )

    shawarma = ShawarmaStore(
        name="El Nido Shawarma Hub",
        daily_sales=42000,
        daily_expenses=18000,
        workers_salary=9000,
        ingredient_waste=2500
    )

    businesses = [disco, shawarma]

    for business in businesses:
        business.generate_report()

This is where everything comes together. Two objects of different types are created and placed in a single list. The loop iterates over the list and calls generate_report() on each. Thanks to polymorphism, Python looks up the method at runtime and executes the version belonging to the object’s actual class.

For the disco object, generate_report() (inherited from BusinessUnit) calls calculate_net_expenses(), which is the overridden version in DiscoHub that includes the DJ fee. For the shawarma object, calculate_gross_profit() called from within generate_report() uses the overridden version that subtracts ingredient waste. The same report method produces correct, business‑specific results without any if statements or type checks.

Polymorphism (from Greek “many forms”) in Python means that the same method call can trigger different implementations depending on the object’s type. It is one of the four fundamental pillars of OOP (along with encapsulation, inheritance, and abstraction). In this program, polymorphism is achieved through inheritance and method overriding.

Overriding a method means providing a new implementation in a child class that replaces the parent’s version. The child can either completely replace the parent logic (like ShawarmaStore.calculate_gross_profit) or extend it (like DiscoHub.calculate_net_expenses).

Solidify your understanding by extending the program:

Stay connected for more Python guides, OOP tutorials, and tech content from the Philippines. Follow on your preferred platform: