When we work with dictionaries that contains lists, we need to make sure that the list exists before we can add items. Or when we use a dictionary for counters, we must make sure that we have a value before we can increment it. While this can be done by hand, there is a much more elegant way in Python.
This post is part of my journey to learn Python. You find the code for this post in my PythonFriday repository on GitHub.
The manual way
We cannot append a value to a non-existent list. Therefore, we must check if the key exists in a dictionary and only append if that is the case. If there is not yet an entry for that key, we need to create a new list with our value:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
def append(dic, key, value): if key in dic: dic[key].append(value) else: dic[key] = [value] d = {} append(d, "a", 1) append(d, "a", 2) append(d, "b", 1) print(d) # {'a': [1, 2], 'b': [1]} d["a"] # [1, 2] |
Defaultdict with lists
The defaultdict creates us an empty list for every key that we add to our dictionary. We can directly append without the need to check if the key exists or manually create that list:
|
1 2 3 4 5 6 7 8 9 10 |
from collections import defaultdict d = defaultdict(list) d["a"].append(3) d["a"].append(4) d["b"].append(5) print(d) # defaultdict(<class 'list'>, {'a': [3, 4], 'b': [5]}) d["a"] # [3, 4] |
We can work with the defaultdict as we do with a regular dictionary for everything else than adding new keys.
Defaultdict with numbers
We can also create a defaultdict with integers, which gives us a 0 as the default value for every newly added key:
|
1 2 3 4 5 6 7 8 |
from collections import defaultdict counters = defaultdict(int) counters["entry"] += 1 counters["entry"] += 1 counters["exit"] += 1 print(counters) # defaultdict(<class 'int'>, {'entry': 2, 'exit': 1}) |
This is much simpler than the regular way with creating a method to make sure there is a value before we increment it:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
def increment(dic, key, value): if key in dic: dic[key] += value else: dic[key] = value counters = {} increment(counters, "entry", 1) increment(counters, "entry", 1) increment(counters, "exit", 1) print(counters) # {'entry': 2, 'exit': 1} |
Next
Using a defaultdict instead of a regular dictionary allows us to directly work with new keys without first making sure that the dictionary contains a (default) value. It saves us a little bit of code, but even that small function could contain bugs that slow us down. Therefore, try defaultdict if you need to work with default values in dictionaries.
Next week we explore a way that can speed-up our applications by caching function calls.