Why does `dict.get()` return `None` when a key is missing?

get() looks up a key, but it also gives you a way to handle a key that is not in the dictionary. If the key is absent and you call settings.get("theme") with no second argument, the result is None. That is the default behavior, not evidence that Python found a theme value.

Direct indexing works differently for a missing key: settings["theme"] raises KeyError. Use it when the key is required and you want a missing key to be an error. Use get() when the key may be absent and you want to choose what happens instead. [S1]

For example, if settings is {}:

settings["theme"]          # raises KeyError
settings.get("theme")     # returns None
settings.get("theme", "light")  # returns "light"

The second argument is the value returned when the key is absent. Choose a default that makes sense for what your code will do next.

Pass a default when you have a meaningful fallback and want the lookup itself to supply it. For a display label, you might use:

label = profile.get("display_name", "Guest")
print(label)

If profile has no "display_name" key, label becomes "Guest". If the key exists, get() returns its stored value instead. [S1]

A default is not a repair for every unexpected value. For instance, if your program requires a name and silently substituting "Guest" would hide a problem, direct indexing—or an explicit check followed by a clear error—may fit better. Decide what a missing key should mean in this particular part of the program before choosing a fallback.

You cannot tell from that result alone. Both an absent key looked up without a default and a present key whose value is None can produce the same result. When the distinction matters, test whether the key is in the dictionary:

profile = {"display_name": None}

if "display_name" in profile:
    print("The key exists; its value is", profile["display_name"])
else:
    print("The key is missing")

Here, membership says the key exists even though its stored value is None. By contrast, if profile were {}, the else branch would run. The documentation recommends membership testing for this distinction. [S1]

This is useful when None has its own meaning in your program—for example, when it differs from a field that was never provided. If you do not need to distinguish those cases, a suitable get() default may be simpler.

Use the pattern that matches what absence means to your code:

# Required key: let an absent key raise KeyError.
name = profile["display_name"]

# Optional key with a fallback for absence.
name = profile.get("display_name", "Guest")

# Need to distinguish absent from present-with-None.
if "display_name" in profile:
    name = profile["display_name"]
else:
    name = "Guest"

For a worked example, suppose profile is {"display_name": None}. Direct indexing returns the stored None; get("display_name", "Guest") also returns the stored None, because the key is present. The membership branch confirms the key exists. If the dictionary is {}, indexing raises KeyError, get("display_name", "Guest") returns "Guest", and membership reports that the key is absent. [S1]

Reusable decision: require the value → index directly; allow absence with one fallback → call get(key, fallback); treat absence differently from stored None → test key in dictionary. The documentation establishes these lookup behaviors; it does not determine which default or error handling is right for your application. Choose that based on your program’s needs.