Skip to main content

How to Handle TypeError Exceptions in Python Type Casting

In Python, type casting (converting data from one type to another, e.g., str(x) or int(y)) is a common operation. However, not all objects can be converted to all types. A TypeError specifically occurs when you attempt to cast an object type that the conversion function does not support, such as trying to convert a list directly into an integer or None into a string in specific contexts.

This guide explains why TypeError occurs during casting, how to distinguish it from ValueError, and how to implement robust error handling using try-except blocks and type checking.

Understanding TypeError vs. ValueError​

Before fixing the error, it is crucial to distinguish between the two most common casting errors:

  • ValueError: The type is correct (e.g., a string), but the content is invalid.
    • Example: int("hello") (Cannot make "hello" an integer).
  • TypeError: The type itself is incompatible with the conversion function.
    • Example: int([1, 2]) (Cannot convert a list to an integer).
    • Example: int(None) (Cannot convert NoneType to an integer).

Reproducing the Error​

Attempting to cast an incompatible data structure causes a TypeError.

data_list = [1, 2, 3]
data_none = None

try:
    # ⛔️ Incorrect: int() does not know how to handle a list
    result = int(data_list)
    print(result)
except TypeError as e:
    print(f"Error 1: {e}")

try:
    # ⛔️ Incorrect: int() cannot convert None
    result = int(data_none)
    print(result)
except TypeError as e:
    print(f"Error 2: {e}")

Output:

Error 1: int() argument must be a string, a bytes-like object or a real number, not 'list'
Error 2: int() argument must be a string, a bytes-like object or a real number, not 'NoneType'

The most Pythonic approach is the "Easier to Ask for Forgiveness than Permission" (EAFP) principle. Wrap the casting operation in a try-except block to catch the error and define a fallback behavior.

It is often best to catch both TypeError and ValueError to ensure your program doesn't crash regardless of whether the input is the wrong type (list) or wrong content (text).

def safe_cast_to_int(value, default=0):
    try:
        # ✅ Correct: Attempt the cast
        return int(value)
    except (TypeError, ValueError) as e:
        # Handle the error by logging it or returning a default
        print(f"Cast failed for input '{value}' ({type(value).__name__}): {e}")
        return default

# Scenario 1: Casting a list (TypeError)
print(f"Result 1: {safe_cast_to_int([1, 2])}")

# Scenario 2: Casting bad text (ValueError)
print(f"Result 2: {safe_cast_to_int('abc')}")

# Scenario 3: Valid input
print(f"Result 3: {safe_cast_to_int('42')}")

Output:

Cast failed for input '[1, 2]' (list): int() argument must be a string, a bytes-like object or a real number, not 'list'
Result 1: 0
Cast failed for input 'abc' (str): invalid literal for int() with base 10: 'abc'
Result 2: 0
Result 3: 42
tip

When casting, catching (TypeError, ValueError) as a tuple covers almost all failure scenarios.

Method 2: Defensive Coding with isinstance()​

If you prefer to "Look Before You Leap" (LBYL), you can check the variable's type using isinstance() before attempting the conversion. This is useful when you only want to process specific known types.

def explicit_cast(value):
    # ✅ Check if the value is a valid type for casting
    if isinstance(value, (str, int, float)):
        return int(value)
    else:
        print(f"Skipping incompatible type: {type(value).__name__}")
        return None

# Valid types
print(f"Float to Int: {explicit_cast(10.5)}")

# Invalid types
print(f"List to Int: {explicit_cast([10, 5])}")

Output:

Float to Int: 10
Skipping incompatible type: list
List to Int: None

Common Scenario: Handling NoneType​

TypeError frequently occurs when a variable expected to be a number is actually None (e.g., missing data from an API or database). You can fix this with a simple conditional check or the or operator.

Using the or operator​

This approach works well if you want None to be treated as 0 or a default value.

user_input = None

# ⛔️ Incorrect: This raises TypeError
# val = int(user_input) 

# ✅ Correct: If user_input is None, it defaults to 0 before casting
# Note: This assumes 0 is a valid fallback
val = int(user_input or 0)
print(f"Value: {val}")

Output:

Value: 0
warning

Be careful with the or operator if valid inputs could be empty strings "" or 0, as these evaluate to False and will trigger the default value. Explicit if x is not None: checks are safer for strict logic.

Conclusion​

To handle TypeError during type casting:

  1. Use try-except (TypeError, ValueError) for the most robust solution that handles both incompatible types and invalid content.
  2. Use isinstance() if you want to strictly allow only specific input types.
  3. Handle None explicitly using conditional logic or defaults (val or 0) to prevent NoneType casting errors.

Table of Contents