Select Page

How to Solve Python TypeError: cannot unpack non-iterable method object

by | Programming, Python, Tips

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

If the method returns an iterable object, you can call the method before performing unpacking. For example,

class Pizza:

    def __init__(self, name, price, is_vegetarian):

        self.name = name

        self.price = price

        self.is_vegetarian = is_vegetarian
    
    def get_info(self):

        return([self.name, self.price, self.is_vegetarian])


pepperoni = Pizza("Pepperoni", 10.99, False)

name, price, is_vegetarian = pepperoni.get_info()

print(name)
print(price)
print(is_vegetarian)

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

Table of contents

TypeError: cannot unpack non-iterable method object

TypeError occurs in Python when you perform an illegal operation for a specific data type. A method is a function that belongs to an object of a class, and we cannot iterate over it. 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.

Example

Let’s look at an example of attempting to unpack a method object. First, we will define a class that stores and returns attributes of fundamental physics particles.

class Particle:

    def __init__(self, name, charge, mass):

        self.name = name

        self.charge = charge

        self.mass = mass
    
    def get_info(self):

        return([self.name, self.charge, self.mass])

The __init__ method is the class constructor and sets the name, charge and mass attributes for the particle.

The get_info method returns a list containing the particle attributes.

Next, we will create an instance of the Particle class containing attributes of the muon particle.

muon = Particle("Muon", -1, 105.7)

Next, we will try to unpack the values returned by the get_info method.

name, charge, mass = muon.get_info

print(name)
print(charge)
print(mass)

Let’s run the code to see what happens:

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [22], in <cell line: 3>()
      1 muon = Particle("Muon", -1, 105.7)
----> 3 name, charge, mass = muon.get_info
      5 print(name)
      6 print(charge)

TypeError: cannot unpack non-iterable method object

The error occurs because we did not call the get_info method and Python interprets this as trying to unpack the method object.

Solution

We can solve this error by calling the method get_info. We can call a method by specifying the method name and putting parentheses () after the name. Let’s look at the revised code:

muon = Particle("Muon", -1, 105.7)

name, charge, mass = muon.get_info()

print(name)
print(charge)
print(mass)

Let’s run the code to unpack the values and print them to the console:

Muon
-1
105.7

Summary

Congratulations on reading to the end of this tutorial!

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

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

Have fun and happy researching!