Skip to main content

How to Solve "TypeError: unsupported operand type(s)" with 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
# print(result + 10)  # ⛔️ TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

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
    # Missing return here!
    # else return 0

result = get_number(5)  # result is None

print(result)           # Output: None
# print(result + 5)     # ⛔️ TypeError

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 = my_list.sort() # ⛔️ WRONG! my_list is now None
# print(my_list + [5])     # ⛔️ TypeError

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

# And then you can use the my_list variable again
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

# ⛔️ TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
# result = num_1 + num_2
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

# Or, provide a default 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

# ⛔️ TypeError: unsupported operand type(s) for *: 'NoneType' and 'NoneType'
#result = value_1 * value_2

# Make sure both operands are not None. Use a default or check beforehand:
if value_1 is not None and value_2 is not None:
    result = value_1 * value_2
# or
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

# ⛔️ TypeError: unsupported operand type(s) for /: 'NoneType' and 'float'
#result = num_1 / num_2

# Check for None, and also check for division by zero!
if num_1 is not None and num_2 != 0:
    result = num_1 / num_2
    print(result)
# Or set a default:
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'

# ⛔️ TypeError: unsupported operand type(s) for +: 'NoneType' and 'str'
# result = str_1 + str_2

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

# Or, provide a default (empty string is often a good choice):
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.

Table of Contents