Python OOP Basics — Classes, Objects, init and Instance Variables

The Story That Explains Classes and Objects

Class vs Object — The Fundamental Difference

Your First Class — Absolute Minimum

# Define the blueprint — as empty as it gets
class Dog:
    pass                       # empty body — no data, no methods, no __init__

# Create objects (instances) from it
d1 = Dog()                     # object #1 — a bare, empty Dog
d2 = Dog()                     # object #2 — another bare, empty Dog

print(d1)                      # <__main__.Dog object at 0x7f8b12c1a410>
print(d2)                      # <__main__.Dog object at 0x7f8b12c1a4d0>
print(d1 is d2)                # False — two distinct objects

So we can already make objects. But right now they're empty — no name, no breed, no age. How do we give them data?

Adding Data From Outside — The Manual Way

In Python, any object lets you attach attributes to it from outside the class. You just reach in with dot notation and assign a value: d1.name = "Buddy". These are instance variables — but created in the most manual way possible.

class Dog:
    pass                          # still just an empty blueprint

# ── Step 1: create three bare, empty objects ──────────────
d1 = Dog()
d2 = Dog()
d3 = Dog()

# ── Step 2: attach every attribute manually, from outside ─
d1.name  = "Buddy"
d1.breed = "Labrador"
d1.age   = 3

d2.name  = "Milo"
d2.breed = "Beagle"
d2.age   = 5

d3.name  = "Luna"
d3.breed = "Poodle"
d3.age   = 2

print(d1.name, d1.breed, d1.age)   # Buddy Labrador 3
print(d2.name, d2.breed, d2.age)   # Milo Beagle 5
print(d3.name, d3.breed, d3.age)   # Luna Poodle 2

Animated Diagram — Manual Assignment Fills Empty Objects One-By-One

Watch the setup happen. Three bare Dog objects sit there empty. Then one line at a time from outside the class, each attribute gets pushed into each object. It works — but count the lines flowing in.

Why This Manual Way Is Painful

The code above works. Every object ends up with the right data. But this style breaks down the moment your program has more than a handful of objects. Let's list exactly why.

The Fix — __init__ Runs Setup Automatically

__init__ (pronounced "dunder init") is a special method Python calls automatically the instant you create an object. You write the setup logic once inside the class, and Python runs it for every new object. No more repetition, no forgotten attributes, no scattered code.

class Dog:
    def __init__(self, name, breed, age):
        # Runs automatically every time you write Dog(...)
        self.name  = name
        self.breed = breed
        self.age   = age

# Object creation is ONE LINE each — no manual attribute wiring
d1 = Dog("Buddy", "Labrador", 3)
d2 = Dog("Milo",  "Beagle",   5)
d3 = Dog("Luna",  "Poodle",   2)

print(d1.name, d1.breed, d1.age)   # Buddy Labrador 3
print(d2.name, d2.breed, d2.age)   # Milo Beagle 5
print(d3.name, d3.breed, d3.age)   # Luna Poodle 2

Before & After — The Same Job

Animated Diagram — __init__ Fills the Empty Object

Watch what happens on Student("Alice", 20): an empty object is created, then the arguments fly into their self. slots automatically. No line of code from outside the class is needed to wire them up.

Anatomy of __init__

class Student:
    def __init__(self, name, age, course):
    #       ^^^^  ^^^^^^^^^^^^^^^^^^  ← self first, then parameters
        self.name   = name          # attach name to this object
        self.age    = age           # attach age to this object
        self.course = course        # attach course to this object

s1 = Student("Alice",   20, "Physics")
s2 = Student("Bob",     22, "Chemistry")
s3 = Student("Chandra", 19, "Math")

print(s1.name, s1.age, s1.course)   # Alice 20 Physics

What Is self?

Every method inside a class takes self as its first parameter. It's just a name for "the specific object this method is being called on." When you write s1.greet(), Python transparently rewrites it as Student.greet(s1) and slots s1 in as self.

class Dog:
    def __init__(self, name, breed):
        self.name  = name
        self.breed = breed

    def bark(self):
        # self is whichever dog we called .bark() on
        print(f"{self.name} says: Woof!")

buddy = Dog("Buddy", "Labrador")
milo  = Dog("Milo",  "Beagle")

buddy.bark()                # same as Dog.bark(buddy)  → "Buddy says: Woof!"
milo.bark()                 # same as Dog.bark(milo)   → "Milo says: Woof!"

Instance Variables — Where Each Object's Data Lives

An instance variable is a piece of data attached to one specific object. It's created the moment you write self.something = value inside a method (usually __init__). Every object gets its own private copy.

Animated Diagram — Independent Memory Per Object

Three BankAccount objects sit side by side. Watch a deposit flow into the middle account — its balance ticks up while the other two stay completely untouched. That's what "each object has its own memory" really means.

Animated Diagram — Inside vs Outside the Class

The same instance variable is reached two different ways depending on where you are. Inside a method you say self.balance. Outside the class you say acc.balance. Both arrows land on the same memory box.

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

    def deposit(self, amount):
        # INSIDE the class → use self.
        self.balance += amount

acc = BankAccount("Alice", 1000)

# OUTSIDE the class → use the object name
print(acc.balance)             # 1000  (read from outside)
acc.deposit(200)               # calls the method → uses self inside
print(acc.balance)             # 1200

Instance Variables vs Local Variables

Inside a method, self.balance and balance are completely different. One survives after the method ends; the other is thrown away instantly.

class Counter:
    def __init__(self):
        self.count = 0            # instance variable — persists

    def bad_increment(self):
        count = self.count + 1    # local variable — gone at return
        # self.count is NEVER updated → bug!

    def good_increment(self):
        self.count += 1          # updates the object's memory

c = Counter()
c.bad_increment()
c.bad_increment()
print(c.count)             # 0  ← nothing changed, silent bug

c.good_increment()
c.good_increment()
print(c.count)             # 2  ← works correctly

Practical Example 1 — A Rectangle

class Rectangle:
    def __init__(self, width, height):
        self.width  = width          # instance variable
        self.height = height         # instance variable

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    def describe(self):
        print(f"Rectangle {self.width}x{self.height}: "
              f"area={self.area()}, perimeter={self.perimeter()}")

r1 = Rectangle(4, 5)
r2 = Rectangle(10, 3)

r1.describe()                     # uses r1's width/height
r2.describe()                     # uses r2's width/height

r1.width = 100
r1.describe()                     # r1 changed
r2.describe()                     # r2 identical to before

Practical Example 2 — A Student Record System

class Student:
    def __init__(self, roll_no, name, marks):
        self.roll_no = roll_no
        self.name    = name
        self.marks   = marks

    def average(self):
        return sum(self.marks) / len(self.marks)

    def grade(self):
        avg = self.average()
        if avg >= 90: return "A"
        if avg >= 75: return "B"
        if avg >= 60: return "C"
        return "F"

    def report(self):
        print(f"{self.roll_no:3d} {self.name:15s} "
              f"Avg: {self.average():5.1f}   Grade: {self.grade()}")

classroom = [
    Student(1, "Alice",   [92, 88, 95, 90]),
    Student(2, "Bob",     [70, 75, 80, 72]),
    Student(3, "Chandra", [55, 62, 58, 65]),
    Student(4, "Deepa",   [40, 45, 50, 42]),
]

for student in classroom:
    student.report()

Practical Example 3 — A Bank Account with Behaviour

class BankAccount:
    def __init__(self, holder, opening_balance=0):
        if opening_balance < 0:
            raise ValueError("Opening balance cannot be negative")
        self.holder   = holder
        self.balance  = opening_balance
        self.history  = []           # each account has its own history

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount
        self.history.append(("deposit", amount))

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        self.history.append(("withdraw", amount))

    def statement(self):
        print(f"\n--- {self.holder} ---")
        for action, amount in self.history:
            print(f"  {action:9s}  ${amount}")
        print(f"  Current balance: ${self.balance}")

alice = BankAccount("Alice", 1000)
bob   = BankAccount("Bob")

alice.deposit(500)
alice.withdraw(200)

bob.deposit(100)
bob.deposit(300)
bob.withdraw(50)

alice.statement()
bob.statement()

Common Mistakes (and Fixes)

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age  = age

    def __repr__(self):
        return f"Student(name={self.name!r}, age={self.age})"

s = Student("Alice", 20)
print(s)     # Student(name='Alice', age=20)   ← much better than a memory address

Quick Reference Table

Golden Rules