Resolving Python TypeError: Unsupported Operand Type(s) for +: 'int' and 'str'

Problem Background and Error Analysis

In Python programming learning, type errors represent one of the most frequent challenges encountered by beginners. Among these, the TypeError: unsupported operand type(s) for +: 'int' and 'str' error message is particularly common. The core issue stems from Python's strong typing characteristics—different types of operands cannot directly perform certain operations.

Error Scenario Reproduction

Consider the following typical learning scenario code:

num1 = int(input("What is your first number? "))
num2 = int(input("What is your second number? "))
num3 = int(input("What is your third number? "))
numlist = [num1, num2, num3]
print(numlist)
print("Now I will remove the 3rd number")
print(numlist.pop(2) + " has been removed")
print("The list now looks like " + str(numlist))

When users input numbers, the program throws a type error at the line print(numlist.pop(2) + " has been removed"). This occurs because numlist.pop(2) returns an integer value, while " has been removed" is a string. In Python, the + operator has no defined behavior for combinations of integers and strings.

Detailed Solution Approaches

Method 1: Explicit Type Conversion

The most straightforward solution involves explicitly converting the integer to a string:

print(str(numlist.pop(2)) + " has been removed")

Here, the str() function converts the integer returned by the pop operation into a string, enabling the + operator to perform string concatenation. This method clearly expresses developer intent and maintains good code readability.

Method 2: Utilizing Print Function Parameter Handling

Python's print() function can accept multiple parameters, automatically separating them with spaces:

print(numlist.pop(2), "has been removed")

This approach avoids the need for type conversion since the print function internally handles output for different parameter types. When parameters are separated by commas, Python automatically inserts spaces between them to create coherent output.

Method 3: String Formatting

Using string formatting methods provides more flexible output handling:

print("{} has been removed".format(numlist.pop(2)))

The {} in the format string serves as a placeholder, and the .format() method inserts parameters into corresponding positions. This method is particularly useful for complex output formatting and maintains clear code intent.

Deep Understanding of Type Systems

The referenced article further illustrates the prevalence of type errors. In the time calculator implementation, developers encountered a similar issue: new_day_index = (index_day_of_week + (added_days)) % 7, where added_days unexpectedly became an empty string instead of the expected integer.

This situation highlights the characteristics of Python's dynamic type system—variable types are determined at runtime. When added_days is initialized as an empty string rather than 0, subsequent arithmetic operations fail. The correct approach should be:

added_days = 0  # Instead of added_days = ""

Debugging and Prevention Strategies

To avoid such errors, the following strategies are recommended:

First, clarify type intentions during variable initialization. As shown in the referenced article, initializing numerical variables to 0 rather than empty strings prevents subsequent type confusion.

Second, employ type checking tools. Although Python is a dynamically typed language, developers can use the type() function or add assertions at critical points to verify variable types:

assert isinstance(added_days, int), "added_days should be integer"

Finally, adopt defensive programming practices. When uncertain about variable types, explicit type conversion can be applied:

added_days = int(added_days) if added_days else 0

Extended Applications and Best Practices

In practical development, type errors are not limited to the + operator. Other operators like -, *, / encounter similar issues. Understanding Python's type conversion rules is crucial:

Python supports limited implicit type conversion, primarily in numerical operations (such as integer and floating-point calculations). However, for mixed operations involving strings and other types, explicit conversion is typically required.

In modern Python development, f-strings provide a more concise string formatting approach:

removed_number = numlist.pop(2)
print(f"{removed_number} has been removed")

This method combines readability with performance advantages and represents the recommended approach for Python 3.6 and later versions.

Conclusion

Type errors represent important milestones in Python learning journeys. By understanding error root causes, mastering multiple solution approaches, and adopting preventive programming strategies, developers can write more robust Python code efficiently. The key lies in recognizing Python's type system design philosophy—explicit is better than implicit—thus clearly expressing type intentions in code.