How to Resolve Python "TypeError: init() should return None, not 'X'"

When defining classes in Python, you might encounter the TypeError: __init__() should return None, not 'X' (where 'X' is the type of value you tried to return, like 'int', 'dict', or 'str'). This error arises because the special __init__ method, Python's instance initializer, has a specific purpose and is not supposed to explicitly return any value.

This guide explains the role of __init__ and why returning a value from it causes this error, showing you the straightforward fix.

Understanding the Error: The Role of __init__

In Python classes, the __init__ method serves as the initializer (often called the constructor, though technically __new__ is the constructor). Its primary responsibility is to set up the initial state of a newly created instance of the class. This typically involves assigning values passed during instantiation to instance attributes (using self).

Crucially, __init__ is not designed to create and return a value like a regular function might. Its job is purely to initialize the instance (self) after it has already been created (usually by the implicit call to __new__). Python expects __init__ to complete its setup and implicitly return None.

Cause: Explicit return Statement in __init__

The TypeError occurs when you include a return statement within your __init__ method that attempts to return anything other than None.

# Error Scenario
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
        print(f"Initializing product: {self.name}")
        # ⛔️ Problem: Returning a value from __init__
        return price # Attempting to return the price

try:
    # Instantiation triggers __init__
    # ⛔️ TypeError: __init__() should return None, not 'int' (or float)
    prod = Product("Laptop", 1200)
    print(prod.name)
except TypeError as e:
    print(e)

Python detects that __init__ tried to return an integer (price) instead of the expected None, leading to the TypeError during the object creation process.

Solution: Remove the return Statement

The fix is simple: Remove the explicit return statement from your __init__ method. Let the method finish its initialization tasks, and Python will handle the rest correctly.

# Corrected Version
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
        print(f"Initializing product: {self.name}")
        # ✅ No return statement here. __init__ implicitly returns None.

# ✅ Instantiation now works correctly
prod = Product("Laptop", 1200)
print(f"Product Name: {prod.name}")   # Output: Laptop
print(f"Product Price: {prod.price}") # Output: 1200

# The 'prod' variable holds the newly created and initialized instance.
print(f"Instance type: {type(prod)}") # Output: <class '__main__.Product'>

After removing return price, the __init__ method completes its job of setting self.name and self.price, implicitly returns None, and the instance creation process finishes successfully.

Why __init__ Doesn't Return Values

The process of creating an object (Product(...)) involves two main steps (simplified):

1. __new__(cls, ...): This special class method is responsible for creating the new instance. It's called first and does return the newly created, uninitialized instance. You usually don't need to define __new__ yourself unless you're doing advanced customization like subclassing immutable types.
2. __init__(self, ...): This instance method is then called automatically with the newly created instance passed as self. Its sole job is to initialize that instance (e.g., set self.name, self.price).

Since the instance is already created by the time __init__ runs, __init__ doesn't need to (and shouldn't) return anything. Its effect is achieved by modifying the self object.

Implicit Return of None

In Python, any function or method that reaches its end without an explicit return statement automatically returns None.

def my_function():
  print("Doing something")
  # No return statement

result = my_function()
print(result) # Output: None

The __init__ method adheres to this rule. By not having a return statement (or explicitly having return None, though that's unnecessary and unconventional), it fulfills Python's requirement.

Quick Checks: Typos and Indentation

While the return statement is the direct cause, ensure you haven't made other common mistakes:

• Spelling: Is it correctly spelled __init__ with double underscores on both sides?
• Indentation: Is the __init__ method correctly indented within the class block? Incorrect indentation could make Python think it's not part of the class.

Conclusion

The TypeError: __init__() should return None, not 'X' occurs specifically because you added a return statement with a value inside your class's __init__ method. Remember that __init__'s purpose is to initialize the instance (self) after creation, not to return a value.

To fix the error, simply remove the return statement from your __init__ method and allow it to implicitly return None.