Python Dictionaries Explained With Examples

1What Is a Python Dictionary?

A Python dictionary is a built-in data structure that stores information as key-value pairs, so you retrieve a value by its key instead of by a numeric position. Think of a real dictionary: you look up a word (the key) to find its definition (the value). This makes lookups fast and code readable.

Dictionaries are written with curly braces, with each pair as key: value separated by commas. They are mutable, meaning you can add, change, and remove pairs after creation, and since Python 3.7 they remember the order in which keys were inserted.

• user = {'name': 'Ava', 'age': 29, 'active': True}
• print(user['name']) # Ava
• empty = {} # an empty dictionary
• scores = dict(math=90, science=85) # using the constructor

2Why Use Dictionaries

Dictionaries shine when you need to associate one piece of data with another and look it up quickly by name rather than position. Because they are backed by a hash table, retrieving a value by key stays fast even as the dictionary grows large.

• Named access: user['email'] is clearer than remembering row[3].
• Fast lookups: checking membership with 'key in d' is efficient regardless of size.
• Flexible values: store numbers, strings, lists, or entire nested dictionaries.
• Natural fit for JSON, config files, counting, and grouping data.

3Creating and Accessing Values

You can create a dictionary with braces, the dict() constructor, or a comprehension. To read a value, use square brackets with the key, but be aware this raises a KeyError if the key is missing.

The safer .get() method returns None (or a default you supply) instead of crashing when a key is absent, which is ideal for optional data.

• prices = {'coffee': 3.5, 'tea': 2.0}
• print(prices['coffee']) # 3.5
• print(prices.get('juice')) # None, no error
• print(prices.get('juice', 0)) # 0, supplied default

if 'tea' in prices:
    print('We have tea')

4Updating and Removing Items

Adding or changing a value uses the same square-bracket syntax: assign to a key and it is created if absent or overwritten if present. To merge another dictionary in, use .update().

• user['age'] = 30 # update existing key
• user['city'] = 'Pune' # add a new key
• user.update({'active': False, 'plan': 'pro'}) # merge in bulk
• del user['city'] # remove a key
• removed = user.pop('plan') # remove and return the value
• user.clear() # empty the whole dictionary

5Looping Over Dictionaries

Iterating a dictionary directly loops over its keys. To work with values or both at once, use the .values() and .items() methods, which return view objects that stay in sync with the dictionary.

• for key in user: # loops over keys
• print(key)
• for value in user.values(): # loops over values
• print(value)
• for key, value in user.items(): # loops over pairs
• print(key, '->', value)

6Useful Built-in Methods

A handful of methods handle most everyday dictionary work. Knowing them saves you from writing loops for tasks the language already solves.

• .keys() — a view of all keys.
• .values() — a view of all values.
• .items() — a view of (key, value) pairs.
• .get(key, default) — safe read with a fallback.
• .setdefault(key, default) — read a key, inserting the default if it is missing.
• .update(other) — merge another dictionary or key-value pairs in place.

7Comprehensions and Nested Dictionaries

A dictionary comprehension builds a map in a single expression, mirroring list comprehensions but producing key-value pairs. Nested dictionaries let you model structured, hierarchical data — the same shape you see in JSON.

• squares = {n: n * n for n in range(5)} # {0:0, 1:1, 2:4, 3:9, 4:16}
• team = {'ava': {'role': 'dev', 'level': 3}, 'raj': {'role': 'qa', 'level': 2}}
• print(team['ava']['role']) # dev

counts = {}
for ch in 'banana':
    counts[ch] = counts.get(ch, 0) + 1
# {'b': 1, 'a': 3, 'n': 2}

8Common Mistakes to Avoid

Most dictionary bugs come from a few predictable habits. Watch for these and your code will be far more robust.

• Using square brackets on a possibly-missing key, causing KeyError — prefer .get() when a key may be absent.
• Trying to use a list as a key — keys must be hashable, so use a tuple instead.
• Modifying a dictionary while looping over it directly — loop over a copy with list(d.items()) if you need to change size.
• Assuming .keys() returns a list — it returns a view; wrap it in list() if you need indexing.
• Relying on duplicate keys — a later key silently overwrites an earlier identical one.

9Key Takeaways

Dictionaries are one of Python's most-used structures — these points capture what matters most.

• Dictionaries store key-value pairs for fast, name-based lookups.
• Keys must be unique and hashable; values can be anything.
• Use .get() to read safely and .update() to merge in bulk.
• Loop with .items() to access keys and values together.
• Comprehensions and nesting handle structured data cleanly.

10Frequently Asked Questions

Q: Are Python dictionaries ordered? A: Yes. Since Python 3.7, dictionaries preserve insertion order as a language guarantee, so iterating returns keys in the order you added them. Before 3.7 this was an implementation detail and not reliable.

Q: Can a dictionary key be a list? A: No. Keys must be hashable, and lists are mutable and therefore unhashable. Use a tuple, which is immutable and hashable, when you need a compound key.

Q: What is the difference between .get() and square-bracket access? A: Square brackets raise a KeyError if the key is missing, while .get() returns None or a default value you provide. Use .get() when a key may legitimately be absent.

Q: How do I merge two dictionaries? A: Use d1.update(d2) to merge in place, or the union operator d1 | d2 (Python 3.9+) to create a new merged dictionary. In both cases, values from the second dictionary win on duplicate keys.