Skip to main content

How to Resolve Python Error "TypeError: 'float'/'str' object cannot be interpreted as an integer"

Python is strongly typed, and certain functions or operations strictly require integer arguments. When you provide a floating-point number (float) or a string (str) where an integer (int) is expected, Python raises a TypeError with messages like 'float' object cannot be interpreted as an integer or 'str' object cannot be interpreted as an integer. This commonly occurs with functions like range().

This guide explains why this type mismatch happens and provides standard solutions for converting floats and strings to integers.

Understanding the Error: Integer Requirement​

Many Python functions and operations are specifically designed to work only with whole numbers (integers). Some prominent examples include:

  • range(stop) / range(start, stop[, step]): All arguments must be integers to define the sequence steps.
  • List/String/Tuple Indexing: Indices (my_list[index]) must be integers.
  • Bitwise Operations: Operators like &, |, ^, ~, <<, >> operate on the binary representation of integers.

A TypeError occurs when you attempt to use a non-integer type (like a float with a decimal part or a str representing a number) in these integer-only contexts. Python doesn't automatically truncate floats or parse strings for these specific operations.

Error 1: 'float' object cannot be interpreted as an integer​

Cause:** Providing a float value to a function/operation expecting an int. A common case is using standard division (/), which always produces a float, as input to range().​

error_float.py
import math

result_float = 50 / 5 # Standard division yields a float
print(f"Result of 50 / 5: {result_float}, Type: {type(result_float)}")
# Output: Result of 50 / 5: 10.0, Type: <class 'float'>

try:
    # ⛔️ TypeError: 'float' object cannot be interpreted as an integer
    # range() requires integer arguments, but 10.0 is a float.
    for i in range(result_float):
        print(i)
except TypeError as e:
    print(f"\nCaught Error: {e}")

Output:

Result of 50 / 5: 10.0, Type: <class 'float'>
Caught Error: 'float' object cannot be interpreted as an integer

Solution 1: Use Floor Division (//)​

If your calculation involves division and you need an integer result specifically for use in an integer context (like range), use the floor division operator //. It performs division and rounds the result down to the nearest whole number, returning an int (if both operands are ints).

solution_floor_division.py
my_num = 53

# ✅ Use floor division to get an integer result for range()
result_int = my_num // 5 # 53 // 5 equals 10
print(f"Result of 53 // 5: {result_int}, Type: {type(result_int)}")
# Output: Result of 53 // 5: 10, Type: <class 'int'>

print("\nLooping with floor division result:")
for i in range(result_int): # range(10) works
    print(i, end=" ")       # Output: 0 1 2 3 4 5 6 7 8 9
print()

Solution 2: Explicit Conversion with int()​

Convert the float to an integer using the int() constructor. This truncates (cuts off) the decimal part, effectively rounding towards zero.

# solution_int_cast_float.py
float_value = 15.7 / 3 # Result is approx 5.233... (float)
print(f"Float value: {float_value}")

# ✅ Convert the float to an int (truncates decimal)
int_value = int(float_value)
print(f"Integer value (truncated): {int_value}, Type: {type(int_value)}")
# Output: Integer value (truncated): 5, Type: <class 'int'>

print("Looping with int() conversion:")
for i in range(int_value):  # range(5) works
    print(i, end=" ")       # Output: 0 1 2 3 4
print()

Solution 3: Rounding (round(), math.ceil(), math.floor())​

If simple truncation isn't desired, you can round the float to the nearest integer before converting or using it where an integer is needed.

solution_rounding.py
import math

float_val_1 = 9.8
float_val_2 = 9.2

# Round to nearest integer
rounded_nearest = round(float_val_1)    # Result: 10
print(f"round({float_val_1}) = {rounded_nearest}")

# Round down (floor)
rounded_down = math.floor(float_val_1)  # Result: 9
print(f"floor({float_val_1}) = {rounded_down}")

# Round up (ceiling)
rounded_up = math.ceil(float_val_2)     # Result: 10
print(f"ceil({float_val_2}) = {rounded_up}")
print()

print("Looping with round():")
for i in range(round(float_val_1)):     # range(10)
    print(i, end=" ")                   # Output: 0 1 2 3 4 5 6 7 8 9
print()

Output:

round(9.8) = 10
floor(9.8) = 9
ceil(9.2) = 10

Looping with round():
0 1 2 3 4 5 6 7 8 9
note
  • round(number): Rounds to the nearest even integer for .5 cases (Python 3 behavior).
  • math.ceil(number): Always rounds up to the next integer.
  • math.floor(number): Always rounds down (equivalent to int() for positive numbers).

Alternative for Ranges: numpy.arange() (Handles Floats)​

If you need to generate sequences with floating-point steps or non-integer endpoints, Python's built-in range() is not suitable. Use numpy.arange() instead (requires pip install numpy).

solution_numpy_arange.py
import numpy as np # Requires numpy install

start = 0.5
stop = 5.0
step = 1.5

# ✅ NumPy's arange handles float arguments
for i in np.arange(start, stop, step):
    print(i)

Output:

0.5
2.0
3.5

Error 2: 'str' object cannot be interpreted as an integer​

Cause:** Providing a str value to a function/operation expecting an int.​

error_string.py
number_as_string = "25" # String containing digits

print(f"Value: {number_as_string}, Type: {type(number_as_string)}")
# Output: Value: 25, Type: <class 'str'>

try:
    # ⛔️ TypeError: 'str' object cannot be interpreted as an integer
    # range() expects an integer, not the string "25".
    for i in range(number_as_string):
        print(i)
except TypeError as e:
    print(f"Caught Error: {e}")

Output:

Value: 25, Type: <class 'str'>
Caught Error: 'str' object cannot be interpreted as an integer

Solution: Explicit Conversion with int()​

Use the int() constructor to convert the string representation of a number into an actual integer.

solution_int_cast_string.py
number_as_string = "25"

# ✅ Convert the string to an integer
int_value = int(number_as_string)
print(f"Converted value: {int_value}, Type: {type(int_value)}")
# Output: Converted value: 25, Type: <class 'int'>

print("\nLooping with int() conversion:")
for i in range(int_value): # range(25) works
    # ... loop logic ...
    pass # Avoid printing 25 numbers here
print("Loop finished successfully.")

# --- Error case for int() ---
non_numeric_string = "hello"
try:
    # ⛔️ ValueError: invalid literal for int() with base 10: 'hello'
    # int() raises ValueError if the string doesn't represent an integer.
    failed_conversion = int(non_numeric_string)
except ValueError as e:
    print(f"\nError converting non-numeric string: {e}")

Output:

Converted value: 25, Type: <class 'int'>

Looping with int() conversion:
Loop finished successfully.

Error converting non-numeric string: invalid literal for int() with base 10: 'hello'
note

Important: The int() conversion will raise a ValueError if the string does not contain a valid integer representation. Use try...except ValueError if the string might not be a number.

Common Scenario: input() Function​

The built-in input() function always returns a string, even if the user types digits. You must explicitly convert the result to int (or float) if you need to perform numerical operations.

solution_input.py
user_input_str = input("Enter a number of iterations: ")
print(f"Input was: '{user_input_str}', Type: {type(user_input_str)}")

try:
    # ✅ Convert input string to integer
    iterations = int(user_input_str)
    print(f"Running loop {iterations} times:")
    for i in range(iterations):
        print(f" Iteration {i}")
except ValueError:
    print("Invalid input. Please enter a whole number.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Output (with User Input = 10)

Enter a number of iterations: 
10
Input was: '10', Type: <class 'str'>
Running loop 10 times:
 Iteration 0
 Iteration 1
 Iteration 2
 Iteration 3
 Iteration 4
 Iteration 5
 Iteration 6
 Iteration 7
 Iteration 8
 Iteration 9

General Cause: Accidental Variable Reassignment​

Ensure a variable intended to hold an integer wasn't accidentally reassigned a float or string value earlier in your code.

count = 10 # Intended integer
# ...
# Some calculation or input handling
count = count / 2 # ⚠️ Now count is 5.0 (a float!)
# ...
try:
    for i in range(count): # ⛔️ TypeError if count is 5.0
        pass
except TypeError as e:
    print(f"Error after potential reassignment: {e}")

Output:

Error after potential reassignment: 'float' object cannot be interpreted as an integer

Solution: Use floor division (count //= 2) or explicit int() casting after the division if an integer is required later, or use different variable names.

Debugging: Checking Types​

When encountering this TypeError, the first step is always to check the type of the variable being passed to the function/operation that expects an integer:

print(f"DEBUG: Type of my_variable is {type(my_variable)}")
# >> Line causing the error, e.g., range(my_variable)

This will immediately tell you if it's a float or str instead of the expected int.

Conclusion​

The TypeError: 'float'/'str' object cannot be interpreted as an integer occurs when you supply a float or string value where an integer is strictly required (like in range() or indexing).

To fix this:

  • For floats:
    • Use floor division (//) if the float resulted from division and you need an integer quotient.
    • Explicitly convert using int(my_float) (truncates decimal).
    • Use round(), math.ceil(), or math.floor() before converting if specific rounding is needed.
  • For strings:
    • Explicitly convert using int(my_string). Be prepared to handle ValueError if the string might not represent a valid integer.
  • General: Check for accidental variable reassignment.

Always ensure data types match the requirements of the functions and operations you are using.

Table of Contents