Classes and Objects

A class is a blueprint that defines the structure and behavior of objects. Objects are instances of classes that hold actual data. Think of a class as a template that specifies what data an object will contain and what actions it can perform.

Creating Your First Class

Define a class using the class keyword followed by the class name (PascalCase convention). Create objects by calling the class like a function.

# Define a simple class
class Dog:
    pass  # Empty class placeholder

# Create objects (instances) of the class
dog1 = Dog()
dog2 = Dog()

# Each object is independent
print(type(dog1))  # Output: 
print(dog1 == dog2)  # Output: False (different objects)

Adding Attributes Directly

You can add attributes to objects dynamically after creation. However, this approach is not recommended for real code since different objects might have inconsistent attributes.

class Dog:
    pass

# Create object and add attributes
dog1 = Dog()
dog1.name = "Buddy"
dog1.age = 3

dog2 = Dog()
dog2.name = "Max"
# dog2 has no age attribute!

print(dog1.name)  # Output: Buddy
print(dog2.name)  # Output: Max

# Define empty Car class
class Car:
    pass

# Create two instances
car1 = Car()
car2 = Car()

# Verify they are different objects
print(car1 is car2)  # Output: False
print(type(car1))    # Output: 

class Book:
    pass

book = Book()
book.title = "Python Basics"
book.author = "John Doe"
book.pages = 250

print(f"{book.title} by {book.author}")
# Output: Python Basics by John Doe

class Student:
    pass

# Create students
s1, s2, s3 = Student(), Student(), Student()
s1.name, s1.grade = "Alice", "A"
s2.name, s2.grade = "Bob", "B"
s3.name, s3.grade = "Carol", "A"

students = [s1, s2, s3]
for s in students:
    print(f"{s.name}: {s.grade}")

The __init__ method is a special constructor that runs automatically when you create an object. It initializes the object's attributes, ensuring every instance starts with proper data. The self parameter refers to the object being created.

Basic __init__ Usage

Define __init__ with self as the first parameter (always required), followed by any parameters you need for initialization.

class Dog:
    def __init__(self, name, age):
        self.name = name  # Instance attribute
        self.age = age    # Instance attribute

# Create objects with initial values
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

print(dog1.name)  # Output: Buddy
print(dog2.age)   # Output: 5

Default Parameter Values

You can provide default values for parameters, making some arguments optional when creating objects.

class Dog:
    def __init__(self, name, age=1, breed="Unknown"):
        self.name = name
        self.age = age
        self.breed = breed

# Different ways to create objects
dog1 = Dog("Buddy")           # Uses defaults
dog2 = Dog("Max", 3)          # Custom age, default breed
dog3 = Dog("Rex", 2, "Husky") # All custom values

print(f"{dog1.name}, {dog1.age}, {dog1.breed}")
# Output: Buddy, 1, Unknown

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

rect = Rectangle(10, 5)
print(f"Width: {rect.width}, Height: {rect.height}")
# Output: Width: 10, Height: 5

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

acc1 = BankAccount("Alice", 1000)
acc2 = BankAccount("Bob")

print(f"{acc1.owner}: ${acc1.balance}")  # Alice: $1000
print(f"{acc2.owner}: ${acc2.balance}")  # Bob: $0

class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = max(0, price)      # Ensure non-negative
        self.quantity = max(0, quantity)

p1 = Product("Laptop", 999, 10)
p2 = Product("Phone", -50, -5)  # Invalid values

print(f"{p1.name}: ${p1.price} x {p1.quantity}")
print(f"{p2.name}: ${p2.price} x {p2.quantity}")
# Phone: $0 x 0 (corrected)

Methods are functions defined inside a class that operate on instance data. They always take self as the first parameter, giving them access to the object's attributes. Methods define the behavior of your objects.

Defining Instance Methods

Define methods like regular functions but inside the class body. Always include self as the first parameter to access the object's data.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        print(f"{self.name} says: Woof!")
    
    def get_info(self):
        return f"{self.name} is {self.age} years old"

dog = Dog("Buddy", 3)
dog.bark()            # Output: Buddy says: Woof!
print(dog.get_info()) # Output: Buddy is 3 years old

Methods That Modify State

Methods can modify the object's attributes, changing its state. This is how objects maintain and update their data over time.

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}. New balance: ${self.balance}")
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            print(f"Withdrew ${amount}. New balance: ${self.balance}")
        else:
            print("Insufficient funds!")

acc = BankAccount("Alice", 100)
acc.deposit(50)   # Deposited $50. New balance: $150
acc.withdraw(30)  # Withdrew $30. New balance: $120

Methods That Return Values

Methods can compute and return values based on the object's state. This is useful for calculations, data retrieval, and transformations.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)
    
    def is_square(self):
        return self.width == self.height

rect = Rectangle(5, 3)
print(f"Area: {rect.area()}")           # Area: 15
print(f"Perimeter: {rect.perimeter()}") # Perimeter: 16
print(f"Is square: {rect.is_square()}") # Is square: False

The __str__ Method

The __str__ method returns a string representation of the object. It is called automatically when you print an object or convert it to a string.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Dog({self.name}, {self.age} years)"

dog = Dog("Buddy", 3)
print(dog)  # Output: Dog(Buddy, 3 years)
# Without __str__, you'd see: <__main__.Dog object at 0x...>

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

rect = Rectangle(5, 4)
print(f"Area: {rect.area()}")  # Output: Area: 20

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

c = Counter()
c.increment()
c.increment()
c.increment()
print(c.get_count())  # Output: 3

class Circle:
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2
    
    def circumference(self):
        return 2 * 3.14159 * self.radius

circle = Circle(5)
print(f"Area: {circle.area():.2f}")      # Area: 78.54
print(f"Circumference: {circle.circumference():.2f}")  # 31.42

class TodoList:
    def __init__(self):
        self.tasks = []
    
    def add_task(self, task):
        self.tasks.append(task)
    
    def complete_task(self, task):
        if task in self.tasks:
            self.tasks.remove(task)
    
    def show_tasks(self):
        for task in self.tasks:
            print(f"- {task}")

todo = TodoList()
todo.add_task("Learn Python")
todo.add_task("Build project")
todo.show_tasks()
todo.complete_task("Learn Python")
todo.show_tasks()

class Player:
    def __init__(self, name, health=100):
        self.name = name
        self.health = health
    
    def take_damage(self, amount):
        self.health = max(0, self.health - amount)
    
    def heal(self, amount):
        self.health = min(100, self.health + amount)
    
    def is_alive(self):
        return self.health > 0

player = Player("Hero")
player.take_damage(30)
print(f"{player.name}: {player.health}HP")  # 70HP
player.heal(50)  # Capped at 100
print(f"Alive: {player.is_alive()}")  # True

Class attributes are shared by all instances, while instance attributes are unique to each object. Understanding the difference prevents subtle bugs and helps you design better classes.

Defining Both Types

Class attributes are defined directly in the class body. Instance attributes are defined inside __init__ using self.

class Dog:
    # Class attribute (shared by all instances)
    species = "Canine"
    count = 0
    
    def __init__(self, name, age):
        # Instance attributes (unique to each)
        self.name = name
        self.age = age
        Dog.count += 1  # Modify class attribute

dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

print(dog1.species)  # Canine (accessed via instance)
print(Dog.species)   # Canine (accessed via class)
print(Dog.count)     # 2 (shared counter)

The Shadowing Trap

Be careful when modifying class attributes through instances. Assigning via an instance creates a new instance attribute that shadows the class attribute.

class Dog:
    species = "Canine"
    
    def __init__(self, name):
        self.name = name

dog1 = Dog("Buddy")
dog2 = Dog("Max")

# This creates an INSTANCE attribute on dog1!
dog1.species = "Modified"

print(dog1.species)  # Modified (instance attr)
print(dog2.species)  # Canine (class attr)
print(Dog.species)   # Canine (unchanged!)

class Car:
    wheels = 4  # Class attribute
    
    def __init__(self, make, model):
        self.make = make
        self.model = model

car1 = Car("Toyota", "Camry")
car2 = Car("Honda", "Civic")

print(f"{car1.make} has {car1.wheels} wheels")
print(f"{car2.make} has {Car.wheels} wheels")

class Employee:
    total_employees = 0
    
    def __init__(self, name, department):
        self.name = name
        self.department = department
        Employee.total_employees += 1
    
    @classmethod
    def get_total(cls):
        return cls.total_employees

e1 = Employee("Alice", "Engineering")
e2 = Employee("Bob", "Marketing")
e3 = Employee("Carol", "Engineering")

print(f"Total employees: {Employee.get_total()}")  # 3

class Config:
    debug = False

c1 = Config()
c2 = Config()

# Shadowing - creates instance attribute
c1.debug = True
print(f"c1.debug: {c1.debug}")  # True (instance)
print(f"c2.debug: {c2.debug}")  # False (class)

# Correct way - modify class attribute
Config.debug = True
print(f"After class modification:")
print(f"c2.debug: {c2.debug}")  # True (from class)

Special methods (also called dunder methods for "double underscore") let your objects work with Python's built-in operators and functions. They enable features like comparison, arithmetic, iteration, and more, making your objects feel like native Python types.

__repr__ vs __str__

Both methods return strings, but serve different purposes. __str__ is for users (readable), __repr__ is for developers (unambiguous, ideally eval-able).

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"Point at ({self.x}, {self.y})"
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(str(p))   # Point at (3, 4)  - user-friendly
print(repr(p))  # Point(3, 4)      - recreatable
print(p)        # Point at (3, 4)  - uses __str__

Comparison Methods: __eq__ and Others

Implement comparison methods to make objects comparable with standard operators. This enables sorting and equality checks.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __eq__(self, other):
        if not isinstance(other, Person):
            return False
        return self.name == other.name and self.age == other.age
    
    def __lt__(self, other):
        return self.age < other.age
    
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)
p3 = Person("Alice", 30)

print(p1 == p3)  # True (same name and age)
print(p1 < p2)   # False (30 is not less than 25)
print(sorted([p1, p2]))  # [Person('Bob', 25), Person('Alice', 30)]

The __len__ Method

Implement __len__ to make your objects work with the built-in len() function. This is useful for container-like classes.

class Playlist:
    def __init__(self, name):
        self.name = name
        self.songs = []
    
    def add_song(self, song):
        self.songs.append(song)
    
    def __len__(self):
        return len(self.songs)
    
    def __repr__(self):
        return f"Playlist('{self.name}', {len(self)} songs)"

playlist = Playlist("Road Trip")
playlist.add_song("Song A")
playlist.add_song("Song B")
playlist.add_song("Song C")

print(len(playlist))  # 3
print(playlist)       # Playlist('Road Trip', 3 songs)

Arithmetic Operators: __add__ and Friends

Implement arithmetic methods to use operators like +, -, *, / with your objects. This is common for numeric or vector-like classes.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(3, 4)
v2 = Vector(1, 2)

print(v1 + v2)    # Vector(4, 6)
print(v1 - v2)    # Vector(2, 2)
print(v1 * 3)     # Vector(9, 12)

Making Objects Iterable: __iter__

Implement __iter__ to make your objects work in for loops. Return an iterator (often using yield or returning self).

class NumberRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end
    
    def __iter__(self):
        current = self.start
        while current <= self.end:
            yield current
            current += 1
    
    def __len__(self):
        return max(0, self.end - self.start + 1)

nums = NumberRange(1, 5)
for n in nums:
    print(n, end=" ")  # 1 2 3 4 5

print(list(nums))  # [1, 2, 3, 4, 5]

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    
    def __repr__(self):
        return f"Book('{self.title}', '{self.author}')"

book = Book("1984", "George Orwell")
print(repr(book))  # Book('1984', 'George Orwell')

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __eq__(self, other):
        if not isinstance(other, Point):
            return False
        return self.x == other.x and self.y == other.y

p1 = Point(3, 4)
p2 = Point(3, 4)
p3 = Point(1, 2)

print(p1 == p2)  # True
print(p1 == p3)  # False

class ShoppingCart:
    def __init__(self):
        self.items = []
    
    def add_item(self, item):
        self.items.append(item)
    
    def __len__(self):
        return len(self.items)

cart = ShoppingCart()
cart.add_item("Apple")
cart.add_item("Banana")
cart.add_item("Orange")

print(len(cart))  # 3

class Money:
    def __init__(self, amount, currency):
        self.amount = amount
        self.currency = currency
    
    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("Cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)
    
    def __repr__(self):
        return f"Money({self.amount}, '{self.currency}')"

m1 = Money(100, "USD")
m2 = Money(50, "USD")
print(m1 + m2)  # Money(150, 'USD')

# m3 = Money(100, "EUR")
# print(m1 + m3)  # ValueError!

Writing good classes requires more than just syntax knowledge. Following established best practices makes your code more maintainable, readable, and Pythonic. These guidelines help you design classes that are easy to use and understand.

Use Meaningful Names

Class names should be nouns that clearly describe what the class represents. Method names should be verbs describing actions.

# Bad: Vague or misleading names
class Data:
    def process(self): pass
    def do_thing(self): pass

# Good: Clear, descriptive names
class CustomerOrder:
    def calculate_total(self): pass
    def apply_discount(self, percent): pass
    def mark_as_shipped(self): pass

Keep __init__ Simple

The constructor should only initialize attributes. Avoid complex logic, I/O operations, or side effects in __init__.

# Bad: Complex logic in __init__
class Report:
    def __init__(self, filepath):
        self.filepath = filepath
        self.data = self._load_file()      # I/O in constructor
        self.processed = self._process()   # Complex logic
        self._send_notification()          # Side effect!

# Good: Simple initialization
class Report:
    def __init__(self, filepath):
        self.filepath = filepath
        self.data = None
        self.processed = False
    
    def load(self):
        """Load data from file."""
        self.data = self._read_file()
        return self
    
    def process(self):
        """Process the loaded data."""
        if self.data is None:
            raise ValueError("Call load() first")
        # Processing logic here
        self.processed = True
        return self

Validate Input Early

Check parameters at the start of methods and raise clear exceptions for invalid input.

class BankAccount:
    def __init__(self, owner, initial_balance=0):
        if not owner or not isinstance(owner, str):
            raise ValueError("Owner must be a non-empty string")
        if initial_balance < 0:
            raise ValueError("Initial balance cannot be negative")
        
        self.owner = owner
        self.balance = initial_balance
    
    def withdraw(self, amount):
        if not isinstance(amount, (int, float)):
            raise TypeError("Amount must be a number")
        if amount <= 0:
            raise ValueError("Amount must be positive")
        if amount > self.balance:
            raise ValueError(f"Insufficient funds: {self.balance} available")
        
        self.balance -= amount
        return self.balance

Use Properties for Controlled Access

Properties let you add validation or computation to attribute access without changing the interface.

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self.celsius = (value - 32) * 5/9

temp = Temperature(25)
print(temp.fahrenheit)   # 77.0
temp.fahrenheit = 100    # Sets celsius to 37.78
print(temp.celsius)      # 37.777...

Add Docstrings

Document your classes and methods with docstrings. They appear in help() and IDE tooltips.

class Rectangle:
    """
    A rectangle defined by width and height.
    
    Attributes:
        width (float): The width of the rectangle.
        height (float): The height of the rectangle.
    
    Example:
        >>> rect = Rectangle(10, 5)
        >>> rect.area()
        50
    """
    
    def __init__(self, width, height):
        """Initialize a Rectangle with given dimensions."""
        self.width = width
        self.height = height
    
    def area(self):
        """Calculate and return the area of the rectangle."""
        return self.width * self.height
    
    def perimeter(self):
        """Calculate and return the perimeter of the rectangle."""
        return 2 * (self.width + self.height)

# View documentation
help(Rectangle)

Visualize how classes and objects work with these interactive examples that break down the concepts step by step.

Class Builder Visualizer

See how a class definition translates into objects with their own data:

class Student:
    school = "Python Academy"
    
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    
    def study(self, hours):
        return f"{self.name} studied {hours}h"

# Create two students
alice = Student("Alice", "A")
bob = Student("Bob", "B")

# Each gets own attributes
# alice.name = "Alice"
# alice.grade = "A"
# bob.name = "Bob"
# bob.grade = "B"

# Call methods
print(alice.study(3))
# "Alice studied 3h"

# Access shared attribute
print(alice.school)
# "Python Academy"
print(bob.school)
# "Python Academy"

Object Inspector: Memory Model

Understand how objects are stored in memory and how attributes are resolved:

┌─────────────────────────────────────────────────────────────────────────┐
│                           CLASS: Student                                │
├─────────────────────────────────────────────────────────────────────────┤
│  Class Attributes (shared):                                             │
│  ┌─────────────────────┐                                                │
│  │ school = "Academy"  │◄─────────────────────┐                         │
│  └─────────────────────┘                      │                         │
│                                               │                         │
│  Methods (shared):                            │                         │
│  ┌─────────────────────┐                      │                         │
│  │ __init__(self,...)  │                      │                         │
│  │ study(self, hours)  │                      │                         │
│  └─────────────────────┘                      │                         │
└───────────────────────────────────────────────┼─────────────────────────┘
                                                │
            ┌───────────────────────────────────┼───────────────────┐
            │                                   │                   │
            ▼                                   ▼                   ▼
┌───────────────────┐               ┌───────────────────┐  (more instances)
│  OBJECT: alice    │               │  OBJECT: bob      │
├───────────────────┤               ├───────────────────┤
│ name = "Alice"    │               │ name = "Bob"      │
│ grade = "A"       │               │ grade = "B"       │
│ ──────────────────│               │ ──────────────────│
│ → points to class │               │ → points to class │
└───────────────────┘               └───────────────────┘

ATTRIBUTE LOOKUP:  alice.school
  1. Check alice's instance attributes → Not found
  2. Check Student class attributes → Found! Return "Academy"

Method Call Visualizer

Step through what happens when you call a method on an object:

class Counter:
    def __init__(self, start=0):
        self.value = start
    
    def increment(self, amount=1):
        self.value += amount
        return self.value

c = Counter(10)
result = c.increment(5)

Special Methods in Action

See how Python operators translate to special method calls:

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    def __add__(self, other):
        return Point(
            self.x + other.x,
            self.y + other.y
        )

p1 = Point(1, 2)
p2 = Point(3, 4)
p3 = p1 + p2  # Point(4, 6)

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    def __eq__(self, other):
        return (self.x == other.x and 
                self.y == other.y)

p1 = Point(1, 2)
p2 = Point(1, 2)
p1 == p2  # True