Python Dictionaries - Key-Value Pairs and Data Structures

Welcome back to our comprehensive course on Python programming and data science. I'm Brian McLean, and in this fifth lesson, we're diving into one of Python's most powerful and versatile data structures: dictionaries.

As you've noticed, each lesson in our series tackles a fundamental programming concept that builds your expertise systematically. We started with variables and data types in lesson one, explored conditional logic with if-else statements in lesson two, covered modules in lesson three, and just completed our deep dive into loops and string methods in lesson four.

Today, we're working in file five, and I'll begin by importing pprint—Python's pretty-print module. Since dictionaries can become complex, nested structures, pretty-printing will make our output far more readable and professionally formatted when we're debugging or analyzing data.

Understanding dictionaries is crucial because they're everywhere in modern Python development. From JSON APIs to configuration files, from database records to machine learning datasets, dictionaries form the backbone of data manipulation in Python. Think of them as Python's equivalent to real-world lookup tables—incredibly efficient and intuitive once you master their syntax.

A dictionary belongs to Python's family of collection data types—iterable structures that can hold multiple values. You're already familiar with lists, which store items by numerical index in square brackets, and sets, which store unique items in curly braces without any ordering or indexing.

Dictionaries occupy a unique middle ground: they store items in curly braces like sets, but unlike both lists and sets, they organize data using keys instead of positions. This key-value pair system makes dictionaries incredibly powerful for representing real-world relationships where you need to associate meaningful names with data.

Let's create our first dictionary to see this concept in action. We'll build a car dictionary that demonstrates how dictionaries excel at modeling complex, related data—something you'll encounter constantly in data science and web development.

Dictionary syntax follows a specific pattern: all key-value pairs go inside curly braces, with keys always enclosed in quotes (since they're technically strings) and values taking whatever data type is appropriate. Here's what makes dictionaries particularly elegant—values can be any Python data type, including other dictionaries, creating powerful nested structures.

Let's construct our car dictionary with multiple properties. If you're coming from JavaScript, you'll find this familiar—Python dictionaries are essentially JavaScript objects, while Python lists correspond to JavaScript arrays.

```python car = { "make": "Ford", "model": "Mustang GT", "options": ["leather seats", "premium sound", "sports package"], "year": 2003, "miles": 56789, "for sale": True, "on road": False } ```

Notice how we're mixing data types strategically. Our keys—make, model, options, year, miles, for sale, and on road—each serve as descriptive labels. The values span strings, numbers, lists, and booleans, demonstrating dictionary flexibility.

Pay particular attention to keys like "for sale" and "on road"—unlike regular Python variables, dictionary keys can contain spaces because they're quoted strings. This makes dictionaries more readable and closer to natural language, a significant advantage when modeling real-world data.

Let's enhance our dictionary with nested structures, which are essential for organizing related data professionally. Instead of having separate "MPG city" and "MPG highway" keys, we'll create a cleaner, more maintainable structure:

```python car = { "make": "Ford", "model": "Mustang GT", "options": ["leather seats", "premium sound", "sports package"], "year": 2003, "miles": 56789, "for sale": True, "on road": False, "MPG": { "city": 18, "highway": 24 } } ```

---

This nested approach demonstrates professional data modeling—grouping related properties under a parent key creates more logical, maintainable code structures that scale well in production environments.

Now let's master dictionary access patterns, which differ significantly from list indexing. To retrieve values, use the syntax `dictionary[key]`—note the square brackets with quoted keys, not dot notation like you might use in JavaScript.

```python print(car["make"]) # Ford print(car["model"]) # Mustang GT print(car["year"]) # 2003 print(car["for sale"]) # True ```

For nested data, you'll chain your lookups logically. To access the highway MPG, you first access the "MPG" key (which returns a dictionary), then access the "highway" key of that nested dictionary:

```python print(car["MPG"]["highway"]) # 24 ```

When working with list values within dictionaries, combine dictionary and list access patterns. To get the first option or a specific option by index:

```python print(car["options"]) # ['leather seats', 'premium sound', 'sports package'] print(car["options"][0]) # leather seats print(car["options"][2]) # sports package ```

Here's a critical concept: dictionaries don't support numerical indexing like lists. Attempting `car[0]` will raise a KeyError because Python looks for a key named "0", not a positional element. This is by design—dictionaries prioritize meaningful key names over positional access.

Updating dictionary values uses the same syntax as reading them, but with assignment. This makes dictionary manipulation intuitive and consistent:

```python car["year"] = 2002 car["miles"] = 57890 pprint(car) # Shows updated values ```

For list values within dictionaries, use standard list methods. To add a new option:

```python car["options"].append("sunroof") ```

Boolean manipulation in dictionaries follows standard Python patterns. To flip a boolean value regardless of its current state:

---

```python car["for sale"] = not car["for sale"] ```

This technique is particularly useful in data processing workflows where you need to toggle states based on conditions.

Dictionary management includes both destructive and non-destructive deletion methods. The `del` keyword permanently removes key-value pairs:

```python del car["on road"] # Permanently removes this property ```

For safer deletion that preserves data, use the `pop()` method, which removes and returns the value:

```python saved_miles = car.pop("miles") # Remove but save the value # Later, if needed: car["mileage"] = saved_miles # Restore under a new key name ```

Adding new properties to dictionaries is remarkably straightforward—simply assign a value to a new key. If the key exists, you update it; if it doesn't exist, Python creates it automatically:

```python car["doors"] = 2 # Creates new property car["doors"] = 4 # Updates existing property ```

Let's put these concepts together with a practical challenge that reinforces both dictionary manipulation and list methods. We'll add three new options—subwoofer, CD player, and flame decals—then alphabetize the complete options list:

```python # Add multiple options efficiently using extend() car["options"].extend(["subwoofer", "CD player", "flame decals"]) # Alphabetize the options list in place car["options"].sort() pprint(car) # Display the updated, organized dictionary ```

This exercise demonstrates real-world data management patterns—extending lists within dictionaries and maintaining sorted data for better organization and searchability. These techniques become essential when working with larger datasets in data science applications or managing configuration data in production systems.

1. Understanding dictionary fundamentals prepares you for advanced Python concepts like JSON processing, API interactions, and database operations—all critical skills in today's data-driven development landscape.