Syntax Key-Value Expressions and Loops

🏷️ Dictionaries / Dictionary Comprehensions

📚 All-in-One📖 Theory Only💻 Code Only

Welcome to the world of dictionary comprehensions! If you've worked with lists before, you know how powerful comprehensions can be. Dictionary comprehensions take that same elegant, concise approach and apply it to key-value pairs. Instead of writing multiple lines to build a dictionary step by step, you can create one in a single, readable expression. This is especially useful when you need to transform data, filter entries, or map values from one structure to another.

⚙️ What Is a Dictionary Comprehension?

A dictionary comprehension is a compact way to create a dictionary by iterating over an iterable (like a list, tuple, or another dictionary) and defining both the key and the value for each item. The basic structure looks like this:

{key_expression: value_expression for item in iterable}

The key and value expressions can be any valid Python expression, and they are evaluated for each item in the iterable. The result is a new dictionary.

📊 Basic Syntax Breakdown

Let's break down the components of a dictionary comprehension:

Curly braces { } – These indicate you are creating a dictionary, just like with a literal dictionary.
key_expression – This defines what the key will be for each entry. It can be the item itself, a transformation of the item, or a completely new value.
Colon : – Separates the key expression from the value expression.
value_expression – This defines what the value will be for each entry.
for item in iterable – This is the loop part, iterating over each element in your source data.

Simple example: Creating a dictionary where each number from 0 to 4 is a key, and its square is the value.

{x: x2 for x in range(5)} would produce {0: 0, 1: 1, 2: 4, 3: 9, 4: 4}**

🛠️ Adding Conditions with if Statements

You can also filter items by adding an if condition at the end of the comprehension. This allows you to include only those key-value pairs that meet a specific criterion.

{key_expression: value_expression for item in iterable if condition}

Example with filtering: Create a dictionary of even numbers and their cubes.

{x: x3 for x in range(10) if x % 2 == 0} would produce {0: 0, 2: 8, 4: 64, 6: 216, 8: 512}**

🕵️ Transforming Existing Dictionaries

One of the most common use cases is transforming an existing dictionary. You can iterate over the items of a dictionary using the .items() method, which gives you access to both the key and the value.

{new_key: new_value for original_key, original_value in original_dict.items()}

Example: Convert all keys in a dictionary to uppercase strings.

Given original_dict = {"apple": 1, "banana": 2, "cherry": 3}
{key.upper(): value for key, value in original_dict.items()} would produce {"APPLE": 1, "BANANA": 2, "CHERRY": 3}

📋 Comparison: Traditional Loop vs. Dictionary Comprehension

Feature	Traditional Loop	Dictionary Comprehension
Lines of code	3 or more lines	1 line
Readability	Clear but verbose	Concise and expressive
Performance	Slightly slower	Generally faster
Best for	Complex logic or multiple steps	Simple transformations and filtering

Traditional loop example:

Start with an empty dictionary: result = {}
Loop over a range: for x in range(5):
Assign key-value pair: result[x] = x2

Dictionary comprehension equivalent:

result = {x: x2 for x in range(5)}**

Both produce the same output, but the comprehension is much shorter.

🧪 Practical Examples for Engineers

Example 1: Mapping server names to their status codes

You have a list of server names and a list of corresponding status codes. You want to create a dictionary where the server name is the key and the status code is the value.

servers = ["web01", "db01", "cache01"]
statuses = [200, 500, 200]
{servers[i]: statuses[i] for i in range(len(servers))} would produce {"web01": 200, "db01": 500, "cache01": 200}

Example 2: Filtering configuration keys that start with a specific prefix

You have a dictionary of configuration settings, and you only want to keep keys that start with "log_".

config = {"log_level": "info", "db_host": "localhost", "log_format": "json", "app_port": 8080}
{key: value for key, value in config.items() if key.startswith("log_")} would produce {"log_level": "info", "log_format": "json"}

Example 3: Swapping keys and values

You have a dictionary and want to invert it, making the original values the new keys and the original keys the new values.

original = {"a": 1, "b": 2, "c": 3}
{value: key for key, value in original.items()} would produce {1: "a", 2: "b", 3: "c"}

✅ Key Takeaways

Dictionary comprehensions provide a concise way to create dictionaries from iterables.
The syntax is {key: value for item in iterable} with an optional if condition for filtering.
You can transform existing dictionaries by iterating over .items().
They are generally faster and more readable than traditional loops for simple transformations.
Use them when you need to map, filter, or transform data into a key-value structure quickly.

Now you have a powerful tool in your Python toolkit. Practice by converting some of your existing loop-based dictionary building code into comprehensions, and you'll quickly see how much cleaner your scripts can become.

Dictionary comprehensions let you build dictionaries by combining a key-value expression with a loop in a single line.

🔧 Example 1: Basic dictionary from two lists

Creates a dictionary by pairing items from two lists using a loop.

keys = ['a', 'b', 'c']
values = [1, 2, 3]
result = {k: v for k, v in zip(keys, values)}

📤 Output: {'a': 1, 'b': 2, 'c': 3}

🔧 Example 2: Square numbers as values

Generates a dictionary where keys are numbers and values are their squares.

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

📤 Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

🔧 Example 3: Filtering with a condition

Builds a dictionary containing only even numbers and their cubes.

numbers = [1, 2, 3, 4, 5, 6]
even_cubes = {n: n ** 3 for n in numbers if n % 2 == 0}

📤 Output: {2: 8, 4: 64, 6: 216}

🔧 Example 4: Transforming existing dictionary keys

Creates a new dictionary with uppercase keys from an existing dictionary.

original = {'apple': 3, 'banana': 5, 'cherry': 2}
uppercase = {k.upper(): v for k, v in original.items()}

📤 Output: {'APPLE': 3, 'BANANA': 5, 'CHERRY': 2}

🔧 Example 5: Mapping sensor readings to status

Converts a list of sensor readings into a dictionary with pass/fail status.

sensors = ['temp_01', 'temp_02', 'temp_03']
readings = [72, 95, 68]
status = {s: 'pass' if r < 90 else 'fail' for s, r in zip(sensors, readings)}

📤 Output: {'temp_01': 'pass', 'temp_02': 'fail', 'temp_03': 'pass'}

Comparison Table: Dictionary Comprehension vs. Manual Loop

Feature	Dictionary Comprehension	Manual For Loop
Lines of code	1 line	3–5 lines
Readability	Compact, clear for simple cases	More explicit, easier to debug
Performance	Faster for small to medium data	Same result, more overhead
Condition support	Built-in with `if` clause	Requires manual `if` block
Best for	Simple key-value transformations	Complex logic or multiple steps