get() vs Direct Key Access in Dictionaries

Square brackets raise a KeyError when the key is missing. get returns a fallback instead, and never raises.

data = {"name": "Ada"}

print(data["name"])          # Ada
print(data.get("name"))      # Ada - same result when the key exists

print(data.get("age"))       # None - the default is None
print(data.get("age", 0))    # 0 - your own default

try:
    print(data["age"])
except KeyError as err:
    print("KeyError:", err)

The only difference between the two forms is what happens when the key is absent. When the key exists they behave identically, which is why the choice only matters on the failure path.

There is a second, less obvious difference: what happens when the stored value is itself None. If a key exists but its value is None, then data.get("key") returns None and data["key"] also returns None — but the first cannot tell you whether the key is missing, while the second raises only if it truly is missing. If you need to distinguish missing from None, use the membership test: if "key" in data.

Choosing between them is really about what a missing key means. If a missing key indicates broken data — a configuration value that must be present, a required field in a payload — let the KeyError happen. The exception names the missing key and fails fast, which is exactly what you want in a request handler or a data pipeline.

If a missing key is a normal possibility, use get. That covers optional settings, a search that may find nothing, and any lookup where a default is meaningful. And when the default is a real value rather than None, pass it explicitly so the intent is visible at the call site.

Use get when the absence of a key is an expected, normal outcome — an optional configuration value, a lookup in a cache that may have missed, a field in a document that may not be there. Use direct access when a missing key means the data is wrong, because the KeyError is a clearer failure than silently substituting a default and letting the problem surface three layers away.

The difference between the two is a design decision about error handling, not a performance one. The dict lookup itself is the same speed either way. get exists so you can express the expected-missing case without a try block, and the direct form exists so the unexpected-missing case is loud.

setdefault is the third option and it behaves differently from both. get never modifies the dictionary. setdefault does: if the key is missing, it inserts the default and returns it. That makes it useful for building a dictionary incrementally, and dangerous for anything else — because a plain read like config.setdefault("timeout", 30) has the side effect of adding a key, and doing that inside a loop over the config's keys can change the dictionary while you iterate it.

There is a fourth option worth naming for the case where you want the default to be computed: the walrus operator in an if statement, or simply an explicit membership test. The pattern if key not in data: data[key] = default is the clearest way to say what you mean, even though it costs an extra lookup.

For an interview, the summary is that get reads, setdefault reads and may write, and direct access reads loudly. Choose based on whether the missing key is data corruption or a normal branch.