How to Fix Python TypeError: unsupported operand type(s) for +

Introduction

The TypeError: unsupported operand type(s) for +: '...' and '...' is one of the most common errors new Python programmers encounter. It occurs when you try to use the addition operator (+) on two objects of incompatible types. For example, you cannot directly add a number to a string or a list to a dictionary.

This guide will explain why this TypeError happens and provide clear solutions for handling different data types correctly.

What Causes This TypeError?

Python is a strongly typed language, which means it doesn’t automatically convert data types in most operations. The + operator behaves differently depending on the types of its operands:

• For numbers (int, float), it performs mathematical addition.
• For strings, it performs concatenation.
• For lists, it performs concatenation.
• For tuples, it performs concatenation.

The error arises when you mix types that don’t have a defined behavior for the + operator.

Common examples that raise the error:

1. Adding a string and an integer:

   age = 25
   message = "My age is " + age # Raises TypeError
   # TypeError: can only concatenate str (not "int") to str
   

2. Adding a list and a string:

   my_list = [1, 2, 3]
   my_string = "456"
   result = my_list + my_string # Raises TypeError
   # TypeError: can only concatenate list (not "str") to list
   

3. Adding a dictionary and a list:

   my_dict = {'a': 1}
   my_list = ['b', 2]
   result = my_dict + my_list # Raises TypeError
   # TypeError: unsupported operand type(s) for +: 'dict' and 'list'
   

How to Fix the Error

The solution is always to ensure that the operands are of a compatible type before using the + operator. This usually involves explicit type conversion.

1. Converting to String for Concatenation

When you want to combine a string with a number or another object for display purposes, convert the non-string object to a string using str().

Incorrect:

age = 25
message = "I am " + age + " years old."

Correct:

age = 25
# Convert the integer 'age' to a string
message = "I am " + str(age) + " years old."
print(message) # Output: I am 25 years old.

A more modern and readable way to format strings is using f-strings (formatted string literals), which automatically handle the conversion.

Best Practice (f-strings):

age = 25
message = f"I am {age} years old."
print(message) # Output: I am 25 years old.

2. Converting to Numbers for Addition

If you receive numeric data as strings (e.g., from user input or a file), you must convert them to a numeric type (int or float) before performing arithmetic.

Incorrect:

num1_str = "10"
num2_int = 20
result = num1_str + num2_int # Raises TypeError

Correct:

num1_str = "10"
num2_int = 20
# Convert the string 'num1_str' to an integer
result = int(num1_str) + num2_int
print(result) # Output: 30

Be sure to handle potential ValueError if the string is not a valid number.

num_str = "hello"
try:
    num_int = int(num_str)
except ValueError:
    print(f"'{num_str}' cannot be converted to an integer.")

3. Handling Other Data Types

When working with other data types like lists or dictionaries, you need to think about what “addition” means in your context.

• Adding an item to a list: Use the append() method or list concatenation with another list.

  my_list = [1, 2, 3]
  item_to_add = 4
      
  # To add a single item
  my_list.append(item_to_add)
  print(my_list) # Output: [1, 2, 3, 4]
      
  # To concatenate with another list
  another_list = [5, 6]
  combined_list = my_list + another_list
  print(combined_list) # Output: [1, 2, 3, 4, 5, 6]
  

• “Adding” to a dictionary: This usually means updating it with new key-value pairs. Use the update() method or direct assignment.

  my_dict = {'a': 1}
      
  # Add a new key-value pair
  my_dict['b'] = 2
      
  # Update with another dictionary
  another_dict = {'c': 3, 'd': 4}
  my_dict.update(another_dict)
      
  print(my_dict) # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  

Conclusion

The TypeError: unsupported operand type(s) for + is a fundamental error in Python that highlights the importance of data types. To fix it, you must perform explicit type conversion to ensure that you are only using the + operator on compatible types. Use str() for string concatenation, int() or float() for mathematical addition, and appropriate methods like append() or update() for other data structures. Adopting f-strings for string formatting will also help you write cleaner and more error-free code.

Professional Depth Check

For How to Fix Python TypeError: unsupported operand type(s) for +, the practical standard is not whether the reader can repeat one instruction once. Treat the topic as a reproducible debugging procedure: verify runtime environment, exact error boundary, minimal reproduction, and rollback path before drawing a conclusion. The result should be written as a small decision record, because future readers need to know which fact was observed, which assumption was used, and which condition would change the answer.

Evidence That Makes the Guidance Reliable

Use objective evidence before changing a workflow. Good evidence includes full command output, version numbers, changed files, and expected versus actual behavior. If two pieces of evidence conflict, keep the conflict visible instead of smoothing it over. For example, a successful quick fix is still weak evidence if the same input, account, dependency, or device state has not been tested again. A durable article should help the reader distinguish a confirmed fix from a plausible fix.

Review Table

Review Item	What To Confirm	Why It Matters
Scope	The exact case covered by this article	Prevents over-applying the advice
Baseline	The state before any change	Makes rollback and comparison possible
Change	The smallest action taken	Reduces hidden side effects
Result	The observed output after the change	Separates evidence from expectation
Recheck	When to revisit the conclusion	Keeps the post accurate over time

Edge Cases and Failure Modes

The main risks are fixing the symptom while leaving the root cause, and mixing unrelated changes into the same test. When the situation involves production data, personal information, money, health, legal rights, or security recovery, the conservative path is to stop and collect evidence before applying a broad fix. The same title can describe very different cases, so the reader should compare their environment with the assumptions in the post before copying commands or decisions.

Maintenance Standard

Recheck this guidance after dependency, operating-system, or build-tool changes. A useful update does not need to rewrite the entire post; it should confirm whether the examples, links, commands, screenshots, and decision criteria still match current behavior. If the old conclusion remains valid, record the check date. If it changes, explain what changed and why the previous advice is no longer enough.

Related Reading

Continue with these related posts from the same topic area.

• How to Fix “SSL: CERTIFICATE_VERIFY_FAILED” Error in Python on Windows
• How to Fix “Permission denied (publickey)” Error with Git on Windows