Python Language Dictionary

Internal

• Python Language

Overview

A dictionary is a mutable collection of key-value pairs. The pairs can be accessed and modified. Each key is unique within the key set, and can be an instance of any immutable type: boolean, integer, float, tuple, string, etc. In other programming languages, the same data structure is referred to as "associative array" or "hash tables" or "hash maps".

Key Discussion

The keys 1 and True are equivalent. Why?

Create a Dictionary

A new dictionary instance is declared using the {...} syntax. The curly braces are placed around comma-separated key: value pairs. The dictionary can be empty

d = {}

or it can be populated with values:

d = {'a': 'b', 1: 2}

It is good form to insert a space after :. A comma is tolerated after the last pair.

Converting Other Data Structures to a Dictionary

Any two-value sequences can be converted into a dictionary using the dict() function.

Examples:

# list of lists
l = [['a', 'b'], ['c', 'd'], ['e', 'f']]
d = dict(l) # will create {'a': 'b', 'c': 'd', 'e': 'f'}

# list of tuples
l = [('a', 'b'), ('c', 'd'), ('e', 'f')]
d = dict(l) # will create {'a': 'b', 'c': 'd', 'e': 'f'}

# tuple of two-item lists
l = (['a', 'b'], ['c', 'd'], ['e', 'f'])
d = dict(l) # will create {'a': 'b', 'c': 'd', 'e': 'f'}

# list of two-character strings
l = ['ab', 'cd', 'ef']
d = dict(l) # will create {'a': 'b', 'c': 'd', 'e': 'f'}

# tuple of two-character strings
l = ('ab', 'cd', 'ef')
d = dict(l) # will create {'a': 'b', 'c': 'd', 'e': 'f'}

Access a Dictionary

Access Individual Elements

Individual dictionary elements can be accessed with the [] syntax or with the get() function.

Access with [] Syntax

The [] syntax can only be used with keys that exist in the dictionary:

d = {'a': 'b'}
print(d['a'])

An attempt to access an inexistent key will throw a KeyError exception. To avoid the exception, use get() instead, or test the existence of the key first.

get() Function

The get() will return the associated value, or None if the key does not exist.

d = {'a': 'b'}
print(d.get('a')) # will display 'a'
print(d.get('no-such-key')) # will display None

The get() function allows for a second argument which will be returned instead of None in case the key does not exist:

d = {}
print(d.get('no-such-key', 'alternative')) # will display "alternative"

Test the Existence of a Key

The existence of the key can be tested with in:

if 'some-key' in d:
  print("key exists")

get() can also be used:

if d.get('some-key') is not None:
  print("key exists")

Get All Keys

d = {'a': 'b', 'c': 'd'}
print(d.keys())

In Python 3, the keys() will return a dict_keys(), which is an iterable view of keys. This is useful with large dictionaries because the runtime does not use the time and the memory to create and store a list that might not be used. In case you need a list, use list() to wrap the result of keys().

list(d.keys())

Get All Values

d = {'a': 'b', 'c': 'd'}
print(d.values())

In Python 3, the values() will return a dict_values(), which is an iterable view of values. This is useful with large dictionaries because the runtime does not use the time and the memory to create and store a list that might not be used. In case you need a list, use list() to wrap the result of values().

list(d.values())

Get All Key-Value Pairs

d = {'a': 'b', 'c': 'd'}
print(d.items())

In Python 3, the items() will return a dict_items(), which is an iterable view of items. This is useful with large dictionaries because the runtime does not use the time and the memory to create and store a list that might not be used. In case you need a list, use list() to wrap the result of items().

list(d.items())

Modify a Dictionary

Modify Individual Elements

Modification with [] Syntax

Individual elements can be modified with the [] syntax. If the key does not exist, the key-value pair will be added to the dictionary. If the key exists, the associated value will be updated:

d = {}
d['a'] = 'b'
print(d['a']) # will display "a"
d['a'] = 'c'
print(d['a']) # will display "c"

Delete Individual Element

d = {'a': 'b', 'c': 'd'}
del d['a']
print(d) # will display {'c': 'd'}

Note that if the key being deleted does not exist, the [] syntax will throw an KeyError exception.

Delete All Items

Use the clear() function:

d = {...}
d.clear()