The error stopped my script cold. I had a list of user inputs — some numbers, some not — and I was passing them straight to math.sqrt() without checking. Python threw ValueError and the whole pipeline froze. That was the moment I learned why type-safe input handling matters in Python.
Handling ValueError in Python comes up whenever a function gets an argument that has the right type but the wrong value. The function cannot do anything with it, so Python stops execution and raises an error. This article covers what ValueError looks like in practice, how to catch it with try/except, and how to proactively validate data before passing it to functions. By the end, you will know how to handle ValueError in Python functions and in data processing loops.
TLDR
- ValueError is raised when a function receives a valid type but invalid value
- try/except catches ValueError and lets the program keep running
- isinstance() and str.isdigit() catch type mismatches before they happen
- Multiple except blocks handle different error types cleanly
- Always validate external input — do not assume it is the type you need
What is ValueError in Python?
ValueError is one of Python’s built-in exceptions. It is raised when an operation or function receives an argument that has the right type overall but a value that the operation cannot handle. For example, int() accepts strings — but only numeric ones. Pass “abc” to int() and Python raises ValueError because “abc” is a string, which is a valid type for int(), but it does not represent a number, which int() requires.
Python raises ValueError at runtime, not when you define code. The error only surfaces when that line of code executes with bad data. That is why it catches many developers off guard — the code looks fine during a code review, but production data triggers the exception. This is the same behavior you would see with handling ValueError in Python for any data pipeline processing mixed input types.
Catching ValueError with try and except
The most direct way to handle ValueError is with a try/except block. Wrap the code that might raise ValueError inside try, and put your recovery or fallback logic inside except. The program keeps running instead of crashing. This pattern is the foundation of Python exception handling for any serious data pipeline.
Here is a simple example that tries to convert user input to an integer and handles the case where the input is not numeric.
user_input = input("Enter a number: ")
try:
number = int(user_input)
print(f"You entered {number}")
except ValueError:
print(f'"{user_input}" is not a valid integer')
Enter a number: abc
"abc" is not a valid integer
The try block runs first. If int(user_input) succeeds, Python skips the except block and continues. If int() raises ValueError, Python jumps immediately to the except block and runs that code instead. The program never crashes.
Using try/except with math.sqrt()
I ran into the problem I described at the start when processing a batch of user-supplied values for a square root calculation. Passing a negative number or a non-numeric string to math.sqrt() raises ValueError. Here is how I handled it.
import math
values = ["16", "-4", "hello", "25"]
for val in values:
try:
num = float(val)
result = math.sqrt(num)
print(f"sqrt({val}) = {result:.2f}")
except ValueError:
print(f"Cannot compute sqrt of {val}")
sqrt(16) = 4.00
Cannot compute sqrt of -4
Cannot compute sqrt of hello
sqrt(25) = 5.00
This pattern works well for processing lists of mixed data. The loop moves through every item, and the except block handles each bad value without stopping the whole loop. You can apply the same pattern when reading user input in Python or processing data from files.
Catching Multiple Exception Types
Sometimes a single block of code can raise different exceptions. You can list multiple except blocks to handle each type differently. Python checks each except in order, so put the most specific exception first.
def parse_and_divide(a, b):
try:
x = int(a)
y = int(b)
return x / y
except ValueError:
print("One or both arguments are not integers")
except ZeroDivisionError:
print("Cannot divide by zero")
parse_and_divide("10", "2") -> 5.0
parse_and_divide("abc", "2") -> One or both arguments are not integers
parse_and_divide("10", "0") -> Cannot divide by zero
The except blocks only run when the specific exception they handle is raised. If int() raises ValueError, Python runs that except and skips ZeroDivisionError. If division by zero happens, Python runs the ZeroDivisionError except block.
Proactive Validation with isinstance() and str.isdigit()
Catching exceptions after they happen is one approach. A better approach for external input is to validate before you call the function. This prevents exceptions in the first place and makes the code intent clearer. The Python built-in methods for type checking are useful for this kind of upfront validation.
The isinstance() function checks if a value is an instance of a type. For strings that should be numeric, str.isdigit() returns True if every character is a digit and the string is non-empty.
def safe_int_convert(s):
if isinstance(s, str) and s.isdigit():
return int(s)
return None
inputs = ["42", "3.14", "hello", "-7"]
for val in inputs:
result = safe_int_convert(val)
if result is not None:
print(f"Converted: {result}")
else:
print(f"Skipped: {repr(val)} is not a positive integer string")
Converted: 42
Skipped: '3.14' is not a positive integer string
Skipped: 'hello' is not a positive integer string
Skipped: '-7' is not a positive integer string
The above validation is strict — it only accepts positive integer strings. For more flexible numeric parsing that handles negative numbers and decimals, wrap the conversion in try/except as shown earlier. Use proactive validation when you know the expected format in advance. Use exception handling when you are processing real-world data where the format is uncertain.
Checking Type Before Calling a Function
Another common scenario is passing mixed types to a custom function. You can validate the type signature at the start of the function and raise a ValueError yourself with a descriptive message if the types are wrong.
def calculate_area(width, height):
if not isinstance(width, (int, float)) or not isinstance(height, (int, float)):
raise ValueError(f"width and height must be numeric, got {type(width).__name__} and {type(height).__name__}")
if width < 0 or height < 0:
raise ValueError("width and height must be non-negative")
return width * height
try:
area = calculate_area("10", 5)
except ValueError as e:
print(f"Error: {e}")
Error: width and height must be numeric, got str and int
Raising ValueError explicitly with a descriptive message helps callers understand what went wrong and what to fix. It also makes debugging easier because the error message tells you exactly which argument caused the problem.
FAQ
Q: What is the difference between TypeError and ValueError?
TypeError is raised when an operation or function is applied to an object of inappropriate type — for example, adding a string to a number. ValueError is raised when the type is correct but the value is wrong — for example, calling int(“abc”). The distinction matters because it tells you whether the problem is the kind of data or the specific value.
Q: Should I always use try/except for ValueError?
Try/except is appropriate when handling external data of unknown format — user input, file contents, API responses. For code where the types are known and controlled internally, proactive validation with isinstance() or type checks at function entry points is often cleaner and makes the code easier to reason about.
Q: Can I catch ValueError and TypeError in the same except block?
Yes. Use a tuple of exception types: except (ValueError, TypeError). Python will catch either exception and run that block. This is useful when different exceptions warrant the same recovery strategy.
Q: Does ValueError have any attributes or methods?
ValueError inherits from Exception, so it has the standard attributes like args (a tuple of the positional arguments passed to the exception) and __str__() (the exception message). You can pass a custom message when raising: raise ValueError(“invalid digit encountered”).
Q: How do I handle ValueError in a loop without stopping?
Wrap each iteration’s logic in its own try/except. When an exception occurs, the except block handles it and the loop continues to the next item. This is the pattern shown earlier with the math.sqrt() loop — each bad value is handled individually without aborting the entire processing run.
ValueError is a runtime error that signals invalid data, not a code bug. The key to handling it well is knowing whether to validate upfront or catch it after the fact. For external and untrusted input, validate first. For internal data flows where types are partially known, try/except keeps the code readable while staying safe.
