Skip to main content

How to Resolve Python "TypeError: 'NoneType' object does not support item assignment"

The TypeError: 'NoneType' object does not support item assignment is a common Python error that occurs when you attempt to modify an element within a sequence (like a list) or assign a value to a key in a mapping (like a dictionary) using square bracket notation (variable[index] = value or variable[key] = value), but the variable currently holds the special value None.

This guide explains why None doesn't support item assignment and details the common scenarios leading to this error, along with effective solutions.

Understanding the Error: Item Assignment and None​

  • Item Assignment: The operation container[index_or_key] = new_value is used to change the value at a specific position in a mutable sequence (like a list) or to add/update a key-value pair in a mapping (like a dict). This requires the object (container) to support item assignment (implementing the __setitem__ special method).
  • None: Represents the absence of a value. It's a singleton object of type NoneType. It is immutable and does not behave like a container; it doesn't have indices or keys to assign values to.

The TypeError occurs because you are trying to perform an item assignment operation on None, which is not a valid container for this purpose.

Cause: Trying to Assign to an Index/Key of None​

The error is triggered when the variable on the left side of the item assignment (variable[...] = ...) currently holds the value None.

Code with Error (List context):

# Error Scenario 1: List context
maybe_list = None

# ⛔️ TypeError: 'NoneType' object does not support item assignment
maybe_list[0] = "value" # Trying to assign to index 0 of None
print(maybe_list)

Code with Error (Dictionary context):

# Error Scenario 2: Dictionary context
maybe_dict = None

# ⛔️ TypeError: 'NoneType' object does not support item assignment
maybe_dict['key'] = "value" # Trying to assign to key 'key' of None
print(maybe_dict)

Common Sources of None Values​

You need to investigate why the variable holds None when you expect it to hold a list or dictionary.

Explicit Assignment (my_variable = None)​

The variable was directly set to None somewhere in your code.

For example:

# Scenario: Explicit assignment
data_container = None
# ... later ...
data_container[0] = 1 # ⛔️ Error

Function Returning None Implicitly​

A function that doesn't have an explicit return statement automatically returns None.

For example:

def initialize_list():
    print("Initializing...")
    # No 'return' statement here

my_list = initialize_list() # my_list becomes None
print(f"Result of initialize_list(): {my_list}")

try:
    my_list[0] = 'a' # ⛔️ Error
except TypeError as e:
     print(f"Error from implicit None return: {e}")

Output:

Initializing...
Result of initialize_list(): None
Error from implicit None return: 'NoneType' object does not support item assignment

Assignment from Methods Returning None (e.g., list.sort())​

As mentioned previously, methods that modify objects in-place (like list.sort(), list.reverse()) often return None. Assigning their result leads to a None variable.

data = [3, 1, 2]

# Scenario: Assigning result of sort()
result_of_sort = data.sort() # data is sorted, but result_of_sort is None
print(f"Result of sort(): {result_of_sort}")

try:
    result_of_sort[0] = 0 # ⛔️ Error
except TypeError as e:
     print(f"Error from assigning sort() result: {e}")

Function Returning None Conditionally​

A function might return a list/dict only if certain conditions are met, returning None otherwise.

def get_data_if_valid(source):
    if isinstance(source, dict):
        return source # Return dict if valid
    # Implicitly returns None otherwise

config = get_data_if_valid("not a dict") # config becomes None
print(f"Result from conditional function: {config}")

try:
    config['setting'] = True # ⛔️ Error
except TypeError as e:
     print(f"Error from conditional None return: {e}")

Solution 1: Ensure Variable Holds a Mutable Container (Fix the Source)​

The most robust solution is to fix the upstream logic so the variable always holds an appropriate mutable container (like a list or dict) when you need to perform item assignment.

Initialize as an Empty List/Dict​

If a variable will be used for item assignment, initialize it correctly, often as an empty list [] or dictionary {}.

# ✅ Initialize as empty list/dict
active_users = []
user_settings = {}

# Now assignments work
active_users.append("Alice") # Use append for lists, not item assignment unless replacing
user_settings['theme'] = 'dark'

print(f"Active users: {active_users}")          # Output: Active users: ['Alice']
print(f"User settings: {user_settings}")        # Output: User settings: {'theme': 'dark'}

# To replace an item in a list (if it exists and isn't empty):
if active_users:
    active_users[0] = 'Alice Smith'
print(f"Updated active users: {active_users}")  # Output: Updated active users: ['Alice Smith']

Output:

Active users: ['Alice']
User settings: {'theme': 'dark'}
Updated active users: ['Alice Smith']

Ensure Functions Return Lists/Dicts​

Modify functions to always return the expected type, even if it's an empty one, instead of implicitly returning None.

# ✅ Function always returns a list
def get_data_if_valid_fixed(source):
    if isinstance(source, dict):
        return source # Return the dict
    else:
        return {} # Return an empty dict as default

config = get_data_if_valid_fixed("not a dict")
print(f"Result from fixed function: {config}")  # Output: {}

# ✅ Assignment now works on the empty dictionary
config['setting'] = True
print(f"Config after assignment: {config}")     # Output: {'setting': True}

Avoid Assigning Results of In-Place Methods*​

Don't assign the result of methods like list.sort() to variables if you intend to modify the (now sorted) list later. Work with the original variable name.

data = [3, 1, 2]
print(f"Original list: {data}")         # Output: Original list: [3, 1, 2]

# ✅ Call sort() directly, modifies 'data' in-place
data.sort()
print(f"Sorted list: {data}")           # Output: Sorted list: [1, 2, 3]

# ✅ Now modify the sorted list
data[0] = 99
print(f"Modified sorted list: {data}")  # Output: Modified sorted list: [99, 2, 3]

Output:

Original list: [3, 1, 2]
Sorted list: [1, 2, 3]
Modified sorted list: [99, 2, 3]

Solution 2: Check if Variable is None Before Assignment​

If the variable can legitimately be None at the point of assignment, check for it first.

maybe_list = None # Could be a list or None

# ✅ Check for None before assignment
if maybe_list is not None:
    try:
        maybe_list[0] = "New Value" # Only attempt if not None
        print("Item assigned.")
    except IndexError:
        print("List was not empty, but index 0 doesn't exist.")
else:
    # This block is executed
    print("Variable is None, cannot perform item assignment.")
    # Handle the None case (e.g., initialize, log, raise error)

Output:

Variable is None, cannot perform item assignment.

Solution 3: Assign a Default Value if None​

A common pattern is to initialize the variable to an empty container if it's currently None.

config_data = None # Might be None initially

# ✅ Assign a default empty dict if it's None
if config_data is None:
    print("Variable was None, initializing to {}.")
    config_data = {}

# ✅ Now item assignment is safe
config_data['user'] = 'admin'
print(f"Config data: {config_data}") # Output: Config data: {'user': 'admin'}

# Example with list
item_list = None
if item_list is None:
    item_list = []

# Now item_list[0] = 'x' would still fail if list is empty,
# but item_list.append('x') would work.
item_list.append('first')
print(f"Item list: {item_list}") # Output: Item list: ['first']

Output:

Variable was None, initializing to {}.
Config data: {'user': 'admin'}
Item list: ['first']

Conclusion​

The TypeError: 'NoneType' object does not support item assignment occurs when you use square bracket assignment (variable[...] = value) on a variable that holds None. None represents the absence of a value and isn't a container like a list or dictionary.

To fix this error:

  1. Identify the source: Trace back to find why the variable is None when you expect a list or dictionary.
  2. Fix the source: Correct the logic (e.g., initialize with [] or {}, ensure functions return the correct type, don't assign the result of in-place methods like sort()).
  3. Check before assignment: If the variable can be None, use if variable is not None: before attempting assignment.
  4. Provide a default: If None, assign an appropriate empty container ([] or {}) before performing the item assignment (if variable is None: variable = {}).

Ensuring your variable holds a mutable container (list or dict) before using item assignment is the key to preventing this TypeError.

Table of Contents