Python/NumPy: How to Fix "TypeError: 'X' object is not iterable" (for int, numpy.int64, type)

The TypeError: 'X' object is not iterable is a fundamental Python error that occurs when you attempt to use an object of type 'X' in a context that requires an iterable. An iterable is an object capable of returning its members one at a time. Common contexts include for loops, membership tests (in, not in), and functions that expect a sequence of items (like sum(), list(), tuple()). This error frequently appears with int (standard Python integers), numpy.int64 (NumPy integers), and even type objects if used incorrectly.

This guide will thoroughly explain why this TypeError arises for these specific non-iterable types, demonstrate common scenarios that trigger it, and provide clear solutions, such as using range() for integer iteration, ensuring you're operating on actual collections (like lists or NumPy arrays) rather than their scalar elements, and correctly calling built-in functions.

Understanding "Iterable" Objects and the TypeError

An iterable in Python is any object that can be looped over, meaning it can return its items one by one. Examples include:

• Sequences: list, tuple, str, range objects.
• Collections: dict (iterates over keys by default), set.
• NumPy arrays (ndarray).
• File objects.
• Custom objects that implement the iteration protocol (__iter__() and __next__() methods).

Objects that are not iterable typically represent single, atomic values. These include:

• Numbers: int, float, complex, numpy.int64, numpy.float64, etc.
• bool (True, False).
• NoneType (None).
• type objects themselves (e.g., the class list or range before being called).

The TypeError: 'X' object is not iterable occurs when you try to use an object of type 'X' (which is not iterable) in an operation that requires an iterable, such as a for loop or a function like sum().

Error Case 1: TypeError: 'int' object is not iterable (Python's Standard Integer)

Cause: Attempting to Iterate Directly Over an int

A single integer value does not contain multiple items to loop through.

my_number = 5
try:
    for digit in my_number:
        print(digit)
except TypeError as e:
    print(f"Error (iterating int): {e}")

Output:

Error (iterating int): 'int' object is not iterable

Solution: Use range() for Iterating a Number of Times

If you want to loop a certain number of times based on an integer, use the range() function.

count_to_loop = 5
print("Iterating using range(count_to_loop):")
for i in range(count_to_loop): # Iterates 0, 1, 2, 3, 4
    print(i)

Output:

Iterating using range(count_to_loop):
0
1
2
3
4

Cause: Passing an int to Functions Expecting Iterables (e.g., sum(), list())

Functions like sum(), list(), tuple(), set(), max(), min() expect an iterable as their main argument (or one of their arguments).

single_int = 10
try:
    total = sum(single_int) # sum() expects an iterable of numbers
except TypeError as e:
    print(f"Error (summing int): {e}")

Output:

Error (summing int): 'int' object is not iterable

Solution: Wrap Integers in a List or Other Iterable

If you intend to operate on a single integer with these functions, or a collection of integers, ensure they are passed within an iterable.

import numpy as np 

single_int = 10
int_val1 = 10
int_val2 = 20

total_sum = sum([int_val1, int_val2, 30])
print(f"Sum of [10, 20, 30]: {total_sum}")      # Output: 60

list_from_int = list([single_int]) # Note: list(10) would error, needs list([10])
print(f"List from single int: {list_from_int}") # Output: [10]

Output:

Sum of [10, 20, 30]: 60
List from single int: [10]

Cause: Using len() in a for loop (Iterating over an int)

A common mistake is for i in len(my_sequence):. len() returns an integer (the length), which is not iterable.

my_string = "hello"
length_of_string = len(my_string) # This is 5 (an int)
try:
    for i in length_of_string:
        print(i)
except TypeError as e:
    print(f"Error (iterating len()): {e}")

Output:

Error (iterating len()): 'int' object is not iterable

Solution: Use range(len(my_sequence)) as shown in 2.2, or iterate directly over the sequence: for char in my_string:.

Error Case 2: TypeError: 'numpy.int64' object is not iterable (NumPy Integer)

This is analogous to the Python int error but occurs with NumPy's scalar integer types (like np.int64, np.int32).

Cause: Iterating Over a Scalar NumPy Integer

import numpy as np

numpy_scalar_int = np.int64(25)
try:
    for digit_part in numpy_scalar_int:
        print(digit_part)
except TypeError as e:
    print(f"Error (iterating np.int64): {e}")

my_np_array = np.array([10, 20, 30])
scalar_element = my_np_array[0] # scalar_element is np.int64(10)
try:
    for item in scalar_element: # Iterating over np.int64(10)
        print(item)
except TypeError as e:
    print(f"Error (iterating np.int64 element): {e}")

Output:

Error (iterating np.int64): 'numpy.int64' object is not iterable
Error (iterating np.int64 element): 'numpy.int64' object is not iterable

Solution: Iterate Over a NumPy Array of Integers, or Use range()

• To iterate a number of times specified by a NumPy integer: for i in range(numpy_scalar_int.item()): (using .item() to get Python int).
• To iterate over elements of a NumPy array: for element in my_np_array:.

Cause: Passing a NumPy Scalar Integer to Functions Expecting Iterables

Similar to Python ints.

import numpy as np

np_int1 = np.int64(50)
np_int2 = np.int64(75)
try:
    total = sum(np_int1, np_int2) # sum() needs an iterable
except TypeError as e:
    print(f"Error (summing np.int64): {e}")

Output:

Error (summing np.int64): 'numpy.int64' object is not iterable

Solution: Wrap NumPy Scalar in a List/Array or Operate on an Array

import numpy as np

np_int1 = np.int64(50)
np_int2 = np.int64(75)

total_np_sum = sum([np_int1, np_int2])
print(f"Sum of [np.int64(50), np.int64(75)]: {total_np_sum}")   # Output: 125

np_array_for_sum = np.array([np_int1, np_int2, np.int64(100)])
print(f"Sum of NumPy array: {sum(np_array_for_sum)}")           # Output: 225

Output:

Sum of [np.int64(50), np.int64(75)]: 125
Sum of NumPy array: 225

Error Case 3: TypeError: 'type' object is not iterable (Python Type/Class Itself)

This error usually means you've referenced a type/class (like range or a custom class) where an instance of that type (created by calling it, e.g., range(5)) or an iterable object was expected.

Cause: Forgetting to Call a Callable Type (e.g., range instead of range())

try:
    for i in range: # 'range' is the type/class, not an instance like range(5)
        print(i)
except TypeError as e:
    print(f"Error (iterating 'type' range): {e}")

Output:

Error (iterating 'type' range): 'type' object is not iterable

Solution: Call the Callable Type with Parentheses ()

print("Iterating using range(0, 3):")
for i in range(0, 3): # ✅ Correct: range(0,3) creates an iterable range object
    print(i)

Output:

Iterating using range(0, 3):
0
1
2

Cause: Attempting to Iterate Over a Custom Class Type That Isn't Iterable

class MyDataContainer:
    data_value = 100

try:
    for item in MyDataContainer: # Trying to iterate over the class itself
        print(item)
except TypeError as e:
    print(f"Error (iterating custom 'type'): {e}")

Output:

Error (iterating custom 'type'): 'type' object is not iterable

Solution: Make Custom Class Iterable (Implement __iter__ and __next__)

If you intend for instances of your class (or the class itself, though less common for direct iteration) to be iterable, you need to implement the iteration protocol.

class IterableCounter:
    def __init__(self, start, end):
        self.current = start
        self.end = end
    def __iter__(self): # Makes instances iterable
        return self
    def __next__(self):
        if self.current < self.end:
            val = self.current
            self.current += 1
            return val
        else:
            raise StopIteration

print("Iterating over an instance of IterableCounter:")
for num_val in IterableCounter(1, 4): # Iterate over an instance
    print(num_val) # Output: 1, 2, 3

Output:

Iterating over an instance of IterableCounter:
1
2
3

Error Case 4: TypeError: argument of type 'int' is not iterable (Membership Test with in)

This specific wording of the TypeError often occurs when using the in or not in membership operators where the right-hand side (the container being checked) is an integer.

Cause: Using in Operator with an Integer as the Right-Hand Operand

my_number_container = 15035
character_to_find = '3'
try:
    if character_to_find in my_number_container:
        print("Found")
except TypeError as e:
    print(f"Error (membership test with int): {e}")

Output:

Error (membership test with int): argument of type 'int' is not iterable

The in operator expects an iterable (like a string, list, tuple, set, dict keys) on its right side to check for membership. An int is not.

Solution: Ensure Right-Hand Operand is Iterable (e.g., String, List)

If my_number_container was supposed to be a string or list, fix its assignment.

Solution: Convert Integer to String for Character Membership Test

If you want to check if a digit (as a character) exists within the string representation of a number:

my_number_container = 15035
character_to_find = '3'

if character_to_find in str(my_number_container):
    print(f"'{character_to_find}' found in string representation of {my_number_container}.")
else:
    print(f"'{character_to_find}' NOT found in string representation of {my_number_container}.")

Output:

'3' found in string representation of 15035.

General Debugging: Checking if an Object is Iterable

You can programmatically check if an object is iterable using a try-except block with iter(). The iter() function raises a TypeError if its argument is not iterable.

import numpy as np

def is_iterable(obj):
    try:
        iter(obj)
        return True
    except TypeError:
        return False

print(f"Is 100 iterable? {is_iterable(100)}")                           # False
print(f"Is np.int64(5) iterable? {is_iterable(np.int64(5))}")           # False
print(f"Is 'hello' iterable? {is_iterable('hello')}")                   # True
print(f"Is [1,2] iterable? {is_iterable([1,2])}")                       # True
print(f"Is np.array([1,2]) iterable? {is_iterable(np.array([1,2]))}")   # True
print(f"Is type range iterable? {is_iterable(range)}")                  # False (the type itself)
print(f"Is range(5) iterable? {is_iterable(range(5))}")                 # True (an instance)

Output:

Is 100 iterable? False
Is np.int64(5) iterable? False
Is 'hello' iterable? True
Is [1,2] iterable? True
Is np.array([1,2]) iterable? True
Is type range iterable? False
Is range(5) iterable? True

Conclusion

The TypeError: 'X' object is not iterable errors are fundamental to Python's type system and iteration protocol.

• Integers (int, numpy.int64) are not iterable: Use range() if you need to loop a number of times based on an integer. When passing to functions like sum() or list(), ensure integers are part of an iterable collection (e.g., a list [my_int]).
• Type objects (type) are not iterable by default: If you see this with range or list, you likely forgot to call them (e.g., range(5) instead of range). For custom classes, implement the iteration protocol (__iter__, __next__) if you want their instances to be iterable.
• For membership tests (in): The right-hand operand must be an iterable. Convert integers to strings (str(my_int)) if you're checking for digit characters.

By understanding what makes an object iterable and ensuring you provide iterables where Python expects them, you can avoid these common TypeErrors.