Python Dictionaries: Create, Access, Update, and Iterate dict

A Dictionary Is a Lookup Table

Lists are indexed by position. Dictionaries are indexed by key — usually a string or a number — and each key maps to a value. That one shift unlocks a huge category of programs: inventories, configs, JSON payloads, user profiles, caches.

prices = {
    "apple": 0.50,
    "bread": 2.00,
    "milk": 1.20,
}

print(prices["apple"])
print(prices["bread"])

The keys and values can be almost anything. Keys need to be hashable (so: numbers, strings, tuples; not lists or other dicts). Values have no restriction — a dict can hold anything, including other dicts or lists.

Creating Dictionaries

Several ways, each with a place:

# Literal with braces
user = {"name": "Rosa", "age": 30, "city": "Lisbon"}
print(user)

# Empty dict, built up over time
counts = {}
counts["a"] = 1
counts["b"] = 2
print(counts)

# From a list of (key, value) pairs
pairs = [("one", 1), ("two", 2), ("three", 3)]
mapping = dict(pairs)
print(mapping)

# With keyword arguments
config = dict(host="localhost", port=8080, debug=True)
print(config)

Reading Values

Two ways, and the choice matters:

prices = {"apple": 0.50, "bread": 2.00}

# [] — direct indexing. KeyError if missing.
print(prices["apple"])

# .get() — returns None (or a default) if missing.
print(prices.get("milk"))              # None
print(prices.get("milk", 0.00))        # 0.00

Pick by intent:

• Use [] when the key must be there. If it isn't, that's a bug and you want the loud error.
• Use .get() when "not present" is a valid case. It lets you write defaults without try/except.

Adding, Updating, Deleting

Assigning to a key either creates or updates it:

prices = {"apple": 0.50, "bread": 2.00}

prices["milk"] = 1.20        # new key
prices["apple"] = 0.60       # existing key, overwritten

print(prices)

del prices["bread"]          # remove a key; KeyError if missing
print(prices)

gone = prices.pop("apple")   # remove and return; accepts a default
print("was:", gone, "now:", prices)

# pop with a default so it doesn't raise
prices.pop("missing", None)

update() merges another dict or iterable of pairs:

settings = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

settings.update(overrides)
print(settings)

Shared keys in overrides overwrite the ones in settings.

Checking for a Key

in checks the keys, not the values:

user = {"name": "Rosa", "age": 30}

print("name" in user)      # True
print("email" in user)     # False
print("Rosa" in user)      # False — that's a value, not a key

To check values specifically, use user.values():

print(30 in user.values())

How to Iterate a Dictionary

You have three views you can loop over:

scores = {"ada": 90, "rosa": 85, "malik": 78}

# Keys (the default)
for name in scores:
    print(name)

# Values
for score in scores.values():
    print(score)

# Both — the common case
for name, score in scores.items():
    print(f"{name}: {score}")

.items() is what you reach for most of the time — it gives you the pair, unpacked, ready to use.

Iteration order in modern Python (3.7+) matches insertion order. A dict is not a "magic bag" — if you add a then b then c, iterating yields them in that order. That's a language guarantee you can rely on.

How to Sort a Dictionary

Dictionaries preserve insertion order, so "sorting" a dict really means building a new dict whose keys are inserted in the order you want:

scores = {"rosa": 85, "ada": 90, "malik": 78}

# Sort by key
by_key = dict(sorted(scores.items()))
print(by_key)

# Sort by value (ascending)
by_value = dict(sorted(scores.items(), key=lambda item: item[1]))
print(by_value)

# Sort by value, descending
top = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(top)

sorted() returns a list of pairs; wrapping that in dict(...) reconstructs a dictionary with the new order. If you only need the sorted pairs (not a dict), skip the outer dict() call.

How to Merge Two Dictionaries

Python 3.9+ gives you the | operator:

defaults = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

merged = defaults | overrides
print(merged)

Values from the right-hand dict win on key collisions. .update() is the in-place equivalent. On older Python versions, use {**defaults, **overrides}.

The setdefault Pattern

A common need: "if the key is there, use its value; if not, set a default and then use it."

counts = {}

for word in ["one", "two", "one", "three", "two", "one"]:
    counts.setdefault(word, 0)
    counts[word] += 1

print(counts)

Or, better, use collections.Counter:

from collections import Counter

words = ["one", "two", "one", "three", "two", "one"]
print(Counter(words))

Counter is a dict subclass that does counting by default. It's the right call whenever you're counting occurrences.

Dictionary Comprehensions

Parallel to list comprehensions, but for building dicts:

numbers = [1, 2, 3, 4, 5]
squares = {n: n * n for n in numbers}
print(squares)

# Invert a dict (keys become values and vice versa)
prices = {"apple": 0.50, "bread": 2.00}
lookup = {v: k for k, v in prices.items()}
print(lookup)

Same rules as list comprehensions, but with key: value between the braces.

Dict as JSON's Twin

Python dicts line up almost exactly with JSON objects. Converting between them is a single call:

import json

data = {"name": "Rosa", "age": 30, "tags": ["python", "docs"]}

as_json = json.dumps(data)
print(as_json)

back = json.loads(as_json)
print(back)

This is why dicts show up everywhere in web work — your API requests and responses are basically dict manipulation with some network in the middle.

A Practical Example

A tiny config-like program that tracks a user profile:

user = {
    "name": "Rosa",
    "email": "rosa@example.com",
    "preferences": {
        "theme": "dark",
        "notifications": True,
    },
    "tags": ["python", "docs"],
}

print(user["name"])
print(user["preferences"]["theme"])
print(user.get("last_login", "never"))

user["tags"].append("seo")
user["preferences"]["theme"] = "light"

print(user)

Nested dicts, mutable values, .get() with a default — the basic toolkit for any record-shaped data.

Moving On

Lists, tuples, sets, dicts. With those four collections in hand, you can model almost any data you'll encounter early on. Next, we'll learn the list comprehension — Python's compact way to transform one collection into another.