TypeError: NoneType Is Not Subscriptable or Iterable

The rule is absolute and easy to enforce. Never assign the result of a mutating call. Put scores.sort() on its own line and keep using scores, or reach for sorted() when you need a new list. If you spot = ...sort() or = ...append( in review, flag it every time — no exceptions, because the crash it produces always lands far from the line that caused it.

scores = [3, 1, 2]
result = scores.sort()
print(result)
print(scores)
names = ["b", "a"]
print(sorted(names))
print(names)
items = []
print(items.append("x"))
print(items)

None Slipped In as an Argument: Defaults, Chains, and Guard Clauses

None rarely starts at the crash site — it arrives as luggage. A lookup misses, a config key is absent, an API returns an empty body, and some intermediate layer passes that None along instead of dealing with it. Each frame assumes the frame above validated, so the value drifts deeper until an operation finally demands something real. By then the traceback's bottom frame is innocent code doing exactly what it should.

The fix is positional: validate where data crosses a boundary, not where it explodes. A function receiving prices should decide immediately what None means there. If prices are required, raise a loud ValueError naming the parameter — fail fast, fail attributably. If absence is legitimate, substitute a deliberate default like an empty list or a fallback config dict, and document that choice in the signature. What you must never do is accept None silently and hand it to the next layer down.

Defaults deserve the same scrutiny. prices or [] is convenient but treats 0 and "" as missing too, which surprises callers passing legitimate falsy values. Prefer the explicit if prices is None branch so your intent survives the next reader. The discipline compounds: when every function guards its own door, None can never travel more than one frame, and tracebacks start pointing at causes instead of victims.

def total(prices):
    if prices is None:
        raise ValueError("prices must be a list, got None")
    return sum(prices)

print(total([10, 20, 30]))


def load_config(raw):
    if raw is None:
        return {"retries": 3}
    return raw

print(load_config(None))
print(load_config({"retries": 5}))

Traceback Reading: Name the Operation That Touched None

The traceback's final line is a label, not a riddle. Python tells you the exact operation that met None: 'not subscriptable' means brackets were applied to None, 'not iterable' means a loop, comprehension, or unpacking met None, and 'not callable' means None was invoked like a function. Each message names a different producer to hunt, so reading that one word before touching code saves entire debugging sessions.

Work the traceback backwards from there. The bottom frame shows the failed operation and the file and line where it happened. The frame above shows the call that delivered the value. Your job is to walk up until you find the frame where a real object should have been built — the search that missed, the mutator that was assigned back, the argument that arrived empty. Drop print(repr(variable)) at each step; repr() separates None from "None", [], and 0, which all look alike in ordinary prints but crash in entirely different ways.

Beginners often patch the bottom frame — wrapping the crash line in try/except or sprinkling a guard where the symptom appeared. That hides the wound without treating it. The professional habit is the opposite: the crash line is evidence, and the fix belongs wherever None was born. Read the last line, walk one frame up, confirm with repr(), and repair the producer.

cases = {
    "subscript": lambda: None["key"],
    "iterate": lambda: [x for x in None],
    "call": lambda: None(),
}
for name, fn in cases.items():
    try:
        fn()
    except TypeError as exc:
        print(name, "->", type(exc).__name__ + ":", exc)

Optional Hints and Strict mypy: Catch None Before It Ships

Type hints turn this runtime surprise into a build-time refusal. Marking a value Optional[str] declares that None is a legal resident, not an intruder — and under strict mypy, every unguarded use of that value becomes a static error. Subscripting, iterating, or calling an Optional without narrowing it first fails CI with Item "None" has no attribute, pointing at the exact line long before production data arrives.

The mechanism is narrowing. After if name is None: return ..., the checker knows the surviving path holds a real str and permits .strip() and .lower(). Without that guard, the same calls are rejected. This is the machine enforcing the discipline the article preaches: check before you touch. Bare annotations like -> dict make the opposite promise — 'this never returns None' — so a function that can fall off the end violates its own contract, and strict mode flags the lie.

Adoption is incremental, which is why teams actually stick with it. Annotate the money paths and the shared helpers first, run mypy --strict on those modules in CI, and widen the net over time. You don't need a fully typed codebase to kill this error class — you need strict checking on the functions whose results get subscripted, looped over, or called.

from typing import Optional


def greet(name: Optional[str]) -> str:
    if name is None:
        return "hello, guest"
    return "hello, " + name.strip().lower()

print(greet("  ADA "))
print(greet(None))


def first(items: list[str]) -> Optional[str]:
    if not items:
        return None
    return items[0]

print(first([]))
print(first(["x", "y"]))

Boundary Guards That Scale: Raise Early, Default Deliberately

Guards scale when they live at boundaries and speak plainly. The entry to a service, the top of a request handler, the start of a batch job — these are the checkpoints where external or optional data becomes internal fact. A guard there converts every downstream assumption into something verified: after if customer is None: raise ValueError("customer is required"), the rest of the function can use customer["id"] with total confidence, and every reader sees the contract up front.

Choose the guard's voice deliberately. Raise for required inputs, because a missing customer is a caller bug that must be loud and attributable. Substitute defaults for optional inputs, because a missing amount is a business decision (amount = 0) that should be visible, not hidden inside an or that also swallows zeroes. The two shapes look similar but communicate opposite things, and mixing them up — defaulting a required value, raising on an optional one — creates bugs subtler than the crash you started with.

Resist scattering is None checks at every use site. A function body littered with guards is a sign the boundary was left open; push the check outward until each function can trust its own parameters. One guard at the door beats ten guards in the hallway, and the traceback — should one ever fire again — will point at the caller that broke the contract.

def charge(customer, amount):
    if customer is None:
        raise ValueError("customer is required")
    if amount is None:
        amount = 0
    return {"customer": customer["id"], "charged": amount}

print(charge({"id": "c_1"}, 50))
print(charge({"id": "c_2"}, None))
try:
    charge(None, 50)
except ValueError as exc:
    print("guard fired:", exc)