Understanding The Nonetype Object: Iterability Errors

TypeError: ‘NoneType’ object is not iterable is a common error message that programmers may encounter when attempting to iterate over a variable or object that has a value of None. This error message indicates that the object being operated on is not iterable, meaning it cannot be looped over or accessed as a sequence of items. In this article, we will explore the causes of this error, explain the error message in detail, provide troubleshooting tips, and cover FAQs related to this issue.

## Common Error Message

The most common error message associated with this issue is:

“`
TypeError: ‘NoneType’ object is not iterable
“`

This error message usually occurs when a programmer attempts to iterate over a variable or object that is assigned a value of None. It highlights that the object being operated on is not iterable and cannot be used in a loop or accessed as a sequence.

## Explanation of the Error Message

To understand the error message, it is essential to grasp the concept of iterable objects in programming. Iterable objects are ones that can be looped over or accessed as a sequence. Examples of iterable objects include lists, strings, tuples, dictionaries, and sets.

In contrast, non-iterable objects cannot be looped over or accessed as a sequence. Such objects do not implement the necessary methods or protocols that allow iteration. When attempting to iterate over a non-iterable object, the interpreter will raise a TypeError with the message “‘NoneType’ object is not iterable.”

The error message specifically mentions “NoneType” because the None value in Python is represented by the “NoneType” object. If a variable or object is assigned the value of None, it means that it does not have a valid value or reference to an iterable object.

## Causes of the Error

There are several common causes of this error. Let’s explore them in detail:

1. Assigning None to a variable: If a variable is assigned the value of None, attempting to iterate over or access it as a sequence will result in the TypeError. For example:

“`python
my_variable = None
for item in my_variable:
# Raises TypeError: ‘NoneType’ object is not iterable
“`

2. Function returning None: If a function does not explicitly return a value or returns None, and the return value is assigned to a variable, iterating over that variable can cause the TypeError. For example:

“`python
def my_function():
return None

result = my_function()
for item in result:
# Raises TypeError: ‘NoneType’ object is not iterable
“`

3. Incorrect function call or method invocation: Calling a function or method that should return an iterable object but instead returns None can lead to this error. Double-checking the function’s documentation or implementation is crucial in such cases.

4. Mistakenly accessing attribute or index of None: If a programmer mistakenly attempts to access an attribute or index of a None object, it will result in the TypeError. For instance:

“`python
my_list = None
print(my_list[0])
# Raises TypeError: ‘NoneType’ object is not subscriptable
“`

## Iterating Through Non-Iterable Objects

To avoid the TypeError, it is crucial to ensure that the object being iterated over is, in fact, iterable. Before attempting to iterate over an object, programmers should consider the following:

1. Check if the object is None before iteration: Before entering a loop or iterator, it is wise to verify that the object being iterated over is not None. By checking for None, you can prevent the iteration from occurring and handle the None case separately.

“`python
my_list = None

if my_list is not None:
for item in my_list:
# Perform iteration

# Handle the None case separately
“`

2. Validate objects returned by functions: When calling functions that are expected to return iterable objects, it is essential to validate the return value before proceeding with iteration. This can be achieved by checking if the return value is not None.

“`python
def my_function():
# Function logic
return None

result = my_function()

if result is not None:
for item in result:
# Perform iteration

# Handle the None case separately
“`

## Nested Iterable Objects

Sometimes, the TypeError: ‘NoneType’ object is not iterable can be a result of nested objects that are not iterable. In such cases, it is necessary to identify which object in the nested structure is causing the issue and handle it accordingly.

Consider the following example:

“`python
my_list = [1, 2, None, 4]

for item in my_list:
for sub_item in item:
# Raises TypeError: ‘NoneType’ object is not iterable
“`

In this case, the issue is caused by the None object within the my_list. By identifying and handling the None object within the nested structure, the TypeError can be avoided.

## Troubleshooting the Error

Here are some specific TypeError scenarios related to non-iterable objects and their respective solutions:

1. TypeError: ‘NoneType’ object is not iterable when attempting to sort a list:

This error occurs when trying to sort a list that contains a None object. Before sorting, remove or handle the None value appropriately.

2. TypeError: ‘NoneType’ object is not subscriptable:

This error is raised when accessing an attribute or index of a None object. Ensure that the object is not None before performing attribute or index operations.

3. TypeError: object is not iterable:

This generic error message can occur when attempting to iterate over an object that is not iterable. Verify that the object is not None and that it is compatible with iteration.

4. TypeError: ‘NoneType’ object is not iterable in Django:

This error may be encountered in Django applications when trying to iterate over a queryset that contains a None value. Examine the queryset and handle or exclude the None values accordingly.

5. TypeError: ‘NoneType’ object is not iterable in JavaScript:

When working with JavaScript, this error can occur when attempting to loop over an object that is undefined or null. Ensure that the object is defined and not null before performing any iterations.

6. ImportError: cannot import name ‘whisper’ from ‘module’ (unknown location) – Type Error: argument of type ‘NoneType’ is not iterable:

This error, while not directly related to iterability, can be encountered when importing modules in Python. Verify the import statement and the module you are trying to import from.

7. TypeError: ‘Queue’ object is not iterable:

If you are working with the Queue object from the queue module in Python, this error can occur when trying to iterate over the Queue object directly. Instead, use the appropriate Queue methods, such as get() or get_nowait(), to retrieve items from the queue.

## FAQs

Q1. What does “‘NoneType’ object is not iterable” mean?
A1. This error message indicates that the object being operated on is not iterable and cannot be looped over or accessed as a sequence.

Q2. How can I fix the TypeError: ‘NoneType’ object is not iterable?
A2. To fix this error, ensure that the object being iterated over is not None. Perform necessary checks to handle the None case separately before entering the loop or iterator.

Q3. Why do I get a TypeError when sorting a list with None values?
A3. Sorting a list that contains None objects can raise a TypeError. Before sorting, remove or handle the None values appropriately.

Q4. How can I iterate over nested iterable objects without causing a TypeError?
A4. When working with nested iterable objects, identify which object in the nested structure is causing the TypeError. Handle or exclude the non-iterable object within the nested structure.

Q5. Why am I getting the TypeError: ‘NoneType’ object is not iterable in Django?
A5. If you encounter this error in a Django application, check the queryset you are iterating over and handle or exclude any None values in the queryset.

Q6. How can I avoid the “TypeError: object is not iterable” message?
A6. To avoid this error message, ensure that the object being iterated over is not None. Additionally, verify that the object is compatible with iteration.

In conclusion, the TypeError: ‘NoneType’ object is not iterable is a common error that occurs when attempting to iterate over a variable or object with a value of None. By understanding the error message, its causes, and implementing the troubleshooting tips provided in this article, programmers can effectively resolve this issue and ensure smooth execution of their code.

Why is my object not iterable?

Introduction:

Iterability is an important concept in the world of programming. It allows us to perform various operations on objects through iteration or looping. However, there are instances when you may encounter an error stating that your object is not iterable. This can be frustrating, especially if you’re unfamiliar with the root cause of the issue. In this article, we’ll explore the reasons why your object might not be iterable, and how you can resolve this issue. We’ll dive deep into the topic, covering various scenarios and providing helpful insights.

Possible Reasons for an Object Not Being Iterable:

1. Missing “__iter__” or “__getitem__” Methods:
One of the common causes for an object not being iterable is the absence of the “__iter__” or “__getitem__” methods. These methods define the behavior of an object when it’s iterated over. If your object lacks these methods, Python won’t recognize it as iterable, resulting in an error. To resolve this, you need to implement these methods in your object’s class and define the logic for iteration and indexing. Once these methods are in place, your object should become iterable.

2. Incorrect Usage of Iteration Constructs:
Another reason for an object not being iterable could be due to the misuse of iteration constructs, such as “for” loops. These constructs expect an iterable object to iterate over. If you mistakenly pass a non-iterable object, it will result in an error. To fix this issue, ensure that you’re providing a valid iterable object for your iteration construct.

3. Iterability of Mutables vs. Immutables:
In Python, some objects like lists and tuples are mutable, while others like strings and integers are immutable. Only mutable objects can be iterated upon, as they can change their state during iteration. Immutable objects, on the other hand, cannot be altered during iteration. If you attempt to iterate over an immutable object, it will result in an error. To overcome this, you can convert your immutable object to a mutable one, such as converting a string to a list, and then iterate over it.

4. Unsuccessful Conversion to an Iterator:
An object needs to be converted into an iterator to be iterable. This conversion is achieved by calling the “__iter__” method on the object. If the conversion fails, the object will not be iterable. This can occur if the object doesn’t have the necessary methods to support iteration. To resolve this, ensure that your object can be successfully converted into an iterator by implementing the required methods.

5. Syntax Errors or Typos:
Sometimes, a simple syntax error or a typo can lead to an object not being iterable. Missing brackets, incorrect variable names, or misspelled function names can prevent your code from executing correctly, resulting in an error. It’s essential to debug your code thoroughly and ensure there are no typos or syntax errors causing the issue.

FAQs:

Q1. Can I make a custom object iterable?
Absolutely! By implementing the “__iter__” and “__getitem__” methods in your object’s class, you can make it iterable. These methods define how your object should behave during iteration or indexing.

Q2. Why does Python require an object to be iterable?
Iteration is a fundamental concept in programming that allows us to process elements of a collection one by one. By requiring an object to be iterable, Python ensures that you can perform iteration-related operations on it.

Q3. How can I identify if an object is iterable before encountering an error?
You can use the “isinstance” function to check if an object is iterable. For example, “isinstance(my_object, Iterable)” will return True if the object is iterable and False if it is not.

Q4. Are all Python built-in objects iterable?
No, not all built-in objects in Python are iterable. While lists, tuples, and dictionaries are iterable, other objects like integers, strings, and booleans are not. It depends on the nature and behavior of the specific object.

Q5. How can I solve the issue of a non-iterable object when using a “for” loop?
Ensure that you’re providing an iterable object for the “for” loop to iterate over. If the object is not iterable, you can consider converting it to an iterable form or modifying your code accordingly.

Conclusion:

Iterability plays a significant role in programming, allowing us to perform repeated tasks efficiently. When encountering an error stating that your object is not iterable, consider the possible causes discussed in this article. By implementing the necessary methods, ensuring correct usage of iteration constructs, and understanding the difference between mutables and immutables, you can resolve the issue and make your object iterable. Remember to double-check your code for syntax errors or typos that might be causing the problem. With a clear understanding of the reasons behind a non-iterable object and the appropriate solutions, you’ll be well-equipped to tackle such errors in your coding journey.

How to Iterate NoneType Object in Python

Python is a versatile programming language that offers a wide range of tools and features to tackle various tasks efficiently. One such task is iterating over objects. However, sometimes we encounter a NoneType object while iterating, which can lead to unexpected errors. In this article, we will delve into the concept of NoneType objects in Python and explore different techniques to iterate over them effectively.

Understanding NoneType Object in Python

In Python, None is a special built-in constant that represents the absence of a value or a null value. It is commonly used to indicate the absence of a return value from a function or method. When a function or method does not explicitly return anything, it automatically returns None.

A NoneType object is an instance of None. It is the data type of the None constant and represents the lack of data or absence of a value.

Iterating over NoneType Object

By default, NoneType objects are not iterable in Python. When we try to iterate over a NoneType object, a TypeError is raised with the message “‘NoneType’ object is not iterable”. This occurs because the Python interpreter expects an object that implements iteration methods such as __iter__() or __getitem__(). Since a NoneType object lacks these methods, it cannot be iterated over using conventional iteration techniques.

To overcome this limitation, we need to handle the NoneType object separately before attempting iteration. Several approaches can be adopted to accomplish this.

Approach 1: Check for None

The simplest way to handle NoneType objects before iteration is by explicitly checking if the object is None. We can use an if statement to ensure that the object is not None before attempting iteration. For example:

“`
my_object = None

if my_object is not None:
for item in my_object:
# perform iteration operations
“`

This check ensures that the code inside the loop is executed only if the object is not None. Otherwise, it skips the iteration, preventing the TypeError.

Approach 2: Use Empty Iterable

Another approach is to use an empty iterable object in place of the NoneType object. This approach provides a clean and concise way to handle NoneType objects. Python provides an empty iterable object called an empty tuple, denoted by (). We can substitute the NoneType object with this empty tuple and iterate over it safely. Here’s an example:

“`
my_object = None

for item in my_object or ():
# perform iteration operations
“`

In this code snippet, we utilize the short-circuit behavior of the `or` operator. If `my_object` is None, the expression `(my_object or ())` evaluates to an empty tuple. Otherwise, it evaluates to `my_object` itself. Therefore, the loop executes without any issues in both cases.

FAQs

Q: What is a NoneType object in Python?
A: A NoneType object is an instance of the None constant in Python. It represents the absence of a value or the lack of data.

Q: Why am I getting a TypeError when trying to iterate over a NoneType object?
A: The TypeError occurs because NoneType objects do not implement the necessary iteration methods, such as __iter__() or __getitem__(). Therefore, the Python interpreter raises an error message stating that the ‘NoneType’ object is not iterable.

Q: How can I avoid the TypeError when iterating over a NoneType object?
A: You can avoid the TypeError by explicitly checking if the object is None before attempting iteration using an if statement. Alternatively, you can use an empty iterable object like an empty tuple to safely iterate over NoneType objects.

Q: Are there any other special behaviors of None in Python?
A: Yes, None is also a falsy value in Python. This means that when used in conditional statements, it evaluates to False. It is often used to denote the absence of a value or a default value in a variable.

Q: Can I modify a NoneType object?
A: No, NoneType objects are immutable in Python. Once assigned, their value cannot be changed. Any attempt to modify a NoneType object will result in a TypeError.

In conclusion, handling NoneType objects while iterating is a crucial aspect of Python programming. By applying the techniques discussed in this article, you can effectively iterate over NoneType objects without encountering any errors. Remember to check for None explicitly or use an empty iterable like an empty tuple to ensure smooth iteration.

TypeError: ‘NoneType’ object is not iterable – Sorting a List

A TypeError is a common error that Python programmers encounter when dealing with lists or other iterable objects. This error specifically occurs when you try to perform an operation that requires iteration on an object that does not support it, such as a NoneType object. In this article, we will explore the causes, solutions, and FAQ related to the TypeError: ‘NoneType’ object is not iterable error.

Understanding Iterable Objects in Python
To comprehend why this error occurs, we must first understand iterable objects in Python. An iterable is any object that can be looped over, allowing us to process each item in the collection one by one. Lists, strings, tuples, sets, and dictionaries are all examples of common iterable objects in Python.

The Iteration Process and NoneType
When a list is sorted in Python, an iteration process is involved under the hood. During this process, each element of the list is compared with the others using a specified sorting algorithm. However, if any of the elements in the list are of NoneType, which represents the absence of a value, the TypeError: ‘NoneType’ object is not iterable error may occur.

Causes of TypeError: ‘NoneType’ object is not iterable
1. Missing return statement: If a function that is expected to return a list ends without a return statement, it implicitly returns None. This can cause the error when trying to sort the returned value.

2. Incorrect function call: Calling a function that is expected to return a list but instead returns None can cause this error. Double-checking function calls is crucial in this context.

3. Modification of a None value: Attempting to iterate over a list that contains a None element can also trigger this TypeError. Therefore, carefully examine the objects in your list to ensure none of them are NoneType.

Solutions to TypeError: ‘NoneType’ object is not iterable
1. Check function return values: Inspect all functions that are involved in the sorting process and verify that they always return a list. If any function returns None, update the code to resolve the issue.

2. Verify list elements: If you encounter the error while sorting a list, examine the elements within the list and ensure that none of them are NoneType. If necessary, remove or replace any None values with valid objects.

3. Debugging through print statements: Place print statements within your code to identify which part is actually causing the error. By segregating the sorting process into different phases, you can pinpoint exactly where the TypeError is occurring.

4. Utilize conditional statements: Add conditional statements to handle scenarios where the list may contain NoneType objects. By using an if statement to check for NoneType before iterating over the list, you can avoid the TypeError.

5. Implement exception handling: Wrap the code block that is causing the TypeError in a try-except block. Within the except block, catch the TypeError and execute alternative code or handle the exception gracefully.

FAQs

Q1. What is a NoneType object in Python?
A1. NoneType is a special built-in type in Python that represents the absence of a value. It is commonly used to indicate the absence of a variable or a placeholder.

Q2. Can a list contain NoneType objects?
A2. Yes, a list in Python can contain NoneType objects. However, if you attempt to iterate or sort the list, you may encounter the TypeError: ‘NoneType’ object is not iterable error if a NoneType object is present.

Q3. How can I handle the TypeError in a program that involves user input?
A3. To handle the TypeError when user input is involved, it is essential to validate and sanitize the input beforehand. Checking for NoneType values and gracefully handling any potential errors can ensure a smooth execution.

Q4. Are there any built-in methods in Python to sort a list that may contain NoneType objects?
A4. Yes, Python provides a versatile sorting method called ‘sorted()’ that can handle lists with NoneType objects. However, it is important to preprocess the list and handle NoneType values appropriately, as discussed earlier.

Q5. Can I use the ‘sort()’ method to sort a list with NoneType objects?
A5. The ‘sort()’ method in Python does not work directly with lists containing NoneType objects. However, you can use the ‘sorted()’ method, as mentioned earlier, to sort such lists.

In conclusion, the TypeError: ‘NoneType’ object is not iterable is a common error that occurs when attempting to sort or iterate over a list or collection that contains NoneType objects. By understanding the causes and following the solutions outlined in this article, programmers can successfully overcome this error and ensure their code runs smoothly. Remember the significance of proper function returns, element checks, debugging techniques, conditional statements, and exception handling to resolve and prevent this TypeError.

Understanding the ‘Nonetype’ Object is Not Subscriptable Error

If you have ever come across the error message ‘nonetype’ object is not subscriptable while writing or debugging your Python code, you might have wondered what it means and how to resolve it. This article aims to provide a comprehensive understanding of this error and guide you through resolving it. So, let’s dive in!

What is the ‘Nonetype’ Object?

In Python, ‘None’ is a special constant that represents the absence of a value or an empty value. It is commonly used to indicate that a variable does not refer to any object or has no value assigned to it. The type of the ‘None’ object is referred to as ‘NoneType’.

Understanding the ‘Nonetype’ Object is Not Subscriptable Error

The error message ‘nonetype’ object is not subscriptable typically occurs when you try to access an element or attribute of an object that is of ‘NoneType’. Python treats ‘NoneType’ objects as special cases and does not allow indexing or subscripting them.

To better understand this error, let’s consider an example:

“`
my_list = None
print(my_list[0])
“`

The above code would result in the following error:

“`
TypeError: ‘NoneType’ object is not subscriptable
“`

Here, we have assigned the value ‘None’ to the variable ‘my_list’. Since ‘my_list’ does not refer to any object, it is of type ‘NoneType’. When we try to access the first element of ‘my_list’ using indexing, it raises an error because ‘NoneType’ objects do not support subscripting.

Common Causes of the Error

1. Forgetting to return a value from a function: If a function does not explicitly return a value or returns ‘None’, and you try to access the returned value using indexing or attribute access, this error may occur.

2. Incorrect assignment or initialization: Assigning ‘None’ to a variable or mistakenly initializing it as ‘None’ can lead to this error when trying to access elements or attributes.

3. Unexpected API response: When working with APIs, if the response received is ‘None’, attempting to subscript or access its attributes can cause this error.

Resolving the ‘Nonetype’ Object is Not Subscriptable Error

To resolve this error, you need to identify the root cause and apply the appropriate solution. Here are some possible resolutions:

1. Check your function returns: Ensure that functions return the expected values or objects instead of ‘None’. If ‘None’ is a valid return value, handle it appropriately when accessing the function’s return.

2. Validate input and assignments: Double-check your code for any assignments or initialization that may lead to ‘None’ values. Avoid subscripting or accessing attributes of variables that may potentially hold ‘None’.

3. Handle unexpected API responses: When making API calls, always handle the possibility of ‘None’ responses. Verify the response received and consider the appropriate error handling or alternative logic.

4. Use conditional statements: To avoid accessing elements or attributes of ‘NoneType’ objects directly, use conditional statements to check if the object is not ‘None’ before performing the intended operations.

5. Debug your code: If the error persists, try using print statements or debuggers to trace the program flow and identify the specific line causing the error. This will help you narrow down the issue and find a suitable solution.

FAQs

Q1: Can ‘NoneType’ objects be subscripted or indexed in any case?
A1: No, ‘NoneType’ objects cannot be subscripted or indexed under any circumstances. They do not support such operations.

Q2: Why does Python treat ‘NoneType’ objects differently?
A2: Python treats ‘NoneType’ objects as a special case to signify the absence of a value or an uninitialized variable. Restricting subscripting helps prevent errors and encourages explicit handling of such cases in your code.

Q3: Can I assign a value to a ‘NoneType’ object?
A3: No, you cannot assign a value to ‘NoneType’ objects. However, you can assign ‘None’ to other types of objects in Python.

In conclusion, encountering the ‘nonetype’ object is not subscriptable error in Python signifies that you are trying to perform indexing or subscripting on a variable that holds a ‘NoneType’ object. By understanding the causes and resolutions discussed in this article, you can efficiently handle this error and write more robust Python code. Happy coding!

TypeError: object is not iterable

When working with programming languages such as Python, you might come across a common error known as “TypeError: object is not iterable.” This error occurs when you try to iterate over an object that is not considered iterable. In this article, we will explore what this error means, common scenarios where it may arise, and how to effectively resolve it.

Understanding Iterables

To comprehend the “TypeError: object is not iterable” error, it is crucial to have a clear understanding of the concept of iterable objects. An iterable is an object that can be looped over, or items that can be accessed in a sequential manner. Examples of iterable objects in Python include strings, lists, tuples, and dictionaries.

Error Causes

There are several common scenarios that can lead to the “TypeError: object is not iterable” error. Let’s explore a few of them:

1. Incorrect Usage of Objects: One of the most frequent causes of this error is attempting to iterate over an object that is not iterable. For instance, trying to loop through an integer or a None value will result in a “TypeError: object is not iterable.”

2. Forgetting to Cast an Object: Sometimes, you might forget to cast an object into an iterable type before trying to iterate over it. This often happens when working with user inputs or external data sources. Always ensure that the object you are trying to iterate over has a valid iterable type.

3. Typo in Variable Names: Another common mistake that can lead to this error is misspelling or mistyping the variable names. If you accidentally use an incorrect variable name, Python might interpret it as a non-iterable object, resulting in the “TypeError: object is not iterable.”

Resolving the Error

Now that we have a good understanding of the “TypeError: object is not iterable” error and its causes, let’s delve into some effective ways to resolve it:

1. Verify Object’s Iterability: First and foremost, you need to ensure that the object you are attempting to iterate over is actually iterable. Check the object’s type and ensure that it belongs to a valid iterable category, such as a string, list, tuple, or dictionary.

2. Check Loop Syntax: Examine your loop syntax carefully. Make sure you are using the correct loop statement, such as “for” or “while,” and that your loop variables reference valid iterable objects.

3. Cast Non-Iterable Objects: If you are dealing with an object that is not inherently iterable, consider casting it into an iterable type. For example, if you have a string that you want to iterate character by character, use the “list()” function to convert it into a list.

4. Validate Variable Names: Double-check all variable names used in your code. Ensure that they match the intended objects and that there are no typos or misspelled words. A simple typographical error can easily result in a “TypeError: object is not iterable.”

5. Use Exception Handling: Implement exception handling mechanisms, such as a try-except block, to catch and handle errors during runtime appropriately. By anticipating potential errors, you can provide users with meaningful error messages or alternative actions.

FAQs

Q: How can I determine if an object is iterable?
A: You can use the `iter()` function in Python to determine if an object is iterable. If the object allows iteration, `iter()` will return an iterator object. Alternatively, you can use the `isinstance()` function to check if an object belongs to an iterable type, such as list, tuple, or string.

Q: What does “TypeError: ‘int’ object is not iterable” mean?
A: This particular error message indicates that you are trying to iterate over an integer object, which is not considered iterable. Remember that integers are not inherently iterable, but you can cast them into an iterable type if required.

Q: Why am I getting a “TypeError: object is not iterable” when working with a dictionary?
A: Dictionaries in Python are iterable, but when looping through a dictionary, the default behavior is to iterate over its keys. If you want to iterate over its values or key-value pairs, use the `values()` or `items()` methods, respectively.

Q: Can I iterate over a None object?
A: No, you cannot iterate over a None object. Since None is not an iterable type, attempting to loop over it will result in the “TypeError: object is not iterable.” Make sure to assign an appropriate iterable object to the variable instead.

Conclusion

The “TypeError: object is not iterable” error often occurs due to attempts to iterate over non-iterable objects or mistakes in variable naming. By understanding the causes and following the resolution steps mentioned in this article, you can effectively resolve this error. Always ensure that you are working with valid iterable objects and pay attention to loop syntax and variable names.

Found 9 images related to nonetype’ object is not iterable theme