Invalid Literal for int() With Base 10: Causes, Fixes, and Examples

Valid Examples

print(int("10"))
print(int(25.7))
print(int(True))

Output:

10
25
1

In the first example, the string “10” is converted into the integer 10. In the second example, the floating-point number 25.7 is converted to 25, with the decimal portion being truncated rather than rounded. In the third example, the boolean value True is treated as 1, while False would be converted to 0.

The int() function works only when the input can be interpreted as a valid integer. If a string contains non-numeric characters or an invalid numeric format, Python raises a ValueError. Understanding how int() handles different data types helps developers write more reliable and error-free programs.

Example 1: Text Instead of Numbers

age = int("twenty")

This code fails because the string “twenty” contains alphabetic characters rather than a numeric value. The int() function can only convert strings that contain valid integer representations.

Correct version:

age = 20

Alternatively, if the value comes from user input, it should be validated before conversion. Proper input validation helps prevent runtime errors and improves application reliability.

Example 2: Currency Symbols

price = int("$100")

Output:

ValueError

The conversion fails because the dollar sign ($) is not part of a valid integer format. Python cannot automatically ignore currency symbols during conversion.

Fix:

price = int("$100".replace("$", ""))

By removing the currency symbol first, the remaining string becomes a valid integer value. Similar preprocessing may be required for other currency formats such as €, £, or ₹.

Example 3: Comma-Separated Numbers

num = int("1,000")

Output:

ValueError

Although humans commonly use commas as thousands separators, Python’s int() function does not parse them automatically. As a result, the conversion fails.

Fix:

num = int("1,000".replace(",", ""))

Removing formatting characters before conversion ensures that the string contains only numeric digits. This approach is useful when working with financial reports or formatted data exports.

Example 4: Decimal Strings

num = int("45.67")

This conversion fails because the string contains a decimal point, making it a floating-point value rather than an integer. The int() function cannot directly convert such strings.

Solution:

num = int(float("45.67"))

In this approach, the string is first converted to a floating-point number and then converted to an integer. Keep in mind that the decimal portion is truncated during the conversion, so 45.67 becomes 45 rather than being rounded.

Method 1: Validate User Input

Always verify input before converting it.

Example:

value = input("Enter age: ")
if value.isdigit():
age = int(value)
else:
print("Invalid number")

This prevents conversion errors from occurring.

Method 2: Use Try-Except Blocks

Exception handling is the safest approach when working with unpredictable data.

Example:

try:
age = int(input("Enter age: "))
except ValueError:
print("Please enter a valid integer.")

This prevents application crashes and improves user experience.

Method 3: Clean Input ata

Many datasets contain symbols, spaces, or formatting characters.

Example:

salary = "$5,000"
salary = salary.replace("$", "")
salary = salary.replace(",", "")
salary = int(salary)

Output:

5000

Data cleaning is especially important when processing external sources.

Method 4: Handle Decimal Values Correctly

If decimal numbers are expected, use float() first.

Example:

price = "25.99"
price = int(float(price))

Output:

25

This converts the decimal string successfully.

User Registration Forms

User registration and data entry forms are among the most common sources of conversion errors. Fields such as age, salary, quantity, or experience level often require numeric input but may contain unexpected values entered by users.

For example, a user might enter text instead of numbers, include extra spaces, or use special characters that cannot be converted into integers. Validating form data before processing helps prevent application errors and improves the overall user experience.

Machine Learning Data Preprocessing

Machine learning workflows often involve cleaning and transforming large datasets before training models. During preprocessing, developers frequently convert string values into numeric formats for analysis.

However, datasets may contain missing values, textual labels, corrupted records, or malformed numeric fields that cannot be converted directly using int(). Proper data validation and preprocessing steps are essential to ensure data quality and avoid interruptions in the training pipeline.

Financial Applications

Financial systems regularly process prices, transaction amounts, invoices, and account balances. These values often include currency symbols, commas, and other formatting characters that are not recognized by the int() function.

For example, values such as $1,500 or ₹25,000 must be cleaned before conversion. Without proper formatting and validation, financial applications may encounter conversion failures that impact calculations and reporting processes.

Data Import Automation

Automated data import processes frequently read information from CSV files, Excel spreadsheets, or third-party data sources. Because these files are often created by different systems or users, formatting inconsistencies are common.

Imported values may contain extra spaces, special symbols, missing data, or mixed data types that cause integer conversion errors. Implementing data-cleaning and validation routines during the import process helps ensure that imported records can be processed reliably and accurately.