How to Fix TypeError NoneType Object Is Not Subscriptable in Python

The error TypeError: ‘NoneType’ object is not subscriptable in Python means you tried to index or slice something that is None — like result[0] when result is None. It’s one of the most common Python errors. Here’s every cause and fix.

What “Subscriptable” Means

Subscripting is accessing an element with square brackets: x[0], x['key'], x[1:3]. Lists, dicts, strings, and tuples are subscriptable. None is not — so None[0] raises this error. The real question is always: why is your variable None?

Cause 1: Function Returns None Implicitly

# 🐛 Function has no return statement (or a path that doesn't return)
def find_user(users, name):
    for user in users:
        if user['name'] == name:
            return user
    # No return when not found → returns None implicitly

result = find_user(users, "Alice")
print(result['email'])   # ❌ TypeError if Alice not found (result is None)

# ✅ Check for None before subscripting
result = find_user(users, "Alice")
if result is not None:
    print(result['email'])
else:
    print("User not found")

Cause 2: Method That Modifies In-Place Returns None

# 🐛 list.sort() sorts in place and returns None
numbers = [3, 1, 2]
sorted_nums = numbers.sort()   # ❌ sort() returns None
print(sorted_nums[0])          # TypeError — sorted_nums is None

# ✅ Use sorted() which returns a new list
sorted_nums = sorted(numbers)  # returns a new sorted list
print(sorted_nums[0])          # works

# Same trap with: list.append(), list.reverse(), dict.update()
# These modify in place and return None

Cause 3: dict.get() Returning None

# 🐛 .get() returns None for missing keys
config = {"host": "localhost"}
port = config.get("port")   # None — 'port' not in dict
print(port[0])              # ❌ TypeError

# ✅ Provide a default with .get()
port = config.get("port", 8080)   # default if missing

# ✅ Or check before use
port = config.get("port")
if port is not None:
    use(port)

Cause 4: Regex Match Returning None

import re

# 🐛 re.match/search return None when no match
match = re.search(r'\d+', "no numbers here")
number = match.group()   # ❌ TypeError — match is None

# ✅ Check the match first
match = re.search(r'\d+', text)
if match:
    number = match.group()
else:
    number = None

Cause 5: API/Database Query Returning None

# 🐛 Database query returns None when no row found
user = db.query("SELECT * FROM users WHERE id = ?", user_id)
name = user['name']   # ❌ TypeError if no user found

# ✅ Always handle the "not found" case
user = db.query("SELECT * FROM users WHERE id = ?", user_id)
if user is None:
    raise NotFoundError(f"User {user_id} not found")
name = user['name']   # safe now

Debugging: Find Why It’s None

# Add a check to see exactly what's None and where
result = some_function()
print(f"DEBUG: result = {result!r}, type = {type(result)}")
# If it prints "result = None", trace back to some_function()
# to find the code path that returns None

# Use a debugger to inspect
import pdb; pdb.set_trace()   # step through and check the value

Safe Patterns to Prevent This

# Pattern 1: Walrus operator for check-and-use (Python 3.8+)
if (user := find_user(users, name)) is not None:
    print(user['email'])

# Pattern 2: Provide defaults
data = fetch_data() or {}   # empty dict if fetch returns None
value = data.get('key', 'default')

# Pattern 3: Optional chaining alternative (Python has no ?. operator)
name = user['name'] if user else None

# Pattern 4: Return consistent types from functions
def find_user(users, name):
    for user in users:
        if user['name'] == name:
            return user
    return {}   # return empty dict instead of None (if that makes sense)

Frequently Asked Questions

Q: Why is my function returning None when I didn’t write “return None”?
A: Python functions return None implicitly if they reach the end without a return statement, or hit a code path that doesn’t return. A common cause: a return inside a loop/if that isn’t reached for all inputs.

Q: Why does sorted_list = my_list.sort() give None?
A: .sort() sorts the list in place and returns None. Use sorted(my_list) which returns a new sorted list. This trap applies to many in-place methods (append, reverse, update).

Q: How do I safely access nested dict keys that might be missing?
A: Chain .get() with defaults: data.get('user', {}).get('name', 'unknown'). Each .get() returns an empty dict if missing, so the chain doesn’t hit None.

Q: What’s the difference between this and ‘NoneType has no attribute’?
A: “Not subscriptable” is from None[x] (square brackets). “Has no attribute” is from None.attr (dot access). Both mean you have a None where you expected a real object — the fix (check for None) is the same.

Q: Should I use try/except or if-checks?
A: Prefer explicit if x is not None checks for clarity when None is an expected possibility. Use try/except for truly exceptional cases. Checking is clearer and faster for the common “might be None” scenario.

Conclusion

“‘NoneType’ object is not subscriptable” means you’re indexing something that’s None. The real fix isn’t the subscript — it’s understanding why your variable is None: a function returning None implicitly, an in-place method like .sort() that returns None, a missing dict key, a failed regex match, or an empty query result. Add a print(f"{result!r}") to confirm what’s None, trace back to its source, and guard with if x is not None before subscripting. Returning consistent types from your functions prevents most of these errors entirely.