Dictionary Keys, Values, and Methods in Python

A dictionary maps keys to values

A dictionary is written with curly braces containing key: value pairs. The key identifies an entry; the value is the data associated with that key. Instead of asking for “item zero,” you can ask for the value stored under "name" or "level".

This makes dictionaries useful for records, configuration settings, counters, lookup tables, structured API data, and many other cases where meaningful labels are more useful than numeric positions.

profile = {
    "name": "Ada",
    "language": "Python",
    "level": 3
}
print(profile["name"])
print(profile["level"])

Ada
3

The strings "name", "language", and "level" are keys. Their associated values are "Ada", "Python", and 3. A dictionary value can be almost any Python object, including strings, numbers, lists, or even another dictionary.

Dictionary keys must be unique and hashable

Within one dictionary, each key identifies one current value. If you assign a new value to an existing key, that entry is updated rather than duplicated. Keys also have to be hashable, which means common immutable values such as strings, integers, and tuples can work as keys, while mutable lists cannot.

Values do not have the same restriction. Multiple keys can point to equal values, and values can be mutable objects.

Assignment updates an existing key or creates a new one

Dictionaries are mutable. Square-bracket assignment has two related behaviors: if the key already exists, its value changes; if the key is new, a new key/value pair is added.

settings = {"theme": "dark", "volume": 5}
settings["volume"] = 7
settings["captions"] = True
print(settings)

{'theme': 'dark', 'volume': 7, 'captions': True}

The "volume" key already existed, so its value changed from 5 to 7. The "captions" key did not exist, so Python added a new entry. No special add method is required for basic dictionary insertion.

keys(), values(), and items() expose dictionary views

Three foundational dictionary methods provide views over different parts of the mapping. keys() gives access to the keys, values() gives access to the values, and items() gives access to key/value pairs.

These methods return special view objects rather than ordinary lists. The views reflect the current dictionary. For teaching output below, list() converts each view into a list so its contents are easy to see.

scores = {"Ada": 98, "Grace": 95, "Linus": 91}
print(list(scores.keys()))
print(list(scores.values()))
print(list(scores.items()))

['Ada', 'Grace', 'Linus']
[98, 95, 91]
[('Ada', 98), ('Grace', 95), ('Linus', 91)]

The pairs produced by items() appear as two-element tuples. This becomes especially useful in loops because one iteration can receive both the key and its associated value.

get() provides a safer lookup when a key might be absent

Square-bracket lookup is strict: mapping[key] raises KeyError when the key does not exist. The get() method is useful when absence is an ordinary possibility rather than an exceptional condition.

mapping.get(key) returns the stored value when the key exists and None when it does not. A second argument supplies a custom fallback.

inventory = {"camera": 2, "tripod": 1}
print(inventory.get("camera"))
print(inventory.get("lens"))
print(inventory.get("lens", 0))

2
None
0

The existing key returns its stored value. The absent key returns None when no fallback is supplied and 0 when that fallback is provided. Choosing between square brackets and get() depends on what absence means in your program: an unexpected missing key may deserve a visible error, while an optional field may deserve a default.

Looping over a dictionary usually means looping over keys or items

A plain for key in data: loop iterates over dictionary keys. If you need both sides of each mapping, for key, value in data.items(): is often clearer. The same unpacking idea appeared with enumerate() in the list module, but here the pair comes from each dictionary item.

This lesson stops short of dictionary membership tests because Lesson 17 is dedicated to checking dictionaries and understanding their reference/copy behavior. For now, the important foundation is knowing what a key is, what a value is, and how the main access methods represent the mapping.

Common dictionary mistakes

The failures below were executed in Python. They show four different assumptions that do not match dictionary rules.

profile = {"name": "Ada", "language": "Python"}
print(profile["level"])

Traceback (most recent call last):
  File "/tmp/ipykernel_313/2116017354.py", line 12, in run_err
    exec(compile(code, filename, "exec"), {})
    ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/tmp/awm_lesson16/mistake1_missing_key.py", line 2, in <module>
KeyError: 'level'

Square-bracket lookup expects the key to exist. If absence is acceptable, use get() or explicitly test for the key in the next lesson.

lookup = {}
lookup[["red", "green"]] = "colors"

Traceback (most recent call last):
  File "/tmp/ipykernel_313/2116017354.py", line 12, in run_err
    exec(compile(code, filename, "exec"), {})
    ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/tmp/awm_lesson16/mistake2_unhashable_key.py", line 2, in <module>
TypeError: unhashable type: 'list'

Lists are mutable and therefore unhashable, so they cannot serve as dictionary keys. A tuple may be appropriate when you need an immutable multi-part key.

profile = {"name": "Ada"}
profile.append("Python")

Traceback (most recent call last):
  File "/tmp/ipykernel_313/2116017354.py", line 12, in run_err
    exec(compile(code, filename, "exec"), {})
    ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/tmp/awm_lesson16/mistake3_append.py", line 2, in <module>
AttributeError: 'dict' object has no attribute 'append'

Dictionaries do not have the list method append(). Add a key/value pair with assignment such as profile["language"] = "Python".

scores = {"Ada": 98, "Grace": 95}
print(scores.get("Ada", "missing", 0))

Traceback (most recent call last):
  File "/tmp/ipykernel_313/2116017354.py", line 12, in run_err
    exec(compile(code, filename, "exec"), {})
    ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/tmp/awm_lesson16/mistake4_get_too_many_args.py", line 2, in <module>
TypeError: get expected at most 2 arguments, got 3

get() accepts the key plus at most one default value. It is a focused lookup method, not a general multi-fallback function.

Supporting classroom explanations

This page is original A Wandering Mind instructional material. The two CPSC 1301K lectures below reinforce dictionary structure and the methods used to retrieve or work with dictionary data.

Try it yourself

For each exercise, identify which strings are keys and which objects are values before running the code.

book = {"title": "Dune", "year": 1965}
print(book["title"])
print(book["year"])

Dune
1965

account = {"plan": "free"}
account["plan"] = "pro"
account["active"] = True
print(account)

{'plan': 'pro', 'active': True}

prices = {"coffee": 4.5, "tea": 3.0}
print(prices.get("tea"))
print(prices.get("juice", 0.0))

3.0
0.0

What you should carry into Lesson 17

You now know how dictionaries map unique hashable keys to values, how square-bracket lookup retrieves an existing entry, how assignment adds or updates entries, and how keys(), values(), items(), and get() expose dictionary data in different ways.

Next, you will ask whether keys exist and revisit the reference/copy distinction from lists. Continue to Checking, Aliasing, and Copying Dictionaries.