Learn What Classes Are in Python: Absolute Beginners Tutorial

A Python class is a blueprint for creating objects. Once you understand how classes work, a large portion of Python's standard library and every third-party package you install will start making sense. This tutorial walks through everything a beginner needs: what a class is, how to write one, what __init__ and self actually do, and how to create and use instances.

Before Python had classes, programs were written as sequences of functions passing data around. That works for small scripts, but as programs grow it becomes hard to keep related data and behavior together. Classes solve that problem by letting you group both in one place.

What Is a Class?

Think of a class as a cookie cutter and instances as the cookies. The cookie cutter defines the shape, but it is not a cookie itself. Every time you use it, you get a new cookie with the same shape but potentially different toppings. In Python terms, the class defines the structure and behavior, and each instance is a separate object that follows that structure while holding its own data.

The Python documentation describes a class as providing a mechanism for bundling data and functionality together. A new class creates a new type of object, allowing new instances of that type to be made. The simplest possible class you can write looks like this:

class Dog:
    pass

That is a valid class. The pass keyword tells Python to do nothing — it is a placeholder when the body would otherwise be empty. This class has no attributes and no methods, but Python has registered it as a type you can create objects from.

What Is an Instance?

An instance is a specific object created from a class. You create one by calling the class like a function:

class Dog:
    pass

rex = Dog()
buddy = Dog()

print(type(rex))    # <class '__main__.Dog'>
print(rex is buddy) # False — two separate objects

rex and buddy are both instances of Dog. They are different objects in memory, meaning changes to one do not affect the other. The type() call confirms that rex is a Dog.

Anatomy of a Python Class

A real class does more than just exist — it holds data and behavior. The three elements you will see in almost every class are the __init__ method, instance attributes assigned through self, and additional methods that define what the object can do.

class Dog:
    """A simple class representing a dog."""

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

    def bark(self):
        print(f"{self.name} says: woof!")

    def describe(self):
        print(f"{self.name} is {self.age} year(s) old.")


rex = Dog("Rex", 4)
rex.bark()      # Rex says: woof!
rex.describe()  # Rex is 4 year(s) old.

What __init__ Does

__init__ is the initializer method. Python calls it automatically the moment you create a new instance. It is not a constructor in the strict sense (Python uses __new__ for that), but for beginners it acts like one: it sets up the instance's starting state. The double underscores on both sides of the name indicate it is a special method that Python knows about and calls at a specific moment.

What self Does

Every method in a class receives the current instance as its first argument. By convention that argument is named self. When you write rex.bark(), Python translates that call internally to Dog.bark(rex) — it passes rex as self. Inside bark, self.name therefore refers to rex.name.

You must include self as the first parameter in every instance method signature, but you never pass it explicitly when calling the method. Python handles that automatically.

"Classes provide a means of bundling data and functionality together." — Python Software Foundation, Python 3 Tutorial

Class Attributes vs Instance Attributes

Python distinguishes between two kinds of attributes. Understanding the difference prevents a common category of beginner bugs.

An instance attribute is attached to a specific instance. You create it inside a method by assigning to self.something. Each instance has its own copy.

A class attribute is defined directly in the class body, outside any method. It is shared across all instances unless an instance overrides it with its own value of the same name.

class Dog:
    species = "Canis lupus familiaris"  # class attribute — shared

    def __init__(self, name):
        self.name = name  # instance attribute — unique per object


rex   = Dog("Rex")
buddy = Dog("Buddy")

print(rex.species)    # Canis lupus familiaris
print(buddy.species)  # Canis lupus familiaris — same value
print(rex.name)       # Rex
print(buddy.name)     # Buddy — different values

Modifying a class attribute through the class itself affects all instances that have not overridden it. Modifying it through an instance creates a new instance attribute that shadows the class attribute for that instance only.

Putting it all together, a complete BankAccount class looks like this:

class BankAccount:
    """Represents a simple bank account."""

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

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

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

    def show_balance(self):
        print(f"{self.owner}'s balance: {self.balance}")


account = BankAccount("Alice", 200)
account.deposit(50)       # Deposited 50. New balance: 250
account.withdraw(300)     # Insufficient funds.
account.show_balance()    # Alice's balance: 250

Python Classes: Key Learning Points

1. A class is defined with the class keyword and a PascalCase name. It is a blueprint, not an object itself.
2. __init__ runs automatically when you create an instance and is where you set up instance attributes using self.
3. self is always the first parameter of an instance method and refers to the calling instance. You never pass it manually — Python does.
4. Instance attributes (set with self.attr) belong to one object. Class attributes (set in the class body) are shared by all instances.
5. You access attributes and call methods using dot notation: obj.attribute and obj.method().

Classes are the foundation of object-oriented programming in Python. Once you are comfortable with what is covered here — defining a class, writing __init__, using self, and creating instances — you are ready to move on to inheritance, where one class can build on another.