Python OOP Interview Questions: Concepts, Code & Gotchas

from abc import ABC, abstractmethod

# ABSTRACTION: Define a contract that all payment processors must follow.
# Callers only need to know about .charge() — not HOW it works.
class PaymentProcessor(ABC):
    @abstractmethod
    def charge(self, amount: float, currency: str) -> str:
        """Every subclass MUST implement this method."""
        pass


# INHERITANCE: StripeProcessor reuses the interface from PaymentProcessor.
# We only write what's different — the Stripe-specific logic.
class StripeProcessor(PaymentProcessor):
    def __init__(self, api_key: str):
        # ENCAPSULATION: _api_key is 'private by convention' (single underscore).
        # External code SHOULD NOT read or write this directly.
        self._api_key = api_key

    def charge(self, amount: float, currency: str) -> str:
        # In real life this would call the Stripe SDK.
        return f"[Stripe] Charged {amount} {currency} using key ending ...{self._api_key[-4:]}"


class PayPalProcessor(PaymentProcessor):
    def __init__(self, client_id: str):
        self._client_id = client_id

    def charge(self, amount: float, currency: str) -> str:
        return f"[PayPal] Charged {amount} {currency} via client {self._client_id}"


# POLYMORPHISM: process_payment doesn't know or care which processor it gets.
# It calls .charge() and Python dispatches to the right class automatically.
def process_payment(processor: PaymentProcessor, amount: float, currency: str):
    result = processor.charge(amount, currency)
    print(result)


# Create objects (instances) from our blueprints (classes)
stripe = StripeProcessor(api_key="sk_live_ABCDEF123456")
paypal = PayPalProcessor(client_id="CLIENT_XYZ")

process_payment(stripe, 49.99, "USD")
process_payment(paypal, 49.99, "USD")

# ── INHERITANCE APPROACH ──────────────────────────────────────────────────
# Use this when the child IS a specialised version of the parent.

class Animal:
    def __init__(self, name: str):
        self.name = name

    def breathe(self):
        # All animals breathe — this belongs in the base class.
        return f"{self.name} is breathing"


class Dog(Animal):
    def speak(self):
        # Dogs speak differently from Cats — override only what changes.
        return f"{self.name} says: Woof!"


class Cat(Animal):
    def speak(self):
        return f"{self.name} says: Meow!"


# ── COMPOSITION APPROACH ─────────────────────────────────────────────────
# Use this when the object HAS a behaviour, not when it IS a type of thing.

class GPSModule:
    """A self-contained unit of GPS behaviour. Fully testable on its own."""
    def get_location(self) -> str:
        return "lat=51.5074, lon=-0.1278"  # London, hardcoded for demo


class MusicPlayer:
    """A self-contained unit of audio behaviour."""
    def play(self, track: str) -> str:
        return f"Now playing: {track}"


class SmartCar:
    """
    SmartCar HAS a GPS and HAS a MusicPlayer.
    It does NOT inherit from either — that would be bizarre.
    Swapping to a SatelliteGPS later? Just change the injected object.
    """
    def __init__(self, gps: GPSModule, player: MusicPlayer):
        self._gps = gps        # Composed in — not inherited
        self._player = player  # Composed in — not inherited

    def navigate(self) -> str:
        return f"Navigating to {self._gps.get_location()}"

    def entertain(self, track: str) -> str:
        return self._player.play(track)


# ── DEMO ─────────────────────────────────────────────────────────────────
dog = Dog("Rex")
cat = Cat("Whiskers")
print(dog.breathe())   # Inherited from Animal
print(dog.speak())     # Dog-specific
print(cat.speak())     # Cat-specific — polymorphism at work

my_car = SmartCar(gps=GPSModule(), player=MusicPlayer())
print(my_car.navigate())
print(my_car.entertain("Bohemian Rhapsody"))

class Employee:
    # Class variable: shared across ALL instances, not per-employee
    company_name = "TheCodeForge"
    _headcount = 0  # tracks how many employees exist

    def __init__(self, first_name: str, last_name: str, annual_salary: float):
        self.first_name = first_name
        self.last_name = last_name
        self._annual_salary = annual_salary  # 'private' — use the property below
        Employee._headcount += 1

    # ── DUNDER METHODS ───────────────────────────────────────────────────
    def __str__(self) -> str:
        """Called by print() and str(). Should be human-readable."""
        return f"{self.first_name} {self.last_name} @ {self.company_name}"

    def __repr__(self) -> str:
        """Called in the REPL and for debugging. Should be unambiguous."""
        return f"Employee('{self.first_name}', '{self.last_name}', {self._annual_salary})"

    def __eq__(self, other: object) -> bool:
        """Two employees are equal if their full names match — define YOUR rule."""
        if not isinstance(other, Employee):
            return NotImplemented  # Let Python handle incompatible types gracefully
        return self.first_name == other.first_name and self.last_name == other.last_name

    # ── PROPERTY ─────────────────────────────────────────────────────────
    @property
    def annual_salary(self) -> float:
        """Getter: caller reads employee.annual_salary like a plain attribute."""
        return self._annual_salary

    @annual_salary.setter
    def annual_salary(self, value: float):
        """Setter: enforces business rules — salary can't go negative."""
        if value < 0:
            raise ValueError(f"Salary cannot be negative. Got: {value}")
        self._annual_salary = value

    # ── CLASS METHOD ─────────────────────────────────────────────────────
    @classmethod
    def from_full_name(cls, full_name: str, annual_salary: float) -> "Employee":
        """
        Alternative constructor — receives `cls` so it can build an instance.
        Caller writes: emp = Employee.from_full_name('Ada Lovelace', 95000)
        """
        first, last = full_name.split(" ", 1)
        return cls(first, last, annual_salary)  # uses cls, not Employee, for subclass safety

    @classmethod
    def headcount(cls) -> int:
        """Reads class-level state — needs cls, so it's a classmethod."""
        return cls._headcount

    # ── STATIC METHOD ────────────────────────────────────────────────────
    @staticmethod
    def is_valid_salary(value: float) -> bool:
        """
        Pure utility: no access to instance (self) or class (cls) needed.
        It just belongs here conceptually because it's about Employee salaries.
        """
        return isinstance(value, (int, float)) and 0 <= value <= 10_000_000


# ── DEMO ─────────────────────────────────────────────────────────────────
emp1 = Employee("Alice", "Smith", 80000)
emp2 = Employee.from_full_name("Bob Johnson", 95000)  # classmethod constructor

print(emp1)                          # __str__
print(repr(emp2))                    # __repr__
print(emp1 == Employee("Alice", "Smith", 999))  # __eq__ — salary ignored by our rule

emp1.annual_salary = 85000           # calls the setter with validation
print(f"New salary: {emp1.annual_salary}")

print(f"Total employees: {Employee.headcount()}")
print(f"Is 50000 valid? {Employee.is_valid_salary(50000)}")
print(f"Is -100 valid? {Employee.is_valid_salary(-100)}")

# ── MIXIN PATTERN ─────────────────────────────────────────────────────────
# Mixins are NOT meant to be instantiated alone.
# They 'mix in' a single, focused behaviour to whatever class uses them.

class TimestampMixin:
    """Adds created_at tracking to any class that includes it."""
    def __init__(self, *args, **kwargs):
        import datetime
        # IMPORTANT: always pass *args/**kwargs up the chain so other
        # __init__ methods in the MRO also receive their arguments.
        super().__init__(*args, **kwargs)
        self.created_at = datetime.datetime.utcnow().strftime("%Y-%m-%d")


class SerializableMixin:
    """Adds a to_dict() method to any class that includes it."""
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)  # cooperative — passes args along

    def to_dict(self) -> dict:
        # __dict__ holds all instance attributes as a plain dictionary
        return self.__dict__


class BaseModel:
    """Minimal base — every model has an id."""
    def __init__(self, model_id: int):
        self.model_id = model_id


# Order of inheritance matters! Python builds the MRO left to right.
# MRO here: BlogPost -> TimestampMixin -> SerializableMixin -> BaseModel -> object
class BlogPost(TimestampMixin, SerializableMixin, BaseModel):
    def __init__(self, model_id: int, title: str, author: str):
        # super().__init__() kicks off the MRO chain.
        # TimestampMixin runs first, then SerializableMixin, then BaseModel.
        super().__init__(model_id=model_id)
        self.title = title
        self.author = author


# ── DEMO ──────────────────────────────────────────────────────────────────
post = BlogPost(model_id=42, title="Python OOP Deep Dive", author="Ada")

print("Title:", post.title)
print("Created at:", post.created_at)  # from TimestampMixin
print("Serialized:", post.to_dict())   # from SerializableMixin

# See exactly how Python resolves method calls for this class
print("\nMRO:")
for klass in BlogPost.__mro__:
    print(" ->", klass.__name__)