Python OOP Classes and Objects: Complete Guide to __init__, self & Methods (with 20 MCQs)

Python OOP Classes and Objects form the foundational pillar of modern software engineering. While procedural programming structures code around independent actions and functions, Object-Oriented Programming (OOP) models applications around cohesive, real-world entities that bundle internal state (attributes) with authorized behaviors (methods).

Everything in Python is an object—from integers and strings to functions and modules. However, the true superpower of Python is realized when you begin engineering your own custom classes. Building on our foundational tutorials covering Python Functions, Modules and Packages, and Exception Handling, this complete guide and learning bundle demystifies the __init__ constructor, the true mechanic behind self, the difference between class and instance attributes, method typologies (instance, class, and static methods), and includes a 20-question practice test.

1. Paradigms: Procedural Programming vs Object-Oriented Programming

In software architecture, paradigms dictate how state and operations are modeled:

• Procedural Programming: Organizes code into sequences of steps, subroutines, and standalone functions that accept raw data structures (lists or dictionaries). The risk: data and the functions that manipulate it remain loosely decoupled, allowing invalid states to be introduced from anywhere in the codebase.
• Object-Oriented Programming (OOP): Combines data (attributes) and behavior (methods) into cohesive, self-governing units called objects. The object protects its internal state through validation and exposes authorized operations to the external world.

2. Core Syntax: Declaring Classes and Instantiating Objects

A class is a user-defined blueprint or prototype from which objects are created. In Python, classes are declared using the class keyword followed by the class name in PascalCase (per PEP 8):

class BankAccount:
    """Blueprint for managing customer bank accounts."""
    pass

# Creating two distinct object instances in heap RAM:
account_1 = BankAccount()
account_2 = BankAccount()

print("Instance 1:", account_1)  # <__main__.BankAccount object at 0x000001A...>
print("Instance 2:", account_2)  # <__main__.BankAccount object at 0x000001B...>
print("Identical memory?", account_1 is account_2)  # False

Each call to BankAccount() allocates a brand new chunk of heap memory with its own distinct object identity (as verified by the is operator).

3. The __init__() Method: Initializing Instance State

When an object is created, it usually needs initial data (such as the account owner’s name and starting balance). Python provides the special dunder method __init__() for this exact purpose:

class BankAccount:
    def __init__(self, owner: str, initial_balance: float = 0.0):
        """Initializes new instance attributes."""
        if initial_balance < 0:
            raise ValueError("Starting balance cannot be negative.")
        
        # Instance attributes bound to the specific object
        self.owner = owner
        self.balance = initial_balance

acc = BankAccount("Alice Smith", 1500.0)
print(f"Owner: {acc.owner}, Balance: ${acc.balance:,.2f}")

Constructor vs Initializer: __new__ vs __init__

In technical precision, __init__ is not the constructor; it is the initializer!

1. __new__(cls): The true constructor. It is a static method responsible for allocating the raw memory and returning the newly minted blank object instance.
2. __init__(self, ...): The initializer. It receives that blank instance as self and populates its instance attributes.

4. Demystifying ‘self’: The Invisible First Argument

The self parameter is the single most common stumbling block for newcomers to Python. Why must every instance method declare self as its first parameter?

class Greeter:
    def say_hello(self, name):
        print(f"Hello, {name}!")

g = Greeter()
g.say_hello("World")

What Happens Under the Hood

When you invoke g.say_hello("World"), Python automatically transforms that call into:

Greeter.say_hello(g, “World”)

Python takes the object before the dot (g) and passes it as the first argument (self) to the class method!

5. Class Attributes vs Instance Attributes (The Mutation Trap)

Understanding where data resides in memory is critical to preventing state corruption bugs:

• Instance Attributes: Variables prefixed with self. (e.g. self.balance). Every object instance owns its own separate, isolated copy.
• Class Attributes: Variables declared directly inside the class body outside any methods. A single shared copy exists in memory, shared across every instance of the class!

class Employee:
    # Class Attribute (shared across all employees)
    company_name = "IT2Edu Global"
    annual_bonus_rate = 0.05

    def __init__(self, name: str, salary: float):
        # Instance Attributes (unique per employee)
        self.name = name
        self.salary = salary

e1 = Employee("Rahul", 80000)
e2 = Employee("Priya", 95000)

print(e1.company_name)  # IT2Edu Global
print(e2.company_name)  # IT2Edu Global

The Shadowing Mutation Trap

What happens if you attempt to change a class attribute through an instance?

# ❌ WRONG: Creates an instance attribute on e1, leaving e2 and Employee unchanged!
e1.company_name = "Tech Solutions"
print(e1.company_name)       # Tech Solutions (Instance shadow)
print(e2.company_name)       # IT2Edu Global (Original class attribute!)
print(Employee.company_name) # IT2Edu Global

# ✅ CORRECT: Updates the class attribute universally for all instances!
Employee.company_name = "Tech Solutions Corp"
print(e2.company_name)       # Tech Solutions Corp

6. The Three Method Types: Instance, @classmethod, and @staticmethod

Python distinguishes between three distinct method typologies depending on what scope they bind to:

class Order:
    tax_rate = 0.08  # Class attribute

    def __init__(self, order_id: str, subtotal: float):
        self.order_id = order_id
        self.subtotal = subtotal

    # 1. INSTANCE METHOD: Binds to instance (self)
    def calculate_total(self) -> float:
        """Modifies or computes using instance attributes."""
        return round(self.subtotal * (1 + self.tax_rate), 2)

    # 2. CLASS METHOD: Binds to class (cls)
    @classmethod
    def from_csv_row(cls, row_string: str):
        """Alternative factory constructor creating instance from raw string."""
        order_id, raw_subtotal = row_string.split(",")
        return cls(order_id.strip(), float(raw_subtotal.strip()))

    # 3. STATIC METHOD: Self-contained utility (no self, no cls)
    @staticmethod
    def is_valid_order_id(order_id: str) -> bool:
        """Pure utility validator bound to Order namespace."""
        return order_id.startswith("ORD-") and len(order_id) == 8

7. Dunder Representation Methods: __str__ vs __repr__

By default, printing an object outputs its cryptic memory address (e.g. <Order object at 0x10a2>). You can customize this using two dunder methods:

• __repr__() (Goal: Unambiguous): Written for developers. Should ideally look like valid Python code to recreate the object. Used in the interactive REPL and error traces.
• __str__() (Goal: Readable): Written for end-users. Human-friendly summary returned when calling str(obj) or print(obj).

class Product:
    def __init__(self, sku: str, price: float):
        self.sku = sku
        self.price = price

    def __repr__(self):
        return f"Product(sku={self.sku!r}, price={self.price})"

    def __str__(self):
        return f"Product [{self.sku}] - ${self.price:.2f}"

p = Product("LAPTOP-99", 1299.50)
print(str(p))   # Product [LAPTOP-99] - $1299.50
print(repr(p))  # Product(sku='LAPTOP-99', price=1299.5)

8. Attribute Introspection: hasattr(), getattr(), and __dict__

Python allows runtime inspection and manipulation of object attributes:

class Configuration:
    def __init__(self):
        self.debug_mode = True
        self.max_connections = 100

config = Configuration()

# 1. Checking attribute existence
print(hasattr(config, "debug_mode"))      # True
print(hasattr(config, "database_url"))    # False

# 2. Dynamic attribute retrieval with fallback default
db = getattr(config, "database_url", "sqlite:///memory.db")
print("Database:", db)                    # sqlite:///memory.db

# 3. Inspecting internal storage dictionary
print("Internal Dict:", config.__dict__)  # {'debug_mode': True, 'max_connections': 100}

9. Comprehensive Comparison Matrices

Matrix 1: The Three Method Typologies

10. Real-World Engineering Case Studies (Banking & Entity Factory)

Case Study: Production Bank Account & Ledger System

from datetime import datetime

class BankAccount:
    bank_routing_number = "021000021"  # Class attribute

    def __init__(self, account_id: str, owner: str, starting_balance: float = 0.0):
        self.account_id = account_id
        self.owner = owner
        self._balance = starting_balance
        self._ledger = []
        self._log_transaction("INITIAL_DEPOSIT", starting_balance)

    def _log_transaction(self, tx_type: str, amount: float):
        self._ledger.append({
            "timestamp": datetime.now().isoformat(),
            "type": tx_type,
            "amount": amount,
            "new_balance": self._balance
        })

    def deposit(self, amount: float) -> float:
        if amount <= 0:
            raise ValueError("Deposit amount must be strictly positive.")
        self._balance += amount
        self._log_transaction("DEPOSIT", amount)
        return self._balance

    def withdraw(self, amount: float) -> float:
        if amount <= 0:
            raise ValueError("Withdrawal amount must be strictly positive.")
        if amount > self._balance:
            raise ValueError(f"Insufficient funds: Balance is ${self._balance:.2f}, requested ${amount:.2f}.")
        self._balance -= amount
        self._log_transaction("WITHDRAWAL", amount)
        return self._balance

    @property
    def current_balance(self) -> float:
        return self._balance

# Executing production flow
user_acc = BankAccount("ACC-9021", "Alice", 1000.0)
user_acc.deposit(250.0)
user_acc.withdraw(100.0)
print(f"Final Balance: ${user_acc.current_balance:.2f}")

11. Memory Tricks & The “B-I-M” Rule

12. One-Page Quick Revision Sheet (Printable PDF Ready)

13. 20 Practice MCQs with Answers & Explanations

class Counter:
    count = 0
    def __init__(self):
        Counter.count += 1

c1 = Counter()
c2 = Counter()
c3 = Counter()
print(c1.count)

class Team:
    members = []  # Class attribute
    def add(self, name):
        self.members.append(name)

14. Frequently Asked Questions (FAQs)

What is the difference between a function and a method in Python?

A function is a standalone block of code declared at module level using def. A method is a function defined inside a class that takes an instance reference (self) or class reference (cls) as its first argument.

Can a class exist without an __init__ method?

Yes. If you do not define an __init__ method, Python provides a default, parameterless initializer inheriting from object.

Why does Python use self instead of the this keyword?

Guido van Rossum chose explicit self to align with Python’s core principle: “Explicit is better than implicit.” Making the instance parameter explicit eliminates ambiguity between local function variables and instance variables.

15. Official References & Related Tutorials

• Python Official Documentation: Classes
• PEP 8: Class Naming Conventions
• Related Lesson: Python Functions: The Complete Practical Guide
• Related Lesson: Python Modules and Packages: The Complete Guide
• Related Lesson: Python Exception Handling: The Complete Guide
• Related Lesson: Python File Handling: The Complete Guide

{
“@context”: “https://schema.org”,
“@graph”: [
{
“@type”: “TechArticle”,
“headline”: “Python OOP Classes and Objects: Complete Guide to __init__, self & Methods (with 20 MCQs)”,
“description”: “Master Python OOP classes and objects with this complete guide. Learn class vs instance attributes, self, __init__, methods, and 20 practice MCQs.”,
“image”: “https://it2edu.com/wp-content/uploads/2026/11/python_oop_classes_architecture_guide-scaled.png”,
“author”: {
“@type”: “Person”,
“name”: “Tech writer”
},
“publisher”: {
“@type”: “Organization”,
“name”: “IT2Edu”,
“url”: “https://it2edu.com”
},
“mainEntityOfPage”: “https://it2edu.com/python-oop-classes-objects-guide/”,
“keywords”: “Python OOP Classes and Objects, class init constructor, self in Python, instance methods, classmethod, staticmethod”
},
{
“@type”: “FAQPage”,
“mainEntity”: [
{
“@type”: “Question”,
“name”: “What is the difference between a function and a method in Python?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “A function is an independent subprogram declared at module scope, whereas a method is a function defined inside a class that receives self or cls as its first parameter.”
}
},
{
“@type”: “Question”,
“name”: “What is the purpose of self in Python?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “self is an explicit reference to the current object instance calling the method, allowing access and modification of the object’s instance state.”
}
},
{
“@type”: “Question”,
“name”: “What is the difference between class attributes and instance attributes?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Class attributes are shared across all instances of a class, while instance attributes are unique and private to each individual object instance.”
}
}
]
}
]
}