As you continue on your journey of
learning Python, you’ll
start working with
larger data sets. As you do so, you should become acquainted with
Python dictionaries. A Python dictionary is a composite data type that is similar to a list but varies in one key respect: access.
While a
Python list is accessed by its position, a dictionary is accessed via a key. Dictionaries are structured in key-value pairs. The key is a unique identifier for a particular piece of data:
Key1: Value1
Key2: Value2
Key3: Value3
Dictionaries are mutable, so they can be changed once created. They are unordered, which means that the items within them are not stored in any certain order. These two features make dictionaries a fast and versatile method of
storing and retrieving data in Python.
You can create a simple dictionary like this:
album = {
"title": "Signals",
"band": "Rush",
"release date": "September 9, 1982"
}
We can access this dictionary by key:
The output of that print statement would be:
Rush
Or, we could print the output in a different order from how the data is listed in the dictionary, like so:
print(album["band"],album["title"])
The output of the above print statement would be:
Rush Signals
Another handy feature of dictionaries is that they can be merged. You can take two dictionaries and merge them into a single one. For example, you might have two dictionaries like these:
a1 = {
"title": "Signals",
"band": "Rush",
"release date": "September 9, 1982"
}
a2 = {
"label":"Anthem",
"number of songs": "8",
"highest rank": "1"
}
These dictionaries, a1 and a2, can be merged into a single dictionary that contains all of the information in each. Of course, you can merge more than two dictionaries in Python — in fact, you can merge as many as you need.
Many techniques can be utilized to merge dictionaries in Python, such as the update() method, the double asterisk operator (**), the chain() method, the ChainMap() function, the merge operator (|) and the update operator (|=). Let’s consider how these techniques can be used to merge data.
The update() Method
The
update() method is very handy. One of its most common uses is to update a dictionary. Say, for example, you have the previous dictionaries, a1 and a2, and you want to add a released single and the total running time of the album. That can be accomplished as follows:
a1.update({"single": "New World Man"})
a2.update({"length": "43:12"})
You can use update() to merge dictionaries with a line of code like this:
The above line of code would combine both dictionaries into one. If you then used a print() statement on the resultant dictionary, the output would be:
{'title': 'Signals', 'band': 'Rush', 'release date': 'September 9, 1982', 'single': 'New World Man', 'label': 'Anthem', 'number of songs': '8', 'highest rank': '1', 'length': '43:12'}
The Double Asterisk Operator (**)
Our next method is the
** operator, which can unpack and merge our key-value pairs into a single variable. We’ll stick with our example above. So we have:
a1 = {
"title": "Signals",
"band": "Rush",
"release date": "September 9, 1982"
}
a2 = {
"label":"Anthem",
"number of songs": "8",
"highest rank": "1"
}
Using a single line of code, let’s define a variable called signals and then merge both the a1 and a2 dictionaries into that variable:
We can then print the signals variable:
The output will be the same as it was when using the update() method above:
{'title': 'Signals', 'band': 'Rush', 'release date': 'September 9, 1982', 'single': 'New World Man', 'label': 'Anthem', 'number of songs': '8', 'highest rank': '1', 'length': '43:12'}
The chain() Method
The previous methods are included with the standard Python libraries. For chain(), we must first import chain with the
itertools library, which is declared like so:
from itertools import chain
Using the same dictionaries, we can define our signals variable using the chain() method:
signals = dict(chain(a1.items(), a2.items()))
This chains together all items from a1 with the items from a2. You can then print the result:
The output will be the same as it was after our previous merges.
The ChainMap() Function
You can simplify the chain() method by using the
ChainMap() function, which doesn’t require the use of the items() function. To use ChainMap(), you must first import it from the collections library:
from collections import ChainMap
So, instead of this:
signals = dict(chain(a1.items(), a2.items()))
The line of code would be written like this:
signals = dict(ChainMap(a1, a2))
The output will be the same.
The Merge Operator (|)
The merge operator is one of the simplest methods of merging dictionaries. Using the previous example dictionaries, this operator can be utilized as follows:
As you probably expected, the output will be the same as in the previous examples.
We can make that code even simpler using the update operator (|=), which functions a lot like the update() method. With this operator, we can merge a1 with a2 like so:
The above would produce the same output as in our previous examples.
And there you have it — numerous ways to merge Python dictionaries. This data type will come in handy in many ways. You’ll be glad to have a number of approaches to use when working with dictionary data.
