Object-oriented programming (OOP) organises software around objects — bundles of data (attributes/state) and the behaviour (methods) that acts on it. A class is a blueprint; an object is an instance of that class. OOP rests on four pillars:

• Encapsulation — bundle data with the methods that manage it, and hide internal detail behind a public interface. The outside world uses the object without depending on how it works inside.
• Abstraction — expose what an object does, conceal how. A BankAccount exposes withdraw(), not the ledger internals.
• Inheritance — a subclass reuses and extends a parent class, modelling an "is-a" relationship (a Dog is an Animal).
• Polymorphism — one interface, many implementations: calling speak() on different animals runs different code, chosen at runtime by the object's actual type.

OOP is fundamentally a strategy for managing complexity in large programs. By grouping state with the operations that maintain it, an object can enforce its own invariants — e.g. a bank balance that never goes negative — so no external code can corrupt it. This is encapsulation's real payoff: local reasoning. You can trust an object because it guards itself.

Polymorphism is the pillar that pays dividends at scale. Write code that calls shape.area() and it works for circles, squares, and triangles you have not even written yet — as long as each provides an area(). New types slot in without touching old code. This "open for extension, closed for modification" principle is why OOP dominated large-system design for decades.

We model animals to show all four pillars: a base class, a private-by-convention attribute (encapsulation), two subclasses (inheritance), and a shared method behaving differently (polymorphism).

class Animal:
    def __init__(self, name):
        self._name = name          # leading underscore: "internal, please don't touch"

    def name(self):                # public accessor -> encapsulation
        return self._name

    def speak(self):
        raise NotImplementedError  # abstract: each subclass must define this

class Dog(Animal):                 # Dog IS-A Animal  -> inheritance
    def speak(self):
        return "Woof"

class Cat(Animal):
    def speak(self):
        return "Meow"

class Cow(Animal):
    def speak(self):
        return "Moo"

# Polymorphism: identical call, type-specific behaviour chosen at runtime
animals = [Dog("Rex"), Cat("Milo"), Cow("Daisy")]
for a in animals:
    print(a.name() + " says " + a.speak())

# Output:
# Rex says Woof
# Milo says Meow
# Daisy says Moo

The loop never asks "what kind of animal is this?" — it simply calls speak() and each object supplies its own answer. Add a Duck class tomorrow and the loop works unchanged. That is polymorphism buying you extensibility.