Check if a given key already exists in a dictionary

From "Is it there?" to "Here it is!"

Though in operator is often the quickest way to validate a key's presence, the landscape is wider. Depending on context, there are other methods better suited to tackling specific situations.

Get: Value retrieval without tears

Imagine you are a miner. Fancy mining gold from a coal mine? That's what get() allows you to do. It can unshroud the value hiding behind a key or show you a kind default face in case the key goes AWOL:

# 'default_value': a stuffed teddy bear won in the face of ’no gold ’scare.
value = my_dict.get('key', 'default_value')


This wards off the nightmare of KeyError that could haunt when my_dict['key'] is invoked directly.

setdefault: Making a home for newcomers

When you need to ensure a key's existence and offer it a cozy initial setting, call setdefault():

# 'new_value': Ah, that new car smell... or maybe that's just the dictionary pages.
my_dict.setdefault('key', []).append('new_value')


Unlike uninvited guests, setdefault() won’t overwrite the value if the key is already home.

defaultdict: Serving counters with a default scoop

Situation: You are vending ice cream. Any new customer (key), you want to hand a default scoop (value). collections.defaultdict: your savior. int is your favorite vanilla flavor. Situation handled.

from collections import defaultdict
counters = defaultdict(int)
# '+=': turns out they are a fan of vanilla!
counters['key'] += 1


Keys are your dictionary tour guides, dict.keys() are just, uh, well… keys

When dealing with membership tests, dict.keys() can seem appealing. It’s a trap. It’s inefficient and unnecessary. Welcome to Python; we like it simple and fast:

# Sorry to say, but this ain't it chief:
if 'key' in my_dict.keys(): 
    print("Exists")

# This, however, is where the party is at:
if 'key' in my_dict: 
    print("Exists")


In Python, if 'key' in my_dict: is snappier and cleaner. Credit: hash lookup. MIA: list search.

One-liner for key existence check

Hey, Pythonistas love compact code and style, right? Then, behold, conditional output in one line:

# drumrolls...
print("Found") if 'key' in my_dict else print("Not Found")


Voila, a fine Pythonic way to state whether a key is sulking in the shadows or sitting boldly like a king.

Disaster management

As a Python developer, being savvy with key existence checks is brilliant. But how about the ability to avert blunders?

A pointless search can be a wild goose chase

Often, a key check is just the prelude to the real drama: value access. So, cut the preamble:

# Windy roads ain't our thing:
if 'key' in my_dict:
    value = my_dict['key']
# Straight and narrow, that's our game:
value = my_dict.get('key', 'default_value')


Voila! No more minced words.

Immutable keys are the dictionary's best friends

Immutable like a superhero's allegiance, so should the dictionary keys be. Lists, dictionaries, they falter (mutable). Trust integers, strings, or tuples as dictionary keys, because they stay true.

The bigger they are, the harder they check

Working with massive datasets? A key exists check might be a performance bottleneck. in, our beloved superhero is optimized; still, size matters, as does the data structure.

Applications dusted with reality

A theoretical tutorial can sometimes give an abstract impression. How about some practical contexts to bring home the bacon?

Database query caching

Let’s talk caching database queries, a scene worthy of any developers’ life:

query_cache = {}
query = "SELECT * FROM users WHERE id = 1"
# Cache or crash? We choose the former:
if query not in query_cache:
    result = perform_database_magic(query)  # We prefer magic over queries!
    query_cache[query] = result
else:
    result = query_cache[query]


A cache check preceding the query can spare several precious milliseconds!

Feature toggles in configurations

See configuration settings, and dictionaries are like long-lost siblings. Feature flags are those annoying childhood memories that won't let you forget they are related:

feature_config = {'dark_mode': True, 'beta_features': False}
# Let there be darkness, or maybe not!
if feature_config.get('dark_mode'):
    enable_night_vision()  # I hope you are not afraid of the dark!


Ah, the ability to flip feature states, sweet bliss!