Dictionaries and default values

Efficiently handling missing keys

You might want non-destructive keys —you won't touch the absence, you'll just return something instead. dict.get(key, default) is small, yet packed with goodness for these situations.

my_dict = {'apple': 3, 'banana': 2}

# Cherry check! If it's there, great! If not, we've got 0 problems🍒
count = my_dict.get('cherry', 0)
print(count)  # Outputs: 0


Wait, but what if you might have multiple missing keys? Call dict.setdefault(key, default) to rescue. It not only fetches the value without a hiccup but also initializes the key if it's nowhere to be found:

my_dict.setdefault('cherry', 0)
print(my_dict['cherry'])  # 0, 'cherry' joins the fruit family 🍒


Need default values for a set of keys? dict.update() merges another dictionary with defaults, while existing keys get to chill:

defaults = {'cherry': 0, 'berry': 0}
my_dict.update({k: defaults[k] for k in defaults if k not in my_dict})


If performance is your concert, and missing keys are like your fans, you might want try/except to handle the exceptions. It's faster than get() because you know... exceptions are rare guests.

try:
    value = my_dict['pear']
except KeyError:
    value = 0  # Planning for a pear-fect fall 🛡️


Deep diving into defaults

defaultdict with functions

defaultdict can summon a function for providing complex defaults, making it incredibly versatile:

from collections import defaultdict

def default_factory():
    return 'default value'

smart_dict = defaultdict(default_factory)
print(smart_dict['nonexistent'])  # 'default value', even this doesn't exist! 


With this, you can construct various default types and function returns as and when required.

The setdefault secret

setdefault might look humble, but it returns the value. Code efficiency enters the chat:

count = my_dict.setdefault('apple', 0)  # Read
my_dict['apple'] = count + 1            # Update. One-stop apple shop! 🍏


get vs __getitem__

dict.get() and dict[key] might look like friendly neighbors, but they sure have their differences. get() is like a polite gentleman—never raises an error and always ready for a custom default. But __getitem__ (aka dict[key]) can be grumpy, throwing KeyError if the key steps on its lawn.

Mastering dictionary defaults

Customizing with __missing__

A dict subclass can override __missing__ to define its behavior for missing keys:

class SpecialDict(dict):
    def __missing__(self, key):
        return 'special default'

my_special_dict = SpecialDict()
print(my_special_dict['ghost'])  # Gives: 'special default', no boo-boos here!


Now, you're wielding the power of custom logic without cluttering the global namespace with defaults.

Performance considerations

• get() or try/except? If you know most keys exist, the latter is faster since exceptions are rare.
• With several keys being party-poopers, get() reigns supreme, smartly avoiding exception handling overhead.

Beware!

• Over use of setdefault might lead to unnecessary dictionary updates. It's not always the hero you need.
• Merging dictionaries with update() might overwrite existing keys like an excited puppy. Handle it with care.