Object-Oriented Programming (OOP)

Introduction

So far in this course, you have written programs as a sequence of variables, functions, and logic that operate on data from the outside. This style works well for smaller scripts, but as programs grow, it becomes harder to keep related data and behavior organized together.

Object-oriented programming, or OOP, is a different way of structuring code that bundles data and the behavior that acts on that data into a single unit called an object. This lesson is a conceptual introduction — you will get a preview of the ideas here, and start writing real class syntax in the very next lesson.

What is OOP?

Object-oriented programming is a programming style built around objects — self-contained units that combine data (called attributes) with the actions that operate on that data (called methods). Instead of writing separate variables and functions that need to be kept in sync manually, you model real things as single, self-contained objects.

Why OOP Matters

As programs grow beyond a few dozen lines, keeping track of loose variables and functions that all operate on the same data becomes error-prone. OOP solves this by grouping related data and functions into a single, well-defined unit, so the relationship between them is clear and enforced by the language itself.

Procedural vs Object-Oriented Style

Everything you have written so far has mostly been procedural style: separate variables and functions that pass data back and forth. Here is the same idea — representing a student and printing their details — written both ways, so you can see the difference in structure.

# Procedural style: data and behavior are separate
student_name = "Maya"
student_grade = 91

def describe_student(name, grade):
    print(f"{name} scored {grade} marks.")

describe_student(student_name, student_grade)

Maya scored 91 marks.

# Object-oriented style: data and behavior live together (preview only)
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def describe(self):
        print(f"{self.name} scored {self.grade} marks.")

maya = Student("Maya", 91)
maya.describe()

Maya scored 91 marks.

Both versions produce the same result, but in the OOP version, the name, grade, and the describe behavior are bundled together inside a single Student object. As you add more students or more behavior, this bundling keeps everything organized. Do not worry about the exact syntax yet — class, self, and __init__ are explained in full detail over the next two lessons.

Real-World Analogy: Blueprint vs House

In OOP, a class is like an architectural blueprint, and an object is like an actual house built from that blueprint. The blueprint itself is not a house you can live in — it is just a plan describing what every house built from it will have.

The Four Pillars of OOP

Object-oriented programming rests on four core ideas. Each one gets its own full lesson later in this course — for now, here is a short preview of what each pillar means.

A Quick Preview of Classes

To make the four pillars feel concrete, here is one more tiny preview: two different classes, Dog and Cat, that both have a method called speak(). This hints at polymorphism, one of the pillars above, without needing to explain the full syntax yet.

class Dog:
    def speak(self):
        print("Woof!")

class Cat:
    def speak(self):
        print("Meow!")

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()

Woof!
Meow!

Notice that the same method name, speak(), behaves differently depending on which object calls it. Full class syntax — class, self, and creating objects — begins in the very next lesson.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Object-oriented programming is a way of structuring code around objects that bundle data and behavior together, modeled after real-world things. You previewed the four pillars — Encapsulation, Inheritance, Polymorphism, and Abstraction — each of which gets its own dedicated lesson soon.