Academy — Sanjib Sikder

A New Way of Thinking

Everything you've written so far has been procedural — a sequence of instructions, with data in variables and behaviour in functions, kept largely separate from each other.

Object-oriented programming takes a different approach. It says: group related data and the functions that operate on it into a single unit. That unit is an object. The blueprint for creating objects is a class.

This isn't a new syntax trick. It's a different way of modelling problems — one that becomes essential as programs grow larger and more complex.

The Problem Without Classes

Imagine managing a library of books. Without classes:

book1_title  = "Midnight's Children"
book1_author = "Salman Rushdie"
book1_pages  = 536

book2_title  = "The God of Small Things"
book2_author = "Arundhati Roy"
book2_pages  = 340

Two books, six variables. Ten books? Sixty variables. And every function that works with a book must receive three separate arguments — or worse, a loosely coupled dictionary with no guarantees about its structure.

Classes solve this by letting you define exactly what a book is — and what it can do.

Defining a Class

Python

Ctrl+Enter to run

class Book:
    def __init__(self, title, author, pages):
        self.title  = title
        self.author = author
        self.pages  = pages

book1 = Book(#22c55e">"Midnight's Children", "Salman Rushdie", 536)
book2 = Book(#22c55e">"The God of Small Things", "Arundhati Roy", 340)

print(book1.title)
print(book2.author)
print(book1.pages)

Let's unpack this carefully.

class Book: — Defines a new type called Book. The convention is CapitalCase for class names.

def __init__(self, title, author, pages): — __init__ is a special method called automatically when a new object is created. It's the constructor — the setup instructions that run once at birth. The double underscores mark it as a "dunder" (double-underscore) method — a Python convention for special built-in behaviour.

self — Every method in a class receives the object itself as the first argument, by convention named self. When you write self.title = title, you're creating an attribute — a piece of data attached to this specific object.

book1 = Book("Midnight's Children", "Salman Rushdie", 536) — This creates an instance of Book. Python calls __init__ automatically, passing the three arguments in. book1 now holds a fully formed object with three attributes.

Adding Methods

A method is a function defined inside a class. It has access to the object's own data through self.

Python

Ctrl+Enter to run

class Book:
    def __init__(self, title, author, pages):
        self.title  = title
        self.author = author
        self.pages  = pages

    def describe(self):
        return f#22c55e">'"{self.title}" by {self.author} ({self.pages} pages)'

    def is_long(self):
        return self.pages > 400

book1 = Book(#22c55e">"Midnight's Children", "Salman Rushdie", 536)
book2 = Book(#22c55e">"The God of Small Things", "Arundhati Roy", 340)

print(book1.describe())
print(book2.describe())
print(book1.is_long())
print(book2.is_long())

describe() and is_long() are methods — they belong to every Book object. Each object calls them with its own data. book1.is_long() checks book1.pages. book2.is_long() checks book2.pages. Same method, different data.

This is the core idea: data and behaviour bundled together. The book knows how to describe itself. The book knows whether it's long. You don't need external functions for this.

Modifying Attributes

Attributes can be read and changed from outside the class using dot notation:

Python

Ctrl+Enter to run

class Book:
    def __init__(self, title, author, pages):
        self.title  = title
        self.author = author
        self.pages  = pages
        self.is_read = False

    def mark_as_read(self):
        self.is_read = True
        print(f#22c55e">'Marked "{self.title}" as read.')

book = Book(#22c55e">"Sapiens", "Yuval Noah Harari", 443)
print(book.is_read)

book.mark_as_read()
print(book.is_read)

is_read starts as False. The method mark_as_read() changes it to True and gives feedback. The state lives inside the object — not in a separate variable somewhere outside.

The `str` Method

When you print() an object directly, Python shows something unhelpful by default. Define __str__ to control what gets displayed:

Python

Ctrl+Enter to run

class Book:
    def __init__(self, title, author, pages):
        self.title  = title
        self.author = author
        self.pages  = pages

    def __str__(self):
        return f#22c55e">'"{self.title}" by {self.author}'

book = Book(#22c55e">"The Namesake", "Jhumpa Lahiri", 291)
print(book)

__str__ is called automatically whenever Python needs a string representation of your object — in print(), in f-strings, in error messages. Always define it. An object that describes itself clearly is far easier to work with.

Multiple Objects, Shared Blueprint

Every object created from a class is independent. They share the blueprint but not the data.

Python

Ctrl+Enter to run

class Counter:
    def __init__(self, name):
        self.name  = name
        self.value = 0

    def increment(self):
        self.value += 1

    def __str__(self):
        return f#22c55e">"{self.name}: {self.value}"

visitors = Counter(#22c55e">"Visitors")
orders = Counter(#22c55e">"Orders")

visitors.increment()
visitors.increment()
visitors.increment()
orders.increment()

print(visitors)
print(orders)

visitors and orders are completely independent objects. Incrementing one has no effect on the other. Each carries its own value. This is what objects give you: isolated, self-contained units of state and behaviour.

A Realistic Example

Python

Ctrl+Enter to run

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner   = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError(#22c55e">"Deposit amount must be positive.")
        self.balance += amount
        print(f#22c55e">"Deposited ₹{amount}. New balance: ₹{self.balance}")

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError(#22c55e">"Insufficient funds.")
        self.balance -= amount
        print(f#22c55e">"Withdrew ₹{amount}. New balance: ₹{self.balance}")

    def __str__(self):
        return f#22c55e">"{self.owner}'s account — Balance: ₹{self.balance}"

account = BankAccount(#22c55e">"Priya", 1000)
print(account)
account.deposit(500)
account.withdraw(200)
account.withdraw(2000)

A BankAccount that validates its own operations, manages its own state, and describes itself. All the logic that belongs to an account lives inside the account. This is the payoff of object-oriented design.

What You Have Learned

Classes let you define your own data types — blueprints for objects that bundle data and behaviour together.

The key ideas:

A class is a blueprint; an object (or instance) is a specific thing built from it
__init__ runs automatically when an object is created — use it to set up attributes
self refers to the current object inside its own methods
Attributes are data attached to an object (self.name)
Methods are functions that belong to a class and operate on the object's data
__str__ controls how an object is displayed when printed
Each object has its own copy of the data — objects don't share state

In the next lesson, you'll learn inheritance — how one class can build on another, reusing and extending its behaviour.

Object-Oriented Programming — Basics

A New Way of Thinking

The Problem Without Classes

Defining a Class

Adding Methods

Modifying Attributes

The __str__ Method

Multiple Objects, Shared Blueprint

A Realistic Example

What You Have Learned

The `str` Method