Python Dictionaries (Key-Value Pairs)

A Python dictionary is a mutable, unordered collection of key-value pairs, defined with curly braces {} and colons separating each key from its value, such as {"model": "gpt-4", "temperature": 0.7}. Conceptually it mirrors a JSON object exactly, which is why dictionaries are the natural Python representation for API payloads, configuration blocks, and parsed JSON responses.

Every key in a dictionary must be hashable — strings, numbers, and tuples of hashable values all qualify, but lists and other dictionaries do not, since their contents (and therefore their hash) can change over time. Values, on the other hand, can be absolutely anything: a string, a number, a nested list, or even another dictionary, which is how deeply nested JSON structures like {"user": {"name": "Alice", "roles": ["admin"]}} are represented naturally in Python.

Because dictionaries are built on a hash table under the hood, Python can locate a value by its key without scanning every entry — the key's hash tells Python almost exactly where in memory to look. That's the mechanical reason dictionary lookups stay fast even as a dictionary grows to hold thousands of entries.

Once a dictionary exists, you retrieve a value by placing its key inside square brackets, such as model_config["temperature"]. This bracket syntax is fast and direct, but it comes with a sharp edge: if the key you ask for doesn't exist, Python raises a KeyError and, unless you catch it, your program crashes on the spot.

For any situation where a key might legitimately be missing — an optional configuration field, a user-supplied payload, a partially filled API response — the .get() method is the safer tool. model_config.get("top_p", 1.0) returns the value if the key exists, and quietly falls back to the second argument (here, 1.0) if it doesn't, with no exception raised at all.

Choosing between the two isn't arbitrary: use bracket access when a missing key really is a bug you want to know about immediately, and use .get() when a missing key is an expected, normal case that should have a sensible default. Mixing up the two is one of the most common sources of unhandled KeyError crashes in production Python code.

When you print() a dictionary, Python shows you its literal representation — curly braces with every key and value exactly as stored, in insertion order (dictionaries have remembered insertion order since Python 3.7). That's why print(model_config) produces output that looks identical to the literal used to create it: {'model': 'gpt-4', 'temperature': 0.7, 'max_tokens': 500}.

Behind that readable output is a hash table, which is what gives dictionaries their signature performance characteristic: average-case O(1) lookup, insertion, and deletion, regardless of how many keys the dictionary holds. Retrieving model_config["temperature"] from a dictionary with 5 keys or 5 million keys takes roughly the same amount of time, because Python jumps to the slot determined by the key's hash instead of scanning entries one by one.

Dictionaries are also mutable in place: assigning to an existing key updates its value, and assigning to a new key inserts it, both without creating a new dictionary object. That mutability is exactly what lets configuration objects and cached lookups be updated cheaply as a program runs, but it also means two variables pointing at the same dictionary will both see any change made through either one.

In the world of AI, data is rarely just a flat list. Dictionaries allow us to store data as Key-Value pairs, identical to JSON objects.

We define a dictionary using curly braces {}. Let's create a configuration payload for an AI model.

When printed, it outputs exactly like the dictionary we created. Dictionaries are optimized for rapid lookup by key.

Checkpoint: What characters are used to enclose a Python dictionary?

• →[ ] (Square Brackets)
• →{ } (Curly Braces)

To extract a specific value, we use the key inside square brackets. Let's grab the temperature.

It successfully finds the value associated with 'temperature'. But be careful—wrong keys cause errors!

If a key doesn't exist, using brackets will crash your app. Instead, use .get(). It safely returns 'None' (or a default) if the key is missing.

Checkpoint: Which method prevents a KeyError when trying to access a missing key?

• →.get()
• →.find()

To modify or add a new key-value pair, simply assign it. It's like updating a variable, but pointing to a specific key.

The dictionary is dynamic. We've updated 'name' and added 'role' in place.

Checkpoint: Dictionaries are identical in structure to which common data format?

• →XML
• →JSON

Mastering dictionaries is critical for working with APIs and model configurations. Start mapping your data today!

Build a Real Config Payload. Finish build_config(): a dictionary stores key-value pairs, matching a real JSON API payload.