A dictionary is a mutable collection of ordered key-value pairs.
Keys must be unique (no duplicate keys) and immutable (strings, numbers, tuples) The values can be of any type, including mixed types within the same dictionary: strings, numbers, dictionaries, lists, objects, ...

Creating basic dictionaries:
Use braces ({}) to create a dictionary.
Use commas to separate items in the dictionary.

Empty dictionary:

x = {} y = dict() print(type(x)) # Output: <class 'dict'> print(x) # Output: {}

A dictionary with one key-value pair:

print({'a': 1}) # Output: {'a': 1}

A dictionary with multiple key-value pairs:

print({'a': 1, 'b': 2}) # Output: {'a': 1, 'b': 2}

Mixed data types:

x = {'a': 1, 'b': 'B', 'c': [1, 2], 'd': (1, 2), 'e': {1, 2}, 'f': {'w': 10}} print(x) # Output: {'a': 1, 'b': 'B', 'c': [1, 2], 'd': (1, 2), 'e': {1, 2}, 'f': {'w': 10}}

List/Set/Dictionary of dictionaries:

x = {'a': 1, 'b': 2} y = {'c': 2, 'd': 3} # list of dictionaries z = [x, y] # dictionary of list, set, and dictionaries d = {'r': x, 's': y, 't': z} # dictionaries cannot be elements of sets because they're mutable and therefore unhashable #w = {x, y} # Raises TypeError: unhashable type: 'dict' print(z) # Output: [{'a': 1, 'b': 2}, {'c': 2, 'd': 3}] print(z[0]['b']) # Output: 2 print(d) # Output: {'r': {'a': 1, 'b': 2}, 's': {'c': 2, 'd': 3}, 't': [{'a': 1, 'b': 2}, {'c': 2, 'd': 3}]} print(d['t'][0]['b']) # Output: 2

Create dictionaries using dict() with keyword arguments:

print(dict(a='A', b='B')) # Output: {'a': 'A', 'b': 'B'}

Create dictionaries using dict() with list of tuples:

print(dict([('a', 'A'), ('b', 'B')])) # Output: {'a': 'A', 'b': 'B'}

Create dictionaries using dictionary comprehension:

print({x: x**2 for x in range(3)}) # Output: {0: 0, 1: 1, 2: 4}

Tuples as dictionary keys:

This is possible because tuples are immutable.
numbers = {(0, 0):0, (0, 1):1, (1, 0):2, (1, 1):3} print(numbers[(0,1)]) # Output: 1 print(numbers.get((0,1))) # Output: 1 print(numbers.get((0,2))) # Output: None print(numbers.get((0,2), "undetermined")) # Output: undetermined

Accessing keys in a dictionary:

x = {'a': 1, 'b': 2} print(x['a']) # Output: 1

Accessing a key that doesn't exist throws an error:

print(x['d']) # Raises KeyError: 'd' # to handle the KeyError: use try/except try: print(x['d']) except KeyError as e: print(f"key not found: {e}") # Output: key not found: 'd' # to handle the KeyError: check if key exists if 'd' in x: print(x['d']) else: print("key 'd' not found")

Using the get function:

It returns default/custom value if the key doesn't exist.
print(x.get('a')) # Output: 1 # return None if key doesn't exist print(x.get('d')) # Output: None # return custom value if key doesn't exist print(x.get('d','key not found')) # Output: key not found

Adding new key-value pairs:

x['c'] = 3 print(x) # Output: {'a': 1, 'b': 2, 'c': 3} # use setdefault() to add a key-value pair only if the key doesn't exist x.setdefault('c', 33) x.setdefault('d', 4) print(x) # Output: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Modifying values in a dictionary:

x['a'] = 0 print(x['a']) # Output: 0

Using update() method:

# update using dictionaries x.update({'a': 'A', 'b': 'B'}) print(x) # Output: {'a': 'A', 'b': 'B', 'c': 3, 'd': 4} # update using keyword arguments x.update(c='C', d='D') print(x) # Output: {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D'}

Removing key-value pairs:

# using del statement del x['d'] print(x) # Output: {'a': 'A', 'b': 'B', 'c': 'C'} # you get a KeyError if the key doesn't exist; need to handle the exception or check if the key exists del x['d'] # Raises KeyError: 'd'

Removing a specific key and returning its value:

# using pop() method to remove a specific key print(x.pop('c')) # Output: 'C' print(x) # Output: {'a': 'A', 'b': 'B'} # you get a KeyError if the key doesn't exist; need to handle the exception or check if the key exists print(x.pop('c')) # Raises KeyError: 'c'

Removing a specific key and returning a tuple with key/value:

# using popitem() method to remove last item print(x.popitem()) # Output: ('b', 'B') print(x) # Output: {'a': 'A'} # you get a KeyError if the dictionary is empty: need to handle the exception or check the length of the dictionary print(x.popitem()) # Output: ('a', 'A') print(x) # Output: {} print(x.popitem()) # Raises KeyError: 'popitem(): dictionary is empty'

Clear dictionary (remove all items):

x = {'a': 1, 'b': 2, 'c': 3} x.clear() print(x) # Output: {}

Looping through all key-value pairs:

x = {'a': 1, 'b': 2, 'c': 3} for key, value in x.items(): print(f'key:{key} | value:{value}') Output:
key:a | value:1 key:b | value:2 key:c | value:3

Looping through all keys in a dictionary:

# default behavior for key in x: print(f'key:{key} | value:{x[key]}') print() # explicitly iterate over keys for key in x.keys(): # calling the keys() function is similar to looping on the dictionary itself print(f'key:{key} | value:{x[key]}') Output:
key:a | value:1 key:b | value:2 key:c | value:3 key:a | value:1 key:b | value:2 key:c | value:3

Looping through all values in a dictionary:

for value in x.values(): print(f'value:{value}') Output:
value:1 value:2 value:3

Looping through all sorted keys:

for key in sorted(x.keys()): print(f'key:{key} | value:{x[key]}') Output:
key:a | value:1 key:b | value:2 key:c | value:3

Looping through all sorted keys (reversed order):

for key in sorted(x.keys(), reverse=True): print(f'key:{key} | value:{x[key]}') Output:
key:c | value:3 key:b | value:2 key:a | value:1

Looping through all sorted values (reversed order):

for key in sorted(x, key=x.get): print(f'key:{key} | value:{x[key]}') Output:
key:a | value:1 key:b | value:2 key:c | value:3

Looping through all the unique values in a dictionary:

x = {'a': 1, 'b': 2, 'c': 2} for value in set(x.values()): print(f'value:{value}') Output:
value:1 value:2

Dictionary comprehensions:

x = [1, 2, 3] # create dictionary from list print({k: k**2 for k in x}) # Output: {1: 1, 2: 4, 3: 9} # create dictionary from list with condition print({k: k**2 for k in x if k % 2 == 1}) # Output: {1: 1, 3: 9} # create dictionary from two lists y = ['a', 'b', 'c'] print({k: v for k, v in zip(x, y)}) # Output: {1: 'a', 2: 'b', 3: 'c'}

Merging Dictionaries:

Conflicting keys will be resolved by taking the values from the last dictionary in the list of dictionaries to merge:
x = {'a': 'A', 'b': 'B'} y = {'b': 'b', 'd': 'D'} # using ** operator: new dictionary created print({**x, **y}) # Output: {'a': 'A', 'b': 'b', 'd': 'D'} # using | operator: new dictionary created print(x | y) # Output: {'a': 'A', 'b': 'b', 'd': 'D'} # using update method: original dictionary updated x.update(y) print(x) # Output: {'a': 'A', 'b': 'b', 'd': 'D'}

Copying dictionaries:

x = {'r': {'a': 1, 'b': 2}, 's': {'c': 2, 'd': 3}, 't': [{'a': 1, 'b': 2}, {'c': 2, 'd': 3}]} # copy by reference y = x # both x and y reference the same dictionary y['r'] = 0 print(x['r']) # Output: 0 # copy by value z = x.copy() # new copy w = dict(x) # new copy z['s'] = 3 print(x['s']) # Output: {'c': 2, 'd': 3} print(z['s']) # Output: 3 print(w['s']) # Output: {'c': 2, 'd': 3}