Python is an object-oriented programming language, which means it allows developers to build programs using classes and objects. This concept is key to building scalable, reusable, and organized code.

In this guide, we’ll cover:

• What are classes and objects?

• How to define and use classes

• Constructors and the __init__() method

• Instance and class variables

• Defining methods

• Inheritance basics

• Tips, common pitfalls

• A complete example at the end

What are Classes and Objects?

Class

A class is a blueprint for creating objects. It defines a type of object by bundling data (attributes) and behaviors (methods) together.

Object

An object is an instance of a class. Think of a class as a recipe, and the object as the dish made from it.

Analogy:

• Class: Car

• Object: My red Toyota Corolla

Defining a Simple Class

class Person:
    pass

Now, let's create an object from this class:

p1 = Person()
print(p1)

Output:

<__main__.Person object at 0x...>

We’ve created an instance (p1) of the class Person.

Adding Attributes with __init__()

The __init__() method is the constructor in Python. It initializes the object when it is created.

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

Creating and using an object:

p1 = Person("Alice", 30)
print(p1.name)  # Alice
print(p1.age)   # 30

• self refers to the instance being created.

• self.name and self.age are instance variables.

Defining Methods

You can add functions (called methods) to a class:

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hi, I am {self.name}")

Usage:

p = Person("Bob")
p.greet()  # Hi, I am Bob

Class Variables vs Instance Variables

Instance Variable:

Defined inside __init__(). Unique to each object.

Class Variable:

Shared among all instances of a class.

class Dog:
    species = "Canine"  # class variable

    def __init__(self, name):
        self.name = name  # instance variable

d1 = Dog("Max")
d2 = Dog("Buddy")

print(d1.species)  # Canine
print(d2.name)     # Buddy

Modifying Object State

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

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

c = Counter()
c.increment()
print(c.count)  # 1

Inheritance – Reusing Code

You can create a new class that inherits from another class.

class Animal:
    def speak(self):
        print("I make a sound")

class Dog(Animal):
    def speak(self):
        print("Bark!")

d = Dog()
d.speak()  # Bark!

• Dog inherits from Animal.

• You can override or extend base class methods.

Special Methods

Special methods (also known as dunder methods) start and end with double underscores.

__str__() – Object String Representation

class Person:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"Person: {self.name}"

p = Person("Eve")
print(p)  # Person: Eve

Other common special methods:

• __len__()

• __eq__()

• __add__()

✅ Complete Example – Bank Account

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

    def deposit(self, amount):
        self.balance += amount
        print(f"Deposited ${amount}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Insufficient funds")
        else:
            self.balance -= amount
            print(f"Withdrew ${amount}")

    def __str__(self):
        return f"{self.owner}'s balance: ${self.balance}"

Usage:

acc = BankAccount("Alice", 100)
print(acc)
acc.deposit(50)
acc.withdraw(30)
print(acc)

Output:

Alice's balance: $100
Deposited $50
Withdrew $30
Alice's balance: $120

⚠️ Common Pitfalls

Tips and Best Practices

• ✅ Use classes to model real-world objects.

• ✅ Keep methods short and focused.

• ✅ Use __str__() for readable print output.

• ✅ Prefer composition over inheritance unless necessary.

• ✅ Use access control conventions (_protected, __private) to indicate intent.

What’s Next?

• Inheritance and polymorphism

• Encapsulation with private/protected members

• Static methods and class methods

• Operator overloading

• Advanced OOP design patterns