Valueerror invalid literal for int with base 10

When working with programming languages like Python, encountering errors is a common existence. One of the errors that often encountered by developers is the ValueError: Invalid literal for int with base 10.

This error typically occurs when attempting to convert a string into an integer, but the string is not in a valid format.

In this article, we will explain to you the causes of this error, examples to illustrate how the error occurs, and provide practical solutions to resolve it.

What is ValueError: Invalid literal for int with base 10?

The ValueError: Invalid literal for int with base 10 is an exception raised in Python when attempting to convert a string to an integer, but the string cannot be interpreted as a valid integer literal.

What are the causes of the error?

This error commonly occurs due to the following reasons:

• Non-numeric characters
• Leading or trailing whitespace
• Decimal points or commas
• Numeric base mismatch

Why does the Valueerror invalid literal for int with base 10 occur?

The ValueError: invalid literal for int() with base 10 error occurs if we try to convert a string to an integer using the int() function in Python, but the string does not represent a valid integer in base 10 (decimal).

How to the Error Reproduce?

Here is an example of how the error reproduces:

number = int("abc")

In this example, we attempt to convert the string “abc” to an integer using the int() function. However, since “abc” is not a valid numeric string, Python raises a ValueError.

Traceback (most recent call last):
File “C:\Users\Dell\PycharmProjects\Python-Code-Example\main.py”, line 1, in
number = int(“abc”)
ValueError: invalid literal for int() with base 10: ‘abc’

Let’s take a look at the other example of valueerror:

number = int("3.14")

In this example, the given line of code tries to convert the string “3.14” into an integer.

However, since the string contains a decimal point, which is not allowed in integers, an error will occur.

Other Examples:

Another example where the ValueError: Invalid literal for int with base 10 error can occur is when reading numeric values from a file.

with open("numbers.txt", "r") as file:
    lines = file.readlines()

numbers = [int(line) for line in lines]

In this example, we attempt to read lines from a file named “numbers.txt” and convert each line to an integer.

However, if the file contains non-numeric strings, a ValueError will be raised.

Traceback (most recent call last):
File “C:\Users\Dell\PycharmProjects\Python-Code-Example\main.py”, line 4, in
numbers = [int(line) for line in lines]
File “C:\Users\Dell\PycharmProjects\Python-Code-Example\main.py”, line 4, in
numbers = [int(line) for line in lines]
ValueError: invalid literal for int() with base 10: ‘xyz’

To handle this situation, we need to implement error handling while reading the file and convert only valid numeric strings.

How to Fix the Valueerror: invalid literal for int with base 10 Error?

Here are the following solutions to solve the python valueerror invalid literal for int with base 10:

Solution 1: Validating the Input

To resolve this issue, we need to make sure that we only pass valid numeric strings to the int() function.

Here’s an example of how we can fix this:

def convert_to_int(string):
    try:
        number = int(string)
        return number
    except ValueError:
        return None

# Usage example
input_string = input("Enter a number: ")
result = convert_to_int(input_string)

if result is not None:
    print(f"The converted integer is: {result}")
else:
    print("Invalid input. Please enter a valid number.")

Output:

Enter a number: 12
The converted integer is: 12

In the example above, we define a convert_to_int() function that attempts to convert the input string to an integer.

Next, we use a try-except block to catch any ValueError that may occur during the conversion.

Then, if an exception is raised, we return None to indicate invalid input. Otherwise, we return the converted integer.

By validating the input before conversion, we can prevent the ValueError and handle invalid literals.

Solution 2: Error Handling and Data Validation

To avoid the ValueError when reading numeric values from a file, we can apply error handling and data validation techniques.

Here’s an updated version of the previous example that includes error handling and validation:

numbers = []
with open("numbers.txt", "r") as file:
    for line in file:
        line = line.strip()
        try:
            number = int(line)
            numbers.append(number)
        except ValueError:
            print(f"Ignoring invalid literal: {line}")

print("Numeric values read from the file:")
print(numbers)

Output:

Ignoring invalid literal: ABCDEFG
Numeric values read from the file:
[12345678]

By integrating an error handling and data validation, we can easily handle invalid literals and process only the valid numeric values from the file.

Additional Resources

• Valueerror embedded null byte
• Valueerror: unknown label type: ‘continuous’
• Valueerror: attempted relative import in non-package

Conclusion

The Invalid literal for int with base 10 error can occur when attempting to convert a non-numeric string to an integer in Python.

However, by applying the proper input validation, error handling, and data validation techniques, you can effectively handle this error and ensure the smooth execution of your code.

In this article, we provide examples that trigger the ValueError and provided practical solutions to resolve the issue.

FAQs (Frequently Asked Questions)

Why int() / float() raise ValueError

Python’s built-in int() and float() are strict — they only accept strings that exactly represent a valid number. Empty strings, decimals with a comma separator, leading/trailing whitespace-only strings, or anything with a letter raises ValueError, not TypeError.

Common triggers

• Whitespace and newlines. int(" 5\n") raises ValueError before Python 3.11. Strip first: int(s.strip()).
• Decimal for int(). int("3.14") raises ValueError. Convert to float first: int(float("3.14")).
• Empty string. int("") raises ValueError. Guard with if s.strip(): before converting.
• Currency symbols. float("$100") fails. Strip currency chars: float(s.replace("$", "").replace(",", "")).
• Locale differences. European decimals use comma (3,14) — replace before parsing.

Diagnostic pattern

# BAD — CSV cell can contain anything
def process_row(row):
    price = float(row["price"])       # ValueError on "n/a" or empty
    quantity = int(row["quantity"])   # ValueError on decimals

# GOOD — validate and fall back
def process_row(row):
    try:
        price = float(row["price"].strip())
    except (ValueError, AttributeError):
        price = 0.0
    try:
        quantity = int(float(row["quantity"].strip()))
    except (ValueError, AttributeError):
        quantity = 0

Best practices

• Always strip whitespace before converting. CSV, form input, and API responses often carry trailing whitespace.
• Use pydantic or dataclasses. Modern validation catches ValueError at the boundary with cleaner error messages.
• Use argparse with type= for CLI. parser.add_argument("--n", type=int) converts + validates automatically.
• Return sensible defaults. Wrap in try/except and return 0 (or None) rather than crashing.

Adones Evangelista

Programmer & Technical Writer at PIES IT Solution

Adones Evangelista is a programmer and writer at PIES IT Solution, author of over 900 tutorials and error-fix guides at itsourcecode.com. Specializes in JavaScript, Django, Laravel, and Python error debugging covering ValueError, TypeError, AttributeError, ModuleNotFoundError, and RuntimeError, plus C/C++ and PHP capstone projects for BSIT students.

Expertise: JavaScript · Python · Django · Laravel · Error Debugging · C/C++
 · View all posts by Adones Evangelista →