Skip to content

Handling Errors and Exceptions When Type Conversion Fails in Python

Updated: at 03:12 AM

Type conversion is the process of converting values from one data type to another in Python. This is done using built-in functions like int(), float(), str(), etc. However, invalid conversions can often lead to errors and exceptions being raised. Properly handling these cases is an important aspect of writing robust Python code.

In this comprehensive guide, we will learn about the common errors and exceptions encountered during type conversions in Python. We will cover techniques to gracefully handle failed type conversions using try/except blocks, check functions, and custom exception classes. Example code snippets are provided to illustrate real-world use cases for exception handling when dealing with incompatible data types.

By the end of this guide, you will have an in-depth understanding of handling errors and exceptions when automatic type conversion fails in Python. This will help you write more resilient code that continues execution and provides meaningful feedback even in the presence of invalid data.

Table of Contents

Open Table of Contents

Common Type Conversion Errors and Exceptions in Python

Here are some of the common errors and exceptions that can occur when attempting to convert between incompatible types in Python:


A ValueError is raised when the type conversion fails due to the data not matching the required structure or constraints of the target type. For example:

# ValueError: invalid literal for int() with base 10: 'foo'

Trying to convert the string ‘foo’ to an integer fails because it does not contain numeric digits.


A TypeError occurs when the object type is incompatible with the target type. For example:

int([1, 2, 3])
# TypeError: int() argument must be a string, a bytes-like object or a number, not 'list'

Trying to convert a list to an integer directly does not work as lists have a different type structure than int.


An OverflowError happens when the value is too large or too small to be represented by the target type. For example:

# OverflowError: int too large to convert to float

The string contains a value too large for the 64-bit integer type.


An IndexError can occur when trying to convert a sequence type like string or tuple but providing an invalid index. For example:

# IndexError: string index out of range

Trying to access index 5 of the ‘123’ string fails as the sequence length is only 3.

Handling Type Conversion Errors

Now that we have seen some common errors and exceptions that can occur when type conversions fail in Python, let’s look at ways to gracefully handle these cases using:

Properly handling failed conversions allows your program to continue execution instead of abruptly stopping when invalid data is encountered.

1. Try/Except Blocks

The best way to handle exceptions and errors from unconvertible types is to wrap the conversion code in a try/except block:

  number = int(user_input)
except ValueError:
  print("Invalid input. Please enter a number.")
  number = 0

The try block attempts to convert the user_input to an integer. If this fails due to an invalid value, the except block will catch the ValueError and handle it by printing a warning message and assigning a default value of 0 to number.

Multiple except blocks can be used to handle different exceptions:

  number = float(input)
except ValueError:
  print("Could not convert input to a number.")
except TypeError:
  print("Input type is not supported for conversion.")

Here ValueError and TypeError are caught separately to print more specific error messages.

2. Check Functions

Another method is to use check functions like isinstance() to validate the argument type before attempting conversion:

input = "123"

if isinstance(input, int):
  print("Input is already an integer.")
elif isinstance(input, str):
    input = int(input)
  except ValueError:
    print("Could not convert string to integer.")

This checks if the input is already an integer, and if not, tries converting the string. The ValueError is caught and handled after the type check.

For sequence types, you can check the element type using isinstance():

values = ["1", "2", "foo"]

integers = []

for val in values:
  if isinstance(val, int):
  elif isinstance(val, str):
      val = int(val)
    except ValueError:
      print(f"{val} could not be converted to int.")

This attempts to convert only strings to integers after validating the type to avoid exceptions on other data types.

3. Custom Exception Classes

If you need more specialized error handling, you can define custom exception classes inherit from Python’s built-in Exception class:

class InvalidConversionError(Exception):
  """Raised when conversion fails for a specific reason"""

def convert_to_int(value):
    return int(value)
  except ValueError:
    raise InvalidConversionError(f"{value} cannot be converted to int.") from None

# InvalidConversionError: foo cannot be converted to int.

The custom InvalidConversionError can provide more context about why the conversion failed compared to the generic ValueError.

Multiple custom exceptions can be defined this way to catch and handle different conversion errors:

class StringToIntError(Exception):

class FloatToIntError(Exception):

  num = int(input)
except ValueError as e:
  if isinstance(input, str):
    raise StringToIntError() from e
  elif isinstance(input, float):
    raise FloatToIntError() from e

This differentiates between a string vs float input when raising exceptions after checking the source type.

Real-World Examples of Handling Type Conversion Errors

Let’s now look at some real-world code examples that demonstrate how to gracefully handle type conversion errors and exceptions in Python:

Converting User Input to Numbers

When accepting numerical input from users, you need to validate and convert the values to numeric types:

while True:
  user_input = input("Enter a number: ")
    user_input = int(user_input)
  except ValueError:
    print("Invalid input, please enter a number.")

  print(f"You entered: {user_input}")

This keeps looping until the user enters a valid integer, while handling the ValueError from non-numeric strings.

Parsing Strings to Ints from a File

When loading data from a file, you may need to convert strings to integers:

import csv

numbers = []

with open('data.csv') as f:
  reader = csv.reader(f)
  for row in reader:
      number = int(row[0])
    except ValueError:
      print(f"Could not parse {row[0]} to int.")


This tries to parse each value to int, catching any formatting errors or non-numeric strings.

Handling Overflow Errors

When dealing with large numbers, overflows are a possibility:

  result = 2**1024
except OverflowError:
  print("Number too large, overflow error occurred.")
  result = float('inf')

The exponentiation may cause an overflow, which is handled by catching the exception and assigning infinity.

Parsing Data from JSON

When parsing JSON data, types may not match what you expect:

import json

data = '{"price": "20"}'

  product = json.loads(data)
  price = product['price']
  total = price * 1.13
except TypeError:
  print("Could not parse price field to number.")
  total = 0

This handles exceptions that occur if the JSON value is a string instead of number.

Best Practices for Handling Type Conversion Errors

Here are some best practices to keep in mind when handling exceptions and errors from failed type conversions in Python:


Handling type conversion errors using try/except blocks, check functions, and custom exceptions is an essential skill for Python developers. This guide provided a comprehensive overview of techniques, best practices, and real-world examples for gracefully handling exceptions when automatic conversion between incompatible types fails.

Robust type conversion error handling ensures your Python code continues functioning predictably even with invalid inputs. It improves the quality and reliability of applications by avoiding abrupt crashes due to uncaught exceptions. Implementing these exception handling best practices will save you many headaches in identifying and fixing bugs caused by unconvertible data types.

The key takeaways are:

By mastering these techniques for handling type conversion errors and exceptions, you can write more robust Python code ready for the real world.