Classes and Objects

What Will You Learn
In this tutorial, you’ll learn the essential building blocks of Object-Oriented Programming in Python: classes and objects. You'll discover how to define a class, create objects from it, and assign attributes and methods that bring your objects to life. The guide explains the difference between classes (blueprints) and objects (instances), with practical code examples that make abstract concepts easy to grasp. You'll also learn how to use constructors to initialize objects and how to work with instance variables and methods. By the end, you'll be ready to start organizing your code more logically and building scalable Python programs using OOP.

Learning classes and objects is a turning point in your journey with the language. It transforms how you think about code — from a sequence of instructions to a set of structured, reusable models. Most modern applications — from web frameworks to data pipelines — are built using object-oriented principles. If you want to build scalable, maintainable software, understanding classes and objects is essential.

Instead of repeating code or managing data manually, you create templates (classes) and let the interpreter handle complexity through objects. It’s how professional developers model real-world concepts like users, transactions, or products in clean and organized code. Mastering this topic gives you the foundation for writing professional-grade programs that grow without turning into chaos.

What Are Classes and Objects in Python?

A class in Python is a blueprint — a template for creating objects. An object is a concrete instance of a class, with its own data and behavior. Classes define what an object can do (methods) and what data it holds (attributes). You can think of a class as a form, and objects as filled-in forms with actual data. Each object created from the same class can hold different values but share the same structure. This structure helps organize your code and make it easier to maintain.

    # Example 1: Defining a class
    class Book:
        pass  # Empty class for now
  

In the example above, we define a class called Book. It currently does nothing (the pass statement is a placeholder), but you can add attributes and methods later to give it functionality. Classes can have attributes (data) and methods (functions) that define their behavior.

    # Example 2: Creating an object from a class
    class Dog:
        def bark(self):
            print("Woof!")

    my_dog = Dog()       # Create an object
    my_dog.bark()        # Call the method → Output: Woof!
  

In this example, we define a class Dog with a method bark. We then create an object my_dog from the class and call its bark method. This is how you interact with objects in Python. You can create multiple objects from the same class, each with its own state and behavior.

    # Example 3: Class with attributes
    class User:
        def __init__(self, name, age):
            self.name = name
            self.age = age

    user1 = User("Alice", 30)
    print(user1.name)     # Output: Alice
    print(user1.age)      # Output: 30
  

In this example, we define a class User with an __init__ method that initializes the object's attributes. When we create an object user1, we set its name and age attributes. This is how you define the state of an object.

How to Create Classes and Objects in Python?

Creating classes and objects in Python is straightforward. You define a class using the class keyword, and then you instantiate (create) objects from it by calling the class like a function. Inside the class, you typically define an __init__ method — a constructor that initializes the object’s attributes. Objects created from the class will each hold their own data but share the same structure and methods. This allows you to write cleaner, more reusable code. Let's walk through three quick examples:

    # Example 1: A simple empty class
    class Product:
        pass

    item = Product()  # Creates an object of class Product
  

In this example, we define a simple class Product without any attributes or methods. We then create an object item from this class. This is the basic structure of defining a class and creating an object in Python. You can add attributes and methods later to give it functionality.

    # Example 2: Class with attributes
    class Car:
        def __init__(self, brand, year):
            self.brand = brand
            self.year = year

    car1 = Car("Toyota", 2020)
    print(car1.brand)  # Output: Toyota
  

In this example, we define a class Car with an __init__ method that initializes the object's attributes brand and year. When we create an object car1, we pass the values "Toyota" and 2020 to set its attributes. This is how you define the state of an object in Python.

    # Example 3: Class with a method
    class Person:
        def __init__(self, name):
            self.name = name

        def greet(self):
            print(f"Hello, my name is {self.name}")

    p = Person("Emma")
    p.greet()  # Output: Hello, my name is Emma
  

In this example, we define a class Person with an __init__ method to set the name attribute and a method greet that prints a greeting. When we create an object p, we can call its greet method to see the output. This demonstrates how classes encapsulate both data and behavior.

What Are the Key Differences Between Classes and Objects in Python?

In Python, a class defines the structure, while an object brings that structure to life. A class is a reusable template, while an object is a single, real-world instance based on that template. Understanding the difference is crucial because code organization, memory management, and behavior logic depend on it. Classes describe what an object is and what it can do. Objects are actual data containers that interact with your application. Without this separation, your programs become harder to scale and maintain.

In summary, classes are the blueprints that define how objects should look and behave, while objects are the actual instances created from those blueprints. Understanding this distinction is key to mastering object-oriented programming in Python.

Common Beginner Mistakes

1. Forgetting to Use self in Method Definitions

One of the most frequent beginner errors when working with classes is forgetting to include self as the first parameter in instance methods. In Python, every instance method must accept self to access object-specific data. Without it, the interpreter throws an error because it doesn't understand how to pass the object reference.

    # Incorrect
    class Animal:
        def speak():
            print("Roar")

    lion = Animal()
    lion.speak()  # TypeError: speak() takes 0 positional arguments but 1 was given
  

The fix is simple: always include self as the first argument for instance methods.

    # Correct
    class Animal:
        def speak(self):
            print("Roar")

    lion = Animal()
    lion.speak()  # Output: Roar
  

2. Accessing Attributes Without self

Another typical mistake is referencing attributes inside the class without using self.. This leads to a NameError because the interpreter searches for a local variable rather than an object attribute.

    # Incorrect
    class Circle:
        def __init__(self, radius):
            radius = radius  # This does nothing

        def get_area(self):
            return 3.14 * radius * radius  # NameError: name 'radius' is not defined
  

Always use self to properly store and access instance attributes:

    # Correct
    class Circle:
        def __init__(self, radius):
            self.radius = radius

        def get_area(self):
            return 3.14 * self.radius * self.radius
  

3. Overwriting the Class Name with an Object

A subtle but critical error is assigning an object to the same name as the class. This overwrites the class reference and prevents you from creating new instances later.

    # Problem
    class Student:
        pass

    Student = Student()  # Now Student is an object, not a class
    new_student = Student()  # TypeError: 'Student' object is not callable
  

To avoid this, use different names for your class and your instances.

    # Correct
    class Student:
        pass

    student1 = Student()
    student2 = Student()
  

4. Assuming Class Attributes Are Instance-Specific

Beginners often define attributes directly inside the class body and assume these are unique to each object. However, such attributes are shared across all instances — known as class attributes. Changing one affects all.

    # Problem
    class Config:
        settings = []

    cfg1 = Config()
    cfg2 = Config()
    cfg1.settings.append("dark_mode")
    print(cfg2.settings)  # Output: ['dark_mode']
  

To have unique attributes per object, define them in the __init__ method using self:

    # Correct
    class Config:
        def __init__(self):
            self.settings = []
  

5. Trying to Use Methods Without Creating an Object

Another beginner issue is calling instance methods directly on the class without creating an object. Since instance methods require an object reference (self), Python throws a TypeError.

    # Incorrect
    class Math:
        def square(self, x):
            return x * x

    result = Math.square(5)  # TypeError
  

Always create an instance before calling an instance method:

    # Correct
    class Math:
        def square(self, x):
            return x * x

    m = Math()
    result = m.square(5)
    print(result)  # Output: 25
  

FAQ — Classes and Objects

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

car1 = Car("Toyota", 2022)
car2 = Car("Ford", 2021)
    

class User:
    platform = "web"  # Class attribute

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