How to check if a key exists in a dictionary in Python

1The in operatorRecommended

key in d is a single hash lookup — O(1), regardless of how big the dict is — and it's the clearest way to say what you mean. Use not in for the inverse.

config = {"host": "localhost", "port": 8080, "debug": False}

print("host" in config)
print("timeout" in config)
print("timeout" not in config)

# `in` looks at KEYS only — "localhost" is a value, not a key
print("localhost" in config)
print("localhost" in config.values())

Two things to internalise. First, in checks keys — the fourth line prints False even though "localhost" is right there as a value. To search values you need value in d.values(), which is a linear O(n) scan. Second, key in d.keys() is not wrong, just redundant: it builds a view object and then does the same lookup. Python 2's d.has_key() was removed in Python 3 — in replaced it.

2dict.get() with a default

When you don't care whether the key is there, only what value to use, skip the check and call get(). With one argument it returns None for a missing key; with two it returns your fallback.

config = {"host": "localhost", "port": 8080}

print(config.get("host"))
print(config.get("timeout"))
print(config.get("timeout", 30))

# .get() never inserts — the dict is unchanged
print(config)

The last line prints {'host': 'localhost', 'port': 8080}: reading a missing key with get() does not add it. That's the difference between get() and setdefault() in section 6. The default argument is evaluated eagerly, so avoid d.get(k, expensive()) — call it only in the miss branch instead.

3The gotcha: keys with falsy values

This is the bug that actually bites people: if d.get(key): is not the same test as if key in d:. get() hands back the value, and 0, "", None, [] and False are all falsy — so a key that exists gets treated as missing.

settings = {"retries": 0, "name": "", "proxy": None}

for key in ("retries", "name", "proxy", "missing"):
    exists = key in settings
    truthy = bool(settings.get(key))
    print(f"{key:<8} exists: {str(exists):<5} truthy: {truthy}")

Three keys exist and every one of them is falsy — the truthy column is False for all four rows, so a truthiness test can't tell "retries": 0 apart from a key that was never set. If you need existence, use in. If you need "present and not None", be explicit: d.get(key) is not None.

4try/except KeyError (EAFP)

Python leans EAFP — easier to ask forgiveness than permission. Index the dict and catch KeyError. The exception object carries the offending key, which makes for good error messages.

config = {"host": "localhost", "port": 8080}

try:
    print(config["port"])
except KeyError as exc:
    print("missing key:", exc)

try:
    print(config["timeout"])
except KeyError as exc:
    print("missing key:", exc)

Note the quotes in missing key: 'timeout' — KeyError reprs the key, so a string key shows up quoted. Reach for this when the key is almost always present (one lookup on the happy path instead of the two an in check plus an index costs) or when a miss is a genuine error you want to log or re-raise. For a plain fallback value, get() is shorter and clearer.

5Which should you use?

6Common variation: check and insert

When a miss should create the entry, setdefault() collapses the check and the write into one call: it returns the existing value if the key is there, otherwise inserts your default and returns that. For the grouping pattern, collections.defaultdict is the same idea with the default baked in.

from collections import defaultdict

config = {"host": "localhost"}

# already there → returns the existing value, changes nothing
print(config.setdefault("host", "0.0.0.0"))
# missing → inserts the default and returns it
print(config.setdefault("port", 8080))
print(config)

groups = defaultdict(list)
for name, lang in [("app.py", "python"), ("main.go", "go"), ("util.py", "python")]:
    groups[lang].append(name)
print(dict(groups))

The catch with defaultdict is that reading a missing key creates it, so d[k] can never tell you a key is absent — use k in d on a defaultdict, which does not insert. Dicts preserve insertion order in Python 3.7+, so the grouped output comes out python first, exactly in the order the keys were first seen.