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

I know this question has been asked before but I can’t seem to get mine to work.

import numpy as np


def load_dataset():
    def download(filename, source="http://yaan.lecun.com/exdb/mnist/"):
        print ("Downloading ",filename)
        import urllib
        urllib.urlretrieve(source+filename,filename)

    import gzip
    
    def load_mnist_images(filename):
        if not os.path.exists(filename):
            download(filename)
        with gzip.open(filename,"rb") as f:
            data=np.frombuffer(f.read(), np.uint8, offset=16)
            
            data = data.reshape(-1,1,28,28)
            
            return data/np.float32(256)

        def load_mnist_labels(filename):
            if not os.path.exists(filename):
                download(filename)
            with gzip.open(filename,"rb") as f:
                data = np.frombuffer(f.read(), np.uint8, offset=8)
            return data

        X_train = load_mnist_images("train-images-idx3-ubyte.gz")
        y_train = load_mnist_labels("train-labels-idx1-ubyte.gz")
        X_test = load_mnist_images("t10k-images-idx3-ubyte.gz")
        y_test = load_mnist_labels("t10k-labels-idx1-ubyte.gz")

        return X_train, y_train, X_test, y_test


X_train, y_train, X_test, y_test = load_dataset()


import matplotlib
matplotlib.use("TkAgg")

import matplotlib.pyplot as plt
plt.show(plt.imshow(X_train[3][0]))

This is the error I am getting:

Traceback (most recent call last):
  File "C:\Users\nehad\Desktop\Neha\Non-School\Python\Handwritten Digits 
Recognition.py", line 38, in <module>
    X_train, y_train, X_test, y_test = load_dataset()
TypeError: cannot unpack non-iterable NoneType object

I am new to machine learning. Did I just miss something simple? I am trying a Handwritten Digit Recognition project for my school Science Exhibition.

When you’re working with iterable objects like Lists, Sets, and Tuples in Python, you might want to assign the items in these objects to individual variables. This is a process known as unpacking.

During the process of unpacking items in iterable objects, you may get an error that says: «TypeError: cannot unpack non-iterable NoneType object».

This error mainly happens when you try to assign an object with a None type to a set of individual variables. This may sound confusing at the moment, but it’ll be much clearer once we see some examples.

Before that, let’s talk about some of the key terms seen in the error message. We’ll discuss the following terms: TypeError, unpacking, and NoneType.

What Is a TypeError in Python?

A TypeError in Python occurs when incompatible data types are used in an operation.

An example of a TypeError, as you’ll see in the examples in the sections that follow, is the use of a None data type and an iterable object in an operation.

What Is Unpacking in Python?

To explain unpacking, you have to understand what packing means.

When you create a list with items in Python, you’ve «packed» those items into a single data structure. Here’s an example:

names = ["John", "Jane", "Doe"]

In the code above, we packed «John», «Jane», and «Doe» into a list called names.

To unpack these items, we have to assign each item to an individual variable. Here’s how:

names = ["John", "Jane", "Doe"]

a, b, c = names

print(a,b,c)
# John Jane Doe

Since we’ve created the names list, we can easily unpack the list by creating new variables and assigning them to the list: a, b, c = names.

So a will take the first item in the list, b will take the second, and c will take the third. That is:

a = «John»
b =  «Jane»
c = «Doe»

What Is NoneType in Python?

NoneType in Python is a data type that simply shows that an object has no value/has a value of None.

You can assign the value of None to a variable but there are also methods that return None.

We’ll be dealing with the sort() method in Python because it is most commonly associated with the «TypeError: cannot unpack non-iterable NoneType object» error. This is because the method returns a value of None.

Next, we’ll see an example that raises the «TypeError: cannot unpack non-iterable NoneType object» error.

In this section, you’ll understand why we get an error for using the sort() method incorrectly before unpacking a list.

names = ["John", "Jane", "Doe"]

names = names.sort()

a, b, c = names

print(a,b,c)
# TypeError: cannot unpack non-iterable NoneType object

In the example above, we tried to sort the names list in ascending order using the sort() method.

After that, we went on to unpack the list. But when we printed out the new variables, we got an error.

This brings us to the last important term in the error message: non-iterable. After sorting, the names list became a None object and not a list (an iterable object).

This error was raised because we assigned names.sort() to names. Since names.sort() returns None, we have overridden and assigned None to a variable that used to be a list. That is:

names = names.sort()
but names.sort() = None
so names = None

So the error message is trying to tell you that there is nothing inside a None object to unpack.

This is pretty easy to fix. We’ll do that in the next section.

How to Fix “TypeError: Cannot Unpack Non-iterable NoneType Object” Error in Python

This error was raised because we tried to unpack a None object. The simplest way around this is to not assign names.sort() as the new value of your list.

In Python, you can use the sort() method on a collection of variables without the need to reassign the result from the operation to the collection being sorted.

Here’s a fix for the problem:

names = ["John", "Jane", "Doe"]

names.sort()

a, b, c = names

print(a,b,c)
Doe Jane John

Everything works perfectly now. The list has been sorted and unpacked.

All we changed was names.sort() instead of using names = names.sort().

Now, when the list is unpacked, a, b, c will be assigned the items in names in ascending order. That is:

a = «Doe»
b = «Jane»
c = «John»

Summary

In this article, we talked about the «TypeError: cannot unpack non-iterable NoneType object» error in Python.

We explained the key terms seen in the error message: TypeError, unpacking, NoneType, and non-iterable.

We then saw some examples. The first example showed how the error could be raised by using the sort() incorrectly while the second example showed how to fix the error.

Although fixing the «TypeError: cannot unpack non-iterable NoneType object» error was easy, understanding the important terms in the error message is important. This not only helps solve this particular error, but also helps you understand and solve errors with similar terms in them.

Happy coding!

---

---

Learn to code for free. freeCodeCamp’s open source curriculum has helped more than 40,000 people get jobs as developers. Get started

I know this question has been asked before but I can’t seem to get mine to work.

import numpy as np


def load_dataset():
    def download(filename, source="http://yaan.lecun.com/exdb/mnist/"):
        print ("Downloading ",filename)
        import urllib
        urllib.urlretrieve(source+filename,filename)

    import gzip
    
    def load_mnist_images(filename):
        if not os.path.exists(filename):
            download(filename)
        with gzip.open(filename,"rb") as f:
            data=np.frombuffer(f.read(), np.uint8, offset=16)
            
            data = data.reshape(-1,1,28,28)
            
            return data/np.float32(256)

        def load_mnist_labels(filename):
            if not os.path.exists(filename):
                download(filename)
            with gzip.open(filename,"rb") as f:
                data = np.frombuffer(f.read(), np.uint8, offset=8)
            return data

        X_train = load_mnist_images("train-images-idx3-ubyte.gz")
        y_train = load_mnist_labels("train-labels-idx1-ubyte.gz")
        X_test = load_mnist_images("t10k-images-idx3-ubyte.gz")
        y_test = load_mnist_labels("t10k-labels-idx1-ubyte.gz")

        return X_train, y_train, X_test, y_test


X_train, y_train, X_test, y_test = load_dataset()


import matplotlib
matplotlib.use("TkAgg")

import matplotlib.pyplot as plt
plt.show(plt.imshow(X_train[3][0]))

This is the error I am getting:

Traceback (most recent call last):
  File "C:\Users\nehad\Desktop\Neha\Non-School\Python\Handwritten Digits 
Recognition.py", line 38, in <module>
    X_train, y_train, X_test, y_test = load_dataset()
TypeError: cannot unpack non-iterable NoneType object

I am new to machine learning. Did I just miss something simple? I am trying a Handwritten Digit Recognition project for my school Science Exhibition.

Do you want to know how to fix the “Typeerror: cannot unpack non-iterable nonetype object” error?

Then this article is for you.

In this article, we will discuss what typeerror: cannot unpack non-iterable nonetype object means, give the possible causes of this error, and provide solutions to resolve this problem.

So first, let us know what this error means.

The Typeerror: cannot unpack non-iterable nonetype object is an error message that usually occurs in Python indicating that you are trying to unpack an object that is of type ‘NoneType’ and therefore not iterable.

In other words, you are trying to extract elements from an object that doesn’t exist or has no values.

Although it may be unclear at this time, it will become much clearer once we see actual examples.

But Before that, let’s discuss a few of the key terms that can be found in this error message.

We’ll talk about the concepts of TypeError, unpacking, and NoneType.

What is TypeError in Python?

TypeError is a type of error that occurs when an operation or function is performed on an object of an inappropriate type.

In this case, it means that the code is trying to perform an operation that cannot be done on a particular data type.

What is Unpacking in Python?

Unpacking refers to the process of extracting individual elements from a collection, such as a tuple or a list.

It is also known as sequence unpacking.

For example:

# Example: Unpacking a tuple
fruits = ('apple', 'banana', 'cherry')

a, b, c = fruits

print(a) 
print(b) 
print(c) 

In this example, we have a tuple of three elements named fruits.

We then unpack the elements of the tuple into three variables a, b, and c.

We can then print each variable to confirm that the values have been assigned correctly.

Output

apple
banana
cherry

Unpacking is a useful technique for quickly assigning values from collections like tuples and lists to variables.

It can also be used to simplify code and make it more readable.

What Is NoneType in Python?

In Python, ‘NoneType’ is a special type of data that represents the absence of a value.

It is often used to indicate that a function or operation did not return any value.

Next, we will see how this Typeerror: cannot unpack non-iterable nonetype object occurs.

How does Typeerror: cannot unpack non-iterable nonetype object occurs?

The “Typeerror: cannot unpack non-iterable nonetype object” error occurs when the code attempts to unpack an object that is not iterable, specifically an object of type “NoneType”.

There are some common reasons why this error occurs, Some common reasons include:

1. Incorrect function return value
2. Unpacking a None object
3. Forget to include a return statement in your function or accidentally exclude it.
4. Returning a None value instead of an iterable object

1. Incorrect function return value:

This happens if a function is supposed to return an iterable object like a tuple, list, or dictionary, but instead returns “None”.

For example:

def get_student_info(name):
    if name == 'Alice':
        return ('Alice', 'Smith', 25, '[email protected]')
    elif name == 'Bob':
        return ('Bob', 'Jones', 27, '[email protected]')
    else:
        return None


student_name = 'Charlie'
first_name, last_name, age, email = get_student_info(student_name)
print(f'{first_name} {last_name}, {age}, {email}')

In this example, it tries to unpack the None object into four variables (first_name, last_name, age, and email), which causes a TypeError to be raised with the message:

TypeError: cannot unpack non-iterable NoneType object

2. Unpacking a None object:

This can happen if a function returns None instead of an iterable object like a tuple or a list.

When you try to unpack the returned value into multiple variables, Python cannot unpack the None object, which results in the error.

For example:

def get_user_info(user_id):
    # Simulate a database query to get user info by ID
    if user_id == 1:
        return ('John', 'Doe', '[email protected]')
    elif user_id == 2:
        return ('Jane', 'Doe', '[email protected]')
    # Return None if the user ID is not found
    return None

# Try to unpack a None object
first_name, last_name, email = get_user_info(3)

# This line will not be executed if the above line raises a TypeError
print(f'Name: {first_name} {last_name}, Email: {email}')

In this example, the get_user_info function is called with an ID of 3, which does not correspond to any user in the database.

As a result, the function returns None

The next line tries to unpack the None object into three variables, which causes a TypeError to be raised with the message:

TypeError: cannot unpack non-iterable NoneType object

3. Forget to include a return statement in your function or accidentally exclude it:

This happens when there is no return statement or the return statement is missing.

Python assigns the value None to the function’s return value.

When you try to unpack None, Python raises the error.

For example:

def calculate_average(numbers):
    # Calculate the average of a list of numbers
    count = len(numbers)
    if count == 0:
        average = 0
    else:
        total = sum(numbers)
        average = total / count

    # Return the average value
    # Oops, forgot to include a return statement!


result = calculate_average([1, 2, 3, 4, 5])
print(f'The average is {result}')

In this example, we try to unpack None into the result variable, which causes a TypeError to be raised.

4. Returning a None value instead of an iterable object:

This can happen if the function is not returning the expected value or if there is an error in the function that prevents it from returning an iterable object.

For example:

def get_name():
    # Get the first and last name of a person
    first_name = input('Enter your first name: ')
    last_name = input('Enter your last name: ')

    # Print the name
    full_name = f'{first_name} {last_name}'
    print(f'Your full name is {full_name}')

print('Getting name...')
first, last = get_name()
print(f'First name: {first}')
print(f'Last name: {last}')

In this example, we assigned two variables (first and last) using sequence unpacking.

Since the function does not return an iterable object, it returns the default None value, which cannot be unpacked into the two variables.

This causes a TypeError to be raised.

Not let’s fix this error.

How to solved Typeerror: cannot unpack non-iterable nonetype object?

To fix the “Typeerror: cannot unpack non-iterable nonetype object” error, we need to ensure that the object you are trying to unpack is not “None” and is iterable.

Here are some alternative solutions that you can use:

Solution 1: Returning the correct value(s):

Make sure your function is returning the correct value(s) and that all paths of the function lead to a return statement.

Here is the updated code for the Incorrect function return value example code above:

def get_student_info(student_name):
    # This function should return a tuple with the student's first name, last name, age, and email
    # If the student is not found, return None
    if student_name == 'Alice':
        return ('Alice', 'Smith', 20, '[email protected]')
    elif student_name == 'Bob':
        return ('Bob', 'Jones', 19, '[email protected]')
    else:
        return None

student_name = 'Alice'
student_info = get_student_info(student_name)
if student_info is not None and isinstance(student_info, tuple):
    first_name, last_name, age, email = student_info
    print(f'{first_name} {last_name}, {age}, {email}')
else:
    print(f'Student {student_name} not found')

In this updated code, we have added a check to ensure that the student_info variable is not None and is also an instance of the tuple class before we attempt to unpack it.

This also handles the case where the get_student_info() function returns a non-tuple value.

Solution 2: Make sure that you’re not unpacking a None object:

You need to make sure that the object you are trying to unpack is not None before attempting to unpack it.

Here is the updated code for the Unpacking a None object example code:

def get_user_info(user_id):
    # Simulate a database query to get user info by ID
    if user_id == 1:
        return ('John', 'Doe', '[email protected]')
    elif user_id == 2:
        return ('Jane', 'Doe', '[email protected]')
    # Return None if the user ID is not found
    return None

# Try to unpack a None object
user_info = get_user_info(3)
if user_info is not None:
    first_name, last_name, email = user_info
    print(f'Name: {first_name} {last_name}, Email: {email}')
else:
    print(f'User with ID 3 not found')

Solution 3:  Define a return statement in the function:

To fix this error, you need to add a return statement to the function to return a value.

Here is the fixed code for the third example code problem above:

def calculate_average(numbers):
    # Calculate the average of a list of numbers
    count = len(numbers)
    if count == 0:
        average = 0
    else:
        total = sum(numbers)
        average = total / count

    # Return the average value
    return average


result = calculate_average([1, 2, 3, 4, 5])
print(f'The average is {result}')

Solution 4: Modify the function to return as a tuple:

By modifying the function to return the values as a tuple, you ensure that the returned value is always iterable, even if one or more of the values in the tuple is None.

This means that you can use tuple unpacking to access the individual values returned by the function.

Here is the fixed code for the fourth example code problem above:

def get_name():
    # Get the first and last name of a person
    first_name = input('Enter your first name: ')
    last_name = input('Enter your last name: ')

    # Return the names as a tuple
    return (first_name, last_name)

print('Getting name...')
first, last = get_name()
print(f'First name: {first}')
print(f'Last name: {last}')

So those are the alternative solutions that you can use to fix “Typeerror: cannot unpack non-iterable nonetype object”.

Hoping that one or more of them helps you solve your problem regarding the error.

Here are the other fixed Python errors that you can visit, you might encounter them in the future.

• typeerror unsupported operand type s for str and int
• typeerror: object of type int64 is not json serializable
• typeerror: bad operand type for unary -: str

Conclusion

In conclusion, The “Typeerror: cannot unpack non-iterable nonetype object” is an error message that occurs when the code attempts to unpack an object that is not iterable, specifically an object of type “NoneType”.

In other words, you are trying to extract elements from an object that doesn’t exist or has no values.

By following the given solution, surely you can fix the error quickly and proceed to your coding project again.

I hope this article helps you to solve your problem regarding a Typeerror stating “cannot unpack non-iterable nonetype object”.

We’re happy to help you.

Happy coding! Have a Good day and God bless.