How to Convert String to int in Python? (Step-by-Step Guide)

Converting strings to integers in Python is essential for performing calculations, managing user input, and handling data efficiently. Various techniques are used for performing string to int conversion, including handling errors and validating input during the process.

For instance, numerical data in text form often needs to be converted to integers before performing mathematical operations. Python provides built-in methods to facilitate such conversions.

This article explores the available methods for how to convert string to int in Python and explains how to use them effectively.

Int DataType in Python

Integers, or the int data type, represent whole numbers that do not have fractional components, such as -5, 0, and +5. They are commonly used in Python for various mathematical operations, including addition, subtraction, multiplication, division, and comparison.

Below is an example of how integers are represented in Python.

number = 42
print(number)
print(type(number))

Output:

String DataType in Python

Strings in Python are represented using the str data type. They are sequences of characters enclosed in either single quotes (') or double quotes ("). Strings are immutable, which means their content cannot be changed once they are created.

Below is an example of how to represent and use strings in Python:

greeting = 'Welcome to Python'
language = "Learning Python is fun"
print(greeting)
print(language)

Output

When Should You Convert Strings to Integers in Python?

As a programmer, there are many scenarios where converting strings to integers is essential. Here are some common situations:

• Processing user input: When users provide numerical input as text, converting these strings to integers is necessary for calculations or validation.
• Reading data from files: Numerical data stored as text in files often needs to be converted into integers for further analysis or computation.
• Sorting and comparisons: Converting strings to integers ensures accurate numerical comparisons and sorting, as it avoids treating numbers as text.
• Database operations: When working with databases, converting string data to integers is important for proper indexing, filtering, and performing mathematical operations on numeric fields.

How to Convert int to string Python?

For the int to string Python conversion, you can use the str() function. This method behaves similarly to other conversion functions but returns the result as a string.

The str() function automatically detects the base of the input if a relevant prefix is provided, converting it to the appropriate decimal format.

Here's an example:

integer_val = 256
print(str(integer_val))  # Converts int to string python
print(type(str(integer_val)))  
negative_integer = -512
print(str(negative_integer))  # Converts negative integer to string
print(type(str(negative_integer)))  # Verifies the type is string
large_number = 1234567890
print(str(large_number))  # Converts large integer to string
print(type(str(large_number)))  # Verifies the type is string
binary_num = 0b10101
print(str(binary_num))  # Converts binary to string
print(type(str(binary_num)))  # Verifies the type is string

Output

How to Convert String to int in Python? 

You can use three methods to convert string to int in Python:

• int() constructor
• eval() function
• ast.literal_eval() function

Method 1: Convert String to int in Python Using int() Constructor

The int() constructor is one of the most common and straightforward methods for converting strings to integers in Python. It is a part of the built-in int class and creates a new integer object when called.

The basic syntax for the int() constructor is as follows:

int(y, base=10)

Here, y is the string or number to be converted, and the base argument specifies the number system (default is 10 for decimal).

You can easily convert a string into an integer like this:

num = int('20')
print("String to positive integer -", num)
num = int("-25")
print("String with negative integer -", num)

Output

You can also convert floating-point numbers to integers by passing a float to int():

num = int(25.76)
print("Float to int -", num)

Output

However, when you attempt to convert a non-decimal integer string without specifying the base, it will result in an error.

int("G5")

Output

By default, the int() function assumes the base is 10 (decimal). If you need to convert a string that represents a number in another base, you must specify the base:

hex_value = "7F"
print("Hexadecimal to decimal -", int(hex_value, base=16))

Output

A common logical mistake occurs when passing a string that represents a number in a non-decimal base but forgetting to specify the base. In this case, int() will treat the string as a decimal number by default:

binary_value = "1101011"
print("Intended binary to decimal result -", int(binary_value))

Output

In this case, the function misinterprets the binary string as a decimal number. To avoid this, always specify the correct base:

binary_value = "1101011"
print("Binary to decimal result -", int(binary_value, base=2))
octal_value = "157"
print("Octal to decimal result -", int(octal_value, base=8))
hex_value = "2A"
print("Hexadecimal to decimal result -", int(hex_value, base=16))

Output

One of the most common exceptions when using int() is the ValueError. If int() receives a string that cannot be converted to an integer, it will raise this exception. To prevent this, it's a good practice to validate input or use a try-except block.

try:

    num = int("12.34")

except ValueError:

    num = 0
    print("Invalid input, assigning default value:", num)

Output

It means when using the int() constructor, it's important to handle cases where the string might not be a valid integer and to specify the correct base for non-decimal numbers to avoid logical errors and exceptions.

Validating Input with isdigit()

You can use the isdigit() method to check whether a string consists only of digits. This is helpful when you need to validate whether the input string can be converted to an integer using the int() function. 

Here's an example of how you can do this:

user_input = input("Please provide a number: ")

if user_input.isdigit():

    number = int(user_input)
    print("The number is:", number)

else:

    print("Invalid input, please enter a valid number.")

Output

In this case, isdigit() will ensure that the input contains only digits and can safely be converted to an integer.

Handling Exceptions with try-except

An alternative approach is to use a try-except block to handle exceptions that arise when trying to convert a string to an integer. This is useful when you are unsure about the format of the input and want to manage errors gracefully. Here's an example:

user_input = input("Enter a number: ")

try:

    number = int(user_input)
    print("The number is:", number)

except ValueError:

    print("Oops! That doesn't seem like a valid number. Please try again.")

Output

In this example, the program tries to convert the input to an integer. If the input is not a valid number (such as letters or symbols), a ValueError is raised, and the program prints an error message without crashing.

Method 2: Convert String to int in Python Using eval() Function

The built-in eval() function allows you to evaluate arbitrary Python expressions from string-based or compiled-code-based input. It's useful when you need to dynamically evaluate Python expressions. 

When you pass a string argument to eval(), it compiles it into bytecode and evaluates it as a Python expression, enabling you to convert strings into integers. Below are some examples:

print("5 - ", eval("5"))
print("4 * 7 - ", eval("4 * 7"))
print("3 ** 4 - ", eval("3 ** 4"))
print("20 + 30 - ", eval("20 + 30"))
print("sum of 4, 5, and 6 - ", eval("sum([4, 5, 6])"))
value = 50
print("(50 + 10) * 2 - ", eval("(value + 10) * 2"))

Output

Just like int(), eval() can be used to convert non-decimal strings into integers. For example:

hex_string = "0x1A"
oct_string = "0o12"
binary_string = "0b1101"
hex_value = eval(hex_string)
oct_value = eval(oct_string)
binary_value = eval(binary_string)
print(hex_value)
print(oct_value)
print(binary_value)
print(type(hex_value))
print(type(oct_value))
print(type(binary_value))

Output

You can also use eval() to evaluate expressions that involve variables, which is something int() cannot do. For example:

a = 15
b = eval("a * 3")
print(b)
print(type(b))

Output

The primary issue with using eval() is that it executes arbitrary code, which can lead to unintended consequences if not handled properly. Among the three methods, eval() is the least secure option due to its potential for executing harmful code. 

Despite this, it offers more flexibility and power than the other methods. To mitigate security risks, it's crucial to use eval() with careful input validation. This includes checking input formats, ensuring data types are correct, restricting input length, and verifying input against patterns or ranges to prevent misuse.

Method 3: Convert String to int in Python Using ast.literal_eval() Function

The literal_eval() function is part of Python's ast module, which stands for Abstract Syntax Tree. This module helps in processing Python syntax structures by interpreting their abstract grammar. 

The literal_eval() function evaluates expressions that are limited to safe Python data types such as strings, numbers, tuples, lists, dictionaries, sets, booleans, and None. While not the most recommended approach for converting strings to integers, literal_eval() can still be used for such conversions under certain conditions.

To use the literal_eval() function, we need to first import it. Here's an example:

from ast import literal_eval
number = literal_eval("1234")
print(number)
print(type(number))

Output

In addition to converting strings into integers, literal_eval() can also be used for converting other valid Python literals such as booleans, lists, dictionaries, and tuples. For example:

from ast import literal_eval
string = '{"name": "John", "age": 30}'
dict_data = literal_eval(string)
print(dict_data)

Output

However, unlike eval(), literal_eval() cannot evaluate mathematical expressions with operators, such as "5 + 6". If you try this, it will raise a ValueError exception. Let’s take an example:

from ast import literal_eval
expression = "5 + 6"
result = literal_eval(expression)
print(result)

Output

To handle this situation, you can use a try-except block, as shown below:

from ast import literal_eval
expression = "5 + 6"

try:

    result = literal_eval(expression)

except ValueError:

    result = 0
    print(result)

Output:

In this case, 0 is assigned to the result if literal_eval() raises a ValueError.

The main benefit of literal_eval() over other methods, like eval(), is its safety. Unlike eval(), literal_eval() only evaluates literals and does not execute potentially harmful or arbitrary code. Additionally, it provides better error handling, raising specific exceptions rather than generic ones like TypeError.

What Factors Should You Consider When Converting Strings to Integers in Python?

When converting strings to integers, there are several important factors to keep in mind:

• Validate input: Ensure the string represents a valid integer before attempting the conversion.
• Handle exceptions: Strings containing non-numeric characters or being empty can cause errors. Use try-except blocks to handle these exceptions gracefully.
• Trim whitespace: Remove unnecessary leading or trailing spaces using the strip() method to avoid conversion errors.
• Check numeric base: Confirm the string is in the correct numeric base, such as binary, octal, decimal, or hexadecimal, to avoid incorrect conversions.
• Manage signs: Account for positive and negative signs in the string representation to prevent unexpected results.
• Resource usage: Although Python supports very large integers, working with extremely large numbers can be resource-intensive and may impact performance.

By addressing these aspects, you can avoid common pitfalls and ensure a smooth string-to-integer conversion process.

Conclusion

Converting strings to integers is an essential skill for Python developers. This article covers three common methods for how to convert string to int in Python, highlighting their advantages and limitations. We also discuss potential errors and offer strategies for handling them. By experimenting with these methods, you can tackle various scenarios and improve your problem-solving abilities.

Need more power than a VPS? Upgrade to BlueServers' dedicated server for unbeatable performance, scalability, and customizability with unlimited traffic.