How to Resolve "TypeError: unsupported operand type(s) for ...: NoneType" in Python

In Python, the TypeError: unsupported operand type(s) for ...: 'NoneType' and ... error (where ... is an operator and another type) occurs when you try to perform an operation that involves None where a different data type (like an integer, string, float, etc.) is expected.

This guide explains the common causes of this error and how to fix it, focusing on best practices for handling potentially None values.

Understanding NoneType and Operators

None is a special value in Python representing the absence of a value. It's the sole value of the type NoneType. Many operators and functions in Python expect specific data types as operands (e.g., + expects numbers or strings, * expects numbers, / expects numbers). When you try to use None with an operator that doesn't support it, you get a TypeError.

Common Causes and Solutions

Functions Returning None Implicitly

A very common cause is a function that doesn't explicitly return a value. In Python, a function that doesn't have a return statement (or has a return statement with no value) implicitly returns None:

def do_math():
    print(5 * 5)  # Prints, but doesn't RETURN anything

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

Solution: Ensure your functions always return the expected value:

def do_math():
    return 5 * 5

result = do_math()
print(result)      # Output: 25
print(result + 10) # Output: 35

Functions with Conditional Returns

If a function has a return statement inside an if block (or other conditional), make sure all execution paths return a value of the expected type:

def get_number(x):
    if x > 10:
        return x

result = get_number(5)  # result is None

print(result)           # Output: None

Solution: Add an else clause (or a return after the if block) to ensure a value of the correct type is always returned:

def get_number(x):
    if x > 10:
        return x
    else:
        return 0  # Return a default value (or raise an exception)

result = get_number(5)
print(result + 5)  # Output: 5

Methods that Modify In-Place

Many built-in Python methods modify objects in-place and return None. Common examples include list.sort(), list.reverse(), list.append(), and dict.update(). Do not assign the result of these methods back to a variable if you intend to use the modified object:

my_list = [3, 1, 4, 2]


my_list.sort()  # Correct: modifies the list in place.
print(my_list)  # Output: [1, 2, 3, 4]

print(my_list + [5]) #Output: [1, 2, 3, 4, 5]

Specific TypeError Examples and Solutions

Let's look at the specific TypeError messages you listed and provide direct solutions. The underlying cause is always the same: using None with an operator that doesn't support it.

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

num_1 = None
num_2 = 15

if num_1 is not None:
    result = num_1 + num_2
    print(result)
else:
    print('variable stores a None value') # Output: variable stores a None value

num_1 = None
num_2 = 15
result = (num_1 or 0) + num_2  # Use 0 as the default if num_1 is None

print(result)  # Output: 15

• Check for None or set a default value before using the + operator.
• The or operator returns 0 because an empty variable is falsy.

TypeError: unsupported operand type(s) for *: 'NoneType' and 'NoneType'

value_1 = None
value_2 = None


if value_1 is not None and value_2 is not None:
    result = value_1 * value_2
result = (value_1 or 1) * (value_2 or 1) # Use 1 as a default, it will result in the other number

TypeError: unsupported operand type(s) for /: 'NoneType' and 'float'

num_1 = None
num_2 = 2.0


if num_1 is not None and num_2 != 0:
    result = num_1 / num_2
    print(result)
result = (num_1 or 1) / num_2 if num_2 != 0 else 0 # Avoid ZeroDivisionError

• Check for None or set a default value before using the / operator.
• Also, check for a possible ZeroDivisionError.

TypeError: unsupported operand type(s) for +: 'NoneType' and 'str'

str_1 = None
str_2 = 'world'


if str_1 is not None:
    result = str_1 + str_2
else:
    result = str_2 # Handle None case.

result = (str_1 or "") + str_2

• Check for None or set a default value before using the + operator.

Defensive Programming: Preventing NoneType Errors

The best way to handle these errors is to prevent them:

• Checking for None: Use if my_variable is not None: before accessing attributes or calling methods.
• Using dict.get() with Defaults: my_dict.get('key', default_value) prevents KeyError and allows you to handle missing keys gracefully.
• Always Return a Value: Ensure all code paths in your functions return a value of the expected type (or explicitly return None if that's the intended behavior). Use type hints to make your intentions clear.
• Use Type Hints: Type hints (def my_function(x: int) -> List[str]:) combined with a type checker (like MyPy) can catch many of these errors before you even run your code.

Conclusion

The TypeError: unsupported operand type(s) for ...: 'NoneType' and ... errors are common in Python, but easily fixed.

The root cause is always using None where a different type (int, float, str, etc.) is expected.

By checking for None values, providing default values, and ensuring your functions always return the expected type, you can write more robust and error-free Python code.

The most important technique is to check for None before performing operations. Using type hints and a type checker like MyPy can help prevent these errors.