Learn how to use Python dictionaries

Programming languages all include quite a lot of information buildings, every suited to particular sorts of jobs. Among the many information buildings constructed into Python, the dictionary, or Python dict, stands out. A Python dictionary is a quick, versatile approach to retailer and retrieve information by means of a reputation or perhaps a extra advanced object sort, somewhat than simply an index quantity.

Python dictionaries consists of a number of keys—an object like a string or an integer. Every secret’s related to a worth, which may be any Python object. You employ a key to acquire its associated values, and the lookup time for every key/worth pair is extremely fixed. In different languages, this sort of information construction is usually referred to as a hash map or associative array.

On this article, we’ll stroll by way of the fundamentals of Python dictionaries, together with use them, the eventualities the place they make sense, and a few frequent points and pitfalls to pay attention to.

Working with Python dictionaries

Let’s start with a easy instance of a Python dictionary:

movie_years = {
    "2001: an area odyssey": 1968,
    "Blade Runner": 1982
}

On this dictionary, the film names are the keys, and the discharge years are the values. The construction {key: worth, key: worth ... } may be repeated indefinitely.

The instance we see right here is known as a dictionary literal—a dictionary construction that’s hard-coded into this system’s supply. It is also potential to create or modify dictionaries programmatically, as you may see afterward.

Keys in dictionaries

A Python dictionary key may be practically any Python object. I say “practically” as a result of the thing in query have to be hashable, which means that it will need to have a hash worth (the output of its __hash__() technique) that doesn’t change over its lifetime, and which may be in comparison with different objects.

Any mutable Python object does not have a constant hash worth over its lifetime, and so cannot be used as a key. For example, a listing cannot be a key, as a result of parts may be added to or faraway from a listing. Likewise, a dictionary itself cannot be a key for a similar cause. However a tuple can be a key, as a result of a tuple is immutable, and so has a constant hash throughout its lifetime.

Strings, numbers (integers and floats alike), tuples, and built-in singleton objects (True, False, and None) are all frequent sorts to make use of as keys.

A given secret’s distinctive to a given dictionary. Multiples of the identical key aren’t potential. If you wish to have a key that factors to a number of values, you’d use a construction like a listing, a tuple, and even one other dictionary as the worth. (Extra about this shortly.)

Values in dictionaries

Values in dictionaries may be any Python object in any respect. Listed below are some examples of values:

example_values = {
    "integer": 32,
    "float": 5.5,
    "string": "good day world",
    "variable": some_var,
    "object": some_obj,
    "function_output": some_func(),
    "some_list": [1,2,3],
    "another_dict": {
        "Blade Runner": 1982
    }
}

Once more, to retailer a number of values in a key, merely use a container sort—a listing, dictionary, or tuple—as the worth. Within the above instance, the keys "some_list" and "another_dict" maintain lists and dictionaries, respectively. This manner, you may create nested buildings of any depth wanted.

Creating new dictionaries

You possibly can create a brand new, empty dictionary by merely declaring:

new_dict = {}

It’s also possible to use the dict() built-in to create a brand new dictionary from a sequence of pairs:

new_dict = dict(
    (
        ("integer", 32), ("float", 5.5),
    )
)

One other approach to construct a dictionary is with a dictionary comprehension, the place you specify keys and values from a sequence:

new_dict = {x:x+1 for x in vary(3)}
# {0: 1, 1: 2, 2: 3}

Getting and setting dictionary keys and values

To retrieve a price from a dictionary, you utilize Python’s indexing syntax:

example_values["integer"] # yields 32

# Get the yr Blade Runner was launched
blade_runner_year = movie_years["Blade Runner"]

You probably have a container as a price, and also you wish to retrieve a nested worth—that’s, one thing from throughout the container—you may both entry it straight with indexing (if supported), or by utilizing an interstitial project:

example_values["another_dict"]["Blade Runner"] # yields 1982
# or ...
another_dict = example_values["another_dict"]
another_dict["Blade Runner"]

# to entry a property of an object in a dictionary:
another_dict["some_obj"].property

Setting a price in a dictionary is easy sufficient:

# Set a brand new film and yr
movie_years["Blade Runner 2049"] = 2017

Utilizing .get() to soundly retrieve dictionary values

For those who attempt to retrieve a price utilizing a key that does not exist in a given dictionary, you may elevate a KeyError exception. A standard approach to deal with this kind of retrieval is to make use of a strive/besides block. A extra elegant approach to search for a key that may not be there may be the .get() technique.

The .get() technique on a dictionary makes an attempt to discover a worth related to a given key. If no such worth exists, it returns None or a default that you just specify. In some conditions you may wish to explicitly elevate an error, however a lot of the time you may simply wish to provide a sane default.

my_dict = {"a":1}

my_dict["b"] # raises a KeyError exception
my_dict.get("a") # returns 1
my_dict.get("b") # returns None
my_dict.get("b", 0) # returns 0, the equipped default

When to make use of a Python dictionary

Utilizing Python dictionaries makes essentially the most sense below the next circumstances:

• You wish to retailer objects and information utilizing names, not simply positions or index numbers. If you wish to retailer parts so as to retrieve them by their index quantity, use a listing. Notice that you just can use integers as index keys, however this is not fairly the identical as storing information in a listing construction, which is optimized for actions like including to the top of the listing. (Dictionaries, as you may see, don’t have any “finish” or “starting” aspect as such.)
• It’s essential discover information and objects rapidly by title. Dictionaries are optimized in order that lookups for keys are virtually at all times in fixed time, whatever the dictionary measurement. You will discover a component in a listing by its place in fixed time, too, however you may’t hunt for a particular aspect rapidly—it’s a must to iterate by way of a listing to discover a particular factor if you do not know its place.
• The order of parts is not as necessary as their presence. Once more, if the ordering of the weather issues greater than whether or not or not a given aspect exists within the assortment, use a listing. Additionally, as you may word beneath, whereas dictionaries do protect the order by which these parts are inserted, that is not the identical as with the ability to search() to the nth aspect rapidly.

Gotchas for values in dictionaries

There are just a few idiosyncrasies value noting about how values work in dictionaries.

First, in the event you use a variable title as a price, what’s saved below that secret’s the worth contained within the variable on the time the dictionary worth was outlined. Here is an instance:

some_var = 128
example_values = {
    "variable": some_var,
    "function_output": some_func()
}

On this case, we set some_var to the integer 128 earlier than defining the dictionary. The important thing "variable" would comprise the worth 128. But when we modified some_var after the dictionary was outlined, the contents of the "variable" key would not change. (This rule additionally applies to Python lists and different container sorts in Python.)

The same rule applies to how perform outputs work as dictionary values. For the important thing "function_output", we’ve got some_func(). This implies when the dictionary is outlined, some_func() is executed, and the returned worth is used as the worth for "function_output". However some_func() is not re-executed every time we entry the important thing "function_output". That worth will stay what it was when it was first created.

If we wish to re-run some_func() each time we entry that key, we have to take a unique strategy—one which additionally has different makes use of.

Calling perform objects in dictionaries

Operate objects may be saved in a dictionary as values. This lets us use dictionaries to execute considered one of a alternative of capabilities based mostly on some key—a typical approach to emulate the change/case performance present in different languages.

First, we retailer the perform object within the dictionary, then we retrieve and execute it:

def run_func(a1, a2):
    ...
def reset_func(a1, a2):
    ...

my_dict = {
    "run": run_func,
    "reset": reset_func
}

command = "run"
# execute run_func
my_dict[command](x, y)
# or ...
cmd = my_dict[command]
cmd(x, y)

Notice that we have to outline the capabilities first, then listing them within the dictionary.

Additionally, Python as of model 3.10 has a characteristic referred to as structural sample matching that resembles standard change/case statements. However in Python, it is meant for use for matching in opposition to buildings or combos of sorts, not simply single values. If you wish to use a price to execute an motion or simply return one other worth, use a dictionary.

Iterating by way of dictionaries

If you could iterate by way of a dictionary to examine all of its keys or values, there are just a few other ways to do it. The commonest is to make use of a for loop on the dictionary—e.g., for merchandise in the_dict. This yields up the keys within the dictionary, which might then be used to retrieve values if wanted:

movie_years = {
    "2001: an area odyssey": 1968,
    "Blade Runner": 1982
}
for film in movie_years:
    print (film)

This name would yield "2001: an area odyssey", then "Blade Runner".

If we as an alternative used the next:

for film in movie_years:
    print (movie_years[movie])

we would get 1968 and 1982. On this case, we’re utilizing the keys to acquire the values.

If we simply need the values, we are able to iterate with the .values() technique obtainable on dictionaries:

for worth in movie_years.values():

Lastly, we are able to get hold of each keys and values collectively by means of the .objects() technique:

for key, worth in movie_years.objects():

Ordering in Python dictionaries

One thing you may discover when iterating by way of dictionaries is that the keys are typically returned within the order by which they’re inserted.

This wasn’t at all times the case. Earlier than Python 3.6, objects in a dictionary would not be returned in any specific order in the event you iterated by way of them. Model 3.6 launched a brand new and extra environment friendly dictionary algorithm, which retained insertion order for keys as a handy facet impact.

Beforehand, Python supplied the sort collections.OrderedDict as a approach to assemble dictionaries that preserved insertion order. collections.OrderedDict remains to be obtainable in the usual library, primarily as a result of a whole lot of current software program makes use of it, and likewise as a result of it helps strategies which might be nonetheless not obtainable with common dicts. For example, it presents reversed() to return dictionary keys in reverse order of insertion, which common dictionaries do not do.

Eradicating objects from dictionaries

Generally you could take away a key/worth pair fully from a dictionary. For this, use the del built-in:

del movie_titles["Blade Runner"]

This removes the important thing/worth pair {"Blade Runner": 1982} from our instance firstly of the article.

Notice that setting a key or a price to None shouldn’t be the identical as eradicating these parts from the dictionary. For example, the command movie_titles["Blade Runner"] = None would simply set the worth of that key to None; it would not take away the important thing altogether.

Discovering keys by means of values

A standard query with dictionaries is whether or not it is potential to discover a key by trying up a price. The brief reply isn’t any—at the least, not with out iterating by way of the important thing/worth pairs to seek out the fitting worth (and thus the fitting key to go along with it).

If you end up in a scenario the place you could discover keys by means of their values, in addition to values by means of their keys, contemplate conserving two dictionaries, the place considered one of them has the keys and values inverted. Nonetheless, you may’t do that if the values you are storing aren’t hashable. In a case like that, you may should resort to iterating by way of the dictionary—or, higher but, discovering a extra sleek resolution to the issue you are really attempting to resolve.

Dictionaries vs. units

Lastly, Python has one other information construction, the set, which superficially resembles a dictionary. Consider it as a dictionary with solely keys, however no values. Its syntax can be much like a dictionary:

movie_titles = {
    "2001: an area odyssey",
    "Blade Runner",
    "Blade Runner 2049"
}

Nonetheless, units should not for storing data related to a given key. They’re used primarily for storing hashable values in a method that may be rapidly examined for his or her presence or absence. Additionally, units do not protect insertion order, because the code they use is not the identical because the code used to create dictionaries.