Cannot unpack non iterable int object ошибка

Often when working on a data analytics project it requires you to split data out into its constituent parts.

There are a number of reasons for this, it can be confusing when you get errors as with the title of this post.

Before we explain this error and what it means, lets us first explain unpacking

Unpacking basically means splitting something up into a number of its parts that make it up.

To demonstrate if you take a,b,c = 123, and look to unpack it, it throws out the error, but why?

Well pure and simple, we have three values on the left “a,b,c”, looking for three values on the right.

a,b,c = 123
print(a)

Output:
 a,b,c = 123
TypeError: cannot unpack non-iterable int object

If you would like to fix this problem change the right hand side to have three values.

a,b,c = 1,2,3
print(a)
print(b)
print(c)
print(a,b,c)

Output:
1
2
3
1 2 3

Process finished with exit code 0

In essence, what is going on is that an evaluation checking that both sides have the same amount of values.

It is important to remember, the code above we used to show the error is an integer, which cannot be unpacked.

So if you take 123 for an example, which we used here it cannot be split into say 100 and 10 and 13.

In this case, even though when they are added up to 123, integers cannot be unpacked.

For this reason in the code for our solution, the difference is that the values used are tuples as follows:

a,b,c = 1,2,3
print(a)
print(b)
print(c)
print(a,b,c)
print(type((a,b,c)))

Or 
a,b,c = (1,2,3)
print(a)
print(b)
print(c)
print(a,b,c)
print(type((a,b,c)))

yield the same result:

1
2
3
1 2 3
<class 'tuple'>

Process finished with exit code 0

So in summary:

When unpacking there are a number of things to remember:

• Integers on their own cannot be unpacked.
• You need to make sure that if you have a number of variables, that you have the same number of integers if they the values.
  • This will make it a tuple and unpacking can then happen.

Выражение for num, value in word, bb: означает, что нужно перебрать коллекцию и каждый ее элемент распаковать по переменным num и value.

В цикле word, bb станет кортежом на два элемента word и bb, т.е. сначала цикл вернет word, потом bb.

А значения num, value заставят его каждый элемент пытаться разложить на два элемента. А т.к. у вас word является числом, то для него такого нельзя сделать (cannot unpack non-iterable int object).

Кст, распаковка выглядит так, для рабочего варианта сделал обе переменных строками по два элемента:

word, bb = '12', '34'
for num, value in word, bb:
    print(num, '=>', value)
# 1 => 2
# 3 => 4

Как мы тут видим, сначала цикл вернул word, после значение "12" распаковал по двум переменным, а следующей итерацией вернул bb и сделал аналогичную распаковку

Мб, вам не цикл нужен был, а что-то вроде такого?

num, value = word, bb
print(str(num) + '==>' + value)

In Python, you can unpack iterable objects and assign their elements to multiple variables in the order they appear. If you try to unpack an integer, you will throw the error TypeError: cannot unpack non-iterable int object. An integer is not a sequence which we can loop over.

To solve this error, you can perform unpacking on a list or tuple of integers. For example,

int_x, int_y, int_z = (1, 2, 3)
print(int_x)
print(int_y)
print(int_z)

This tutorial will go through how to solve the error with code examples.

TypeError: cannot unpack non-iterable int object

TypeError occurs in Python when you perform an illegal operation for a specific data type. Integers are zero, positive or negative whole numbers without a fractional component and are not iterable. Unpacking is only suitable for iterable objects.

What is an Iterable Object in Python?

An iterable is an object that can be “iterated over“, for example in a for loop. In terms of dunder methods under the hood, an object can be iterated over with “for” if it implements __iter__() or __getitem__().

An iterator returns the next value in the iterable object. An iterable generates an iterator when it is passed to the iter() method.

In terms of dunder methods under the hood, an iterator is an object that implements the __next__() method.

A for loop automatically calls the iter() method to get an iterator and then calls next over and over until it reaches the end of the iterable object.

Unpacking requires an iteration in order to assign values to variables in order, and as such requires iterable objects.

What is Unpacking in Python?

Unpacking is the process of splitting packed values into individual elements. The packed values can be a string, list, tuple, set or dictionary. During unpacking, the elements on the right-hand side of the statement are split into the values on the left-hand side based on their relative positions. Let’s look at the unpacking syntax with an example:

values = [10, 20, 30]

x, y, z = values

print(f'x: {x}, y: {y}, z: {z}')

The above code assigns the integer values in the value list to three separate variables. The value of x is 10, y is 20, and the value of z is 30. Let’s run the code to get the result:

x: 10, y: 20, z: 30

We can also unpack sets and dictionaries. Dictionaries are only ordered for Python version 3.7 and above but are unordered for 3.6 and below. Generally, it is not recommended to unpack unordered collections of elements as there is no guarantee of the order of the unpacked elements.

We cannot unpack an Integer because it is not an iterable object, and an iterable is a Python object that we can iterate over.

Example

Let’s look at an example of attempting to unpack an int object. First, we will define a function that returns an integer.

def return_int():

    return 2

Next, we will try to unpack the object returned by the function and assign three values to the variables named x, y, and z.

x, y, z = return_int()

print(f'x: {x}, y: {y}, z: {z}')

Let’s run the code to see the result:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [18], in <cell line: 1>()
----> 1 x, y, z = return_int()
      2 print(f'x: {x}, y: {y}, z: {z}')

TypeError: cannot unpack non-iterable int object

The error occurs because the function returns an integer, and we are using an unpack operation, which is impossible with an integer because integers are not iterable.

We can use the type() method to check the type of an object. Let’s verify the type of the object returned by the return_int() function call:

print(type(return_int()))

<class 'int'>

Solution

We can solve this error by ensuring the function we use returns an iterable object. In this case, we will return a tuple containing three integers. Let’s look at the revised code:

def return_tuple():

    return (2, 4, 8)

Next, we will call the return_tuple() function to return the tuple and unpack it.

x, y, z = return_tuple()

print(f'x: {x}, y: {y}, z: {z}')

Let’s run the code to see the result:

x: 2, y: 4, z: 8

We successfully called the function and unpacked the tuple into three variables, and printed their values to the console.

Summary

Congratulations on reading to the end of this tutorial!

For more reading on cannot unpack non-iterable object errors, go to the articles:

• How to Solve Python TypeError: cannot unpack non-iterable NoneType object
• How to Solve Python TypeError: cannot unpack non-iterable float object
• How to Solve Python TypeError: cannot unpack non-iterable numpy.float64 object

Go to the online courses page on Python to learn more about Python for data science and machine learning.

Have fun and happy researching!