TypeError: 'NoneType' object is not iterable

Question

What does TypeError: 'NoneType' object is not iterable mean? Example:

for row in data:  # Gives TypeError!
    print(row)

Intermezzo

This is one of my annoying disappointments in Python. When None is coerced into as sequence it must produce an empty sequence, totally harmless. – Darlleen

@nehemiah: Python is strongly typed (just not statically typed). None is never coerced to anything. Having None silently behave like other types hides errors; that's the opposite of "harmless". If you need a falsy placeholder for the empty sequence, you can use () or ''/"", both of which are singletons and can be loaded as cheaply as None. If you want to opt-in to silently treating anything falsy as an empty sequence, you could do for row in data or ():, but no one does that, because passing None to a function expecting a sequence is an error that shouldn't pass silently. – Heresy

You may also get this error when in python 2 installing a module that no longer supports python 2, e.g. https://mcmap.net/q/128684/-python-2-7-installing-opencv-via-pip-virtual-environment/838494 – Amah

Answer 1

It means the value of data is None.

Elemental

Correct, But the common scenario author intended here is totally to skip the for loop instead of raising an exception. Python's design is flawed here. When None is treated as an iterable it must return empty list at least. This exception never helped anyone in real life other than making us insert few ugly if data is not None: kind of handling. – Darlleen

Try for i in data or [] – Unwarranted

@nehemiah: Actually, the correct approach is not to check if data is or is not None, but to let the exception occur. You want the consumers of your API to know when they've used it incorrectly. Accepting None as an empty sequence would let mistakes like mylist = mylist.extend(morestuff), manage to hide even longer; they think they extended a list (and they did, but then immediately replaced it with None), then pass it to the OP's function and wonder why the file is empty, with no errors raised of any kind. – Heresy

@Darlleen Python's design is certainly not flawed. Stricter type systems make bugs much easier to find. cf. Rust, Haskell, Scala, et al. – Copybook

You do realize that Python is not strongly typed language, right,, At least be consistent everywhere instead of trying to be everything. – Darlleen

@Darlleen As others have said, Python is most definitely strongly typed. You have an example right here! Another is that e.g. 1+'0' and 1+None both (thankfully) result in an error. Maybe what you meant is that Python is not statically typed, that is true. – Psychotic

@ArthurTacca I'm all for strongly typed as long as they are consistently enforced. Pythons design is not consistent. bool(None) is okay but list(None) isn't it. Not so good. – Darlleen

@Darlleen In C++, bool(nullptr) is OK but std::vector<std::string>{nullptr} is not. Does that mean that C++ is not strongly typed? Of course not. It's just that, in Python and C++ and lots of other strongly typed languages, lots more things are truthey/falsey that can be used as sequences. – Psychotic

@ArthurTacca bringing cpp is not an ideal comparison. Python being a high level language converting between different types is essential in practicality. bool(None) is False, list(None) shud be [] and dict(None) shud be {} that's the clean design. – Darlleen

@Darlleen Ironically, what you're saying is that Python is too strongly typed for your preference! – Psychotic

Answer 2

Explanation of error: 'NoneType' object is not iterable

In python2, NoneType is the type of None. In Python3 NoneType is the class of None, for example:

>>> print(type(None))     #Python2
<type 'NoneType'>         #In Python2 the type of None is the 'NoneType' type.

>>> print(type(None))     #Python3
<class 'NoneType'>        #In Python3, the type of None is the 'NoneType' class.

Iterating over a variable that has value None fails:

for a in None:
    print("k")     #TypeError: 'NoneType' object is not iterable

Python methods return NoneType if they don't return a value:

def foo():
    print("k")
a, b = foo()      #TypeError: 'NoneType' object is not iterable

You need to check your looping constructs for NoneType like this:

a = None 
print(a is None)              #prints True
print(a is not None)          #prints False
print(a == None)              #prints True
print(a != None)              #prints False
print(isinstance(a, object))  #prints True
print(isinstance(a, str))     #prints False

Guido says only use is to check for None because is is more robust to identity checking. Don't use equality operations because those can spit bubble-up implementationitis of their own. Python's Coding Style Guidelines - PEP-008

NoneTypes are Sneaky, and can sneak in from lambdas:

import sys
b = lambda x : sys.stdout.write("k") 
for a in b(10): 
    pass            #TypeError: 'NoneType' object is not iterable 

NoneType is not a valid keyword:

a = NoneType     #NameError: name 'NoneType' is not defined

Concatenation of None and a string:

bar = "something"
foo = None
print foo + bar    #TypeError: cannot concatenate 'str' and 'NoneType' objects

What's going on here?

Python's interpreter converted your code to pyc bytecode. The Python virtual machine processed the bytecode, it encountered a looping construct which said iterate over a variable containing None. The operation was performed by invoking the __iter__ method on the None.

None has no __iter__ method defined, so Python's virtual machine tells you what it sees: that NoneType has no __iter__ method.

This is why Python's duck-typing ideology is considered bad. The programmer does something completely reasonable with a variable and at runtime it gets contaminated by None, the python virtual machine attempts to soldier on, and pukes up a bunch of unrelated nonsense all over the carpet.

Java or C++ doesn't have these problems because such a program wouldn't be allowed to compile since you haven't defined what to do when None occurs. Python gives the programmer lots of rope to hang himself by allowing you to do lots of things that should cannot be expected to work under exceptional circumstances. Python is a yes-man, saying yes-sir when it out to be stopping you from harming yourself, like Java and C++ does.

Kura

(a) Confuses NoneType and None (b) thinks that NameError: name 'NoneType' is not defined and TypeError: cannot concatenate 'str' and 'NoneType' objects are the same as TypeError: 'NoneType' object is not iterable (c) comparison between Python and java is "a bunch of unrelated nonsense" – Tisza

Umm... Java would have essentially identical problems if you passed null to a function expecting any collection type. C++ would have the same problem (but generally just die in a segfault without reporting the cause) for nullptr (admittedly, good C++ rarely uses pointers, but what you've demonstrated is bad Python, and bad C++ can die at runtime from nulls too). Python is doing the correct thing here; it's not "soldiering on", it's erroring out the moment you try to use None for anything None can't do. Your problem isn't with Python, it's with dynamically typed languages in general. – Heresy

Answer 3

Code: for row in data:
Error message: TypeError: 'NoneType' object is not iterable

Which object is it complaining about? Choice of two, row and data. In for row in data, which needs to be iterable? Only data.

What's the problem with data? Its type is NoneType. Only None has type NoneType. So data is None.

You can verify this in an IDE, or by inserting e.g. print "data is", repr(data) before the for statement, and re-running.

Think about what you need to do next: How should "no data" be represented? Do we write an empty file? Do we raise an exception or log a warning or keep silent?

Tisza

Answer 4

Another thing that can produce this error is when you are setting something equal to the return from a function, but forgot to actually return anything.

Example:

def foo(dict_of_dicts):
    for key, row in dict_of_dicts.items():
        for key, inner_row in row.items():
            Do SomeThing
    #Whoops, forgot to return all my stuff

return1, return2, return3 = foo(dict_of_dicts)

This is a little bit of a tough error to spot because the error can also be produced if the row variable happens to be None on one of the iterations. The way to spot it is that the trace fails on the last line and not inside the function.

If your only returning one variable from a function, I am not sure if the error would be produced... I suspect error "'NoneType' object is not iterable in Python" in this case is actually implying "Hey, I'm trying to iterate over the return values to assign them to these three variables in order but I'm only getting None to iterate over"

Danutadanya

This is exactly what brought me here. So what's the Pythonic solution for such situation? – Francescafrancesco

It seems like there is some help here:#1275375 – Francescafrancesco

Dr_Zaszus that's exactly my question as well. This particular answer only says that there is indeed the problem. And, the accepted answer basically also just says "yes, this will throw an error". The entire thread is devoid of actual, good, accepted-practice answers to resolve the underlying problem. The best solution mentioned is in a comment, which is to add "if data is not None:", which is an ugly solution. – Selfcontradiction

Answer 5

It means that the data variable is passing None (which is type NoneType), its equivalent for nothing. So it can't be iterable as a list, as you are trying to do.

Page

it would be nice if just iterated like an empty list... would nake for cleaner code and less error checking – Salmonoid

@Salmonoid It would make for a lot of problems being more difficult to detect I think. I'm glad None is different from an empty iterable. If you want your described behaviour, just use for row in data or []: – Opia

@Opia it's lot cleaner if it returns empty list. If you want it to fail you can always add a line if data is None: raise – Darlleen

Answer 6

You're calling write_file with arguments like this:

write_file(foo, bar)

But you haven't defined 'foo' correctly, or you have a typo in your code so that it's creating a new empty variable and passing it in.

Hamfurd

Answer 7

For me it was a case of having my Groovy hat on instead of the Python 3 one.

Forgot the return keyword at the end of a def function.

Had not been coding Python 3 in earnest for a couple of months. Was thinking last statement evaluated in routine was being returned per the Groovy (or Rust) way.

Took a few iterations, looking at the stack trace, inserting try: ... except TypeError: ... block debugging/stepping thru code to figure out what was wrong.

The solution for the message certainly did not make the error jump out at me.

Addend

Answer 8

It means data is None, which is not an iterable. Adding an or []* prevents the exception and doesn't print anything:

for row in data or []:  # no more TypeError!
    print(row)

* credits to some earlier comments; please beware that raising an exception may be a desired behavior too and/or an indicator of improper data setting.

Paracelsus

Answer 9

It also depends on Python version you are using. Seeing different error message thrown in python 3.6 and python 3.8 as following which was the issue in my case

• Python 3.6

(a,b) = None
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not iterable

• Python 3.8

(a,b) = None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot unpack non-iterable NoneType object

Cowherb

Answer 10

because using for loop while the result it is just one value not a set of value

pola.py

@app.route("/search")
def search():
    title='search'
    search_name =  request.form.get('search')
    
    search_item =   User.query.filter_by(id=search_name).first()

    return render_template('search.html', title=title, search_item=search_item  ) 

search.html (wrong)

{% for p in search %}
{{ p }}

search.html (correct)

<td>{{ search_item  }}</td>

Orthoscope

Answer 11

i had this error with pandas in databricks.

The solution for this error was install the library in the cluster enter image description here

Disburse

You need to include the code using a code block rather than a picture of it. – Landman

Answer 12

It's implied in many answers here but the solution to this error (and the related TypeError: cannot unpack non-iterable NoneType object) is not try to fix it at the line this error occurs but fix the process that generates data. For example if data is a value returned from a function, then make sure that function returns an iterable object (such as list, numpy ndarray, pandas DataFrame etc.). If data is the value returned from some API call, make sure to check that the request returned an iterable object.

For example in the following case, function func() prints a value, which implicitly returns None, which results in the TypeError in the title once we try to iterate over it.

def func():
    print('a string')

list(func())  # TypeError: 'NoneType' object is not iterable

Instead make sure to return a value:

def func():
    return 'a string'

list(func())  # ['a', ' ', 's', 't', 'r', 'i', 'n', 'g']

Coverup