How to Create a Class in Python

This guide walks you through creating a class in Python, the blueprint for objects that bundle data and functions together. By the end, you’ll know how to define a class, add attributes and methods, use constructors, and instantiate objectsâ€”skills that underpin almost every Python program, from small scripts to large applications.

What You’ll Need

Python 3 installed (any recent version, e.g., 3.8 or newer).
A text editor or IDE (like VS Code, PyCharm, or even Notepad).
Basic familiarity with Python functions and variables.

Step-by-Step

Understand the purpose of a class. A class is a template for creating objects. It groups related data (attributes) and behaviors (methods) into a single unit. For example, a Car class might have attributes like color and speed, and methods like accelerate().
Start with the class keyword. Type class, followed by the class name in CamelCase (e.g., Car), and a colon. The class body is indented. Example:
```
class Car:
    pass
```
The pass statement is a placeholder so the class is syntactically valid.
Add a constructor method (__init__). This special method runs when you create an instance. It typically initializes instance attributes. The first parameter is always self, which refers to the instance being created. Example:
```
class Car:
    def __init__(self, color, speed=0):
        self.color = color
        self.speed = speed
```
Here, color is required, speed has a default value.

Define instance methods. Methods are functions inside the class that operate on the instance. They also take self as the first parameter. Example:

class Car:
    def __init__(self, color, speed=0):
        self.color = color
        self.speed = speed

    def accelerate(self, amount):
        self.speed += amount
        return self.speed

Now you can call my_car.accelerate(10).

Create an instance (object). Call the class like a function, passing arguments for the required parameters. Example:
```
my_car = Car("red")
```
This creates a Car object with color set to "red" and speed at 0.
Access attributes and call methods. Use dot notation: object.attribute or object.method(). Example:
```
print(my_car.color)  # red
my_car.accelerate(20)
print(my_car.speed)  # 20
```
Add class attributes (optional). Attributes defined directly in the class body (outside methods) are shared by all instances. Example:
```
class Car:
    wheels = 4  # class attribute

    def __init__(self, color):
        self.color = color
```
Access via Car.wheels or instance.wheels.
Use __str__ for readable output (optional). Define this method to control what print() shows for your object. Example:
```
def __str__(self):
    return f"Car(color={self.color}, speed={self.speed})"
```
Then print(my_car) gives a nice string.
Test your class. Write a small block to create objects and call methods to ensure everything works as expected.

Common Mistakes

Forgetting self as the first parameter in methods. Without it, Python will raise a TypeError when you call the method.
Using self outside a method or forgetting it in the __init__ signature.
Misspelling __init__ (double underscores on both sides). If you spell it _init_ or __init, the constructor won’t run and your attributes won’t be set.
Treating class attributes like instance attributes. If you assign my_car.wheels = 3, it creates an instance attribute that shadows the class one, but other instances remain at 4.
Not indenting the class body correctly. Python relies on indentation; a missing indent will cause an IndentationError.

Tips

Use meaningful class and method names that clearly describe their purpose.
Keep methods short and focused on a single responsibility.
Use type hints (e.g., def __init__(self, color: str) -> None:) to improve readability and catch errors early.
Use properties (@property) if you need controlled access to attributes.
Leverage inheritance to reuse code: class ElectricCar(Car):.

Troubleshooting

Getting TypeError: __init__() takes 1 positional argument but 2 were given â€“ You likely forgot to include self in the __init__ definition, or you’re passing too many arguments. Check the signature.
AttributeError: ‘Car’ object has no attribute ‘color’ â€“ The __init__ didn’t run (maybe misspelled) or you’re trying to access an attribute that was never assigned.
IndentationError: expected an indented block â€“ Ensure every line inside the class is indented consistently (usually 4 spaces). Avoid mixing tabs and spaces.
Method not working as expected â€“ Check if you’re modifying a class attribute instead of an instance attribute. Use self.attribute to assign instance values.
Object prints as <__main__.Car object at 0x...> â€“ Define __str__ to get a human-readable representation.

Frequently Asked Questions

1. What is the difference between a class and an instance?
A class is the blueprint; an instance is a specific object created from that blueprint. For example, Car is the class, and my_car = Car("red") creates an instance.

2. Do I always need an __init__ method?
No. If your class doesn’t need to initialize attributes, you can omit it. But most classes benefit from having one to set up initial state.

3. Can I create a class without any methods?
Yes, you can have a class with only attributes (though it’s rare). Use class MyClass: and define class attributes inside.

4. How do I make a method that doesn’t use self?
Use a static method with @staticmethod. It doesn’t receive the instance or class as the first argument. Example: @staticmethod def helper():.

5. What is self exactly?
self is a reference to the current instance. It’s how methods access the instance’s own attributes and other methods. It’s not a keyword; you could name it anything, but self is the convention.

6. Can I have multiple constructors?
Python doesn’t allow multiple __init__ methods. Instead, use default arguments or class methods like @classmethod to create alternative constructors.

General steps for current mainstream versions; menus can differ by device and version. See the disclaimer or report an error.

More in this bed

The whole Tech How-To bed →