Iterating Over Keys by Default

🏷️ Dictionaries / Iterating Over Dictionaries

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

🧠 Context Introduction

When you work with dictionaries in Python, one of the most common tasks is looping through their contents. By default, when you iterate over a dictionary using a simple for loop, Python gives you the keys — not the values. This is a fundamental behavior that makes dictionary iteration intuitive and efficient. Understanding this default behavior helps you write cleaner code and avoid confusion when accessing dictionary data.

⚙️ How Default Iteration Works

A dictionary stores data as key-value pairs.
When you write a for loop directly on a dictionary, Python automatically iterates over its keys.
This means you can access each key one by one without needing any special method.

Example: - You have a dictionary named server_status with keys like "web01", "db01", and "cache01". - Writing for item in server_status: will assign each key to item in sequence. - The loop will run once for each key in the dictionary.

Expected behavior: - First iteration: item equals "web01" - Second iteration: item equals "db01" - Third iteration: item equals "cache01"

📊 Why Keys by Default?

Reason	Explanation
🔑 Keys are unique identifiers	Keys are the primary way to look up data, so iterating over them first makes logical sense
⚡ Efficient access to values	Once you have a key, you can easily get its corresponding value using square brackets
🧹 Cleaner syntax	No need to call a special method just to get started with iteration
🔄 Consistent behavior	This default works the same way across all Python versions

🛠️ Practical Example in Context

Consider a dictionary storing server configurations:

servers dictionary contains: "web01" maps to "192.168.1.10", "db01" maps to "192.168.1.20", and "cache01" maps to "192.168.1.30"

When you write a loop like for server in servers: , you get each server name one at a time.

To access the IP address for each server, you would use servers[server] inside the loop.

What happens step by step: 1. The loop starts with server equal to "web01" 2. You can print server to see the key 3. You can print servers[server] to see the value "192.168.1.10" 4. The loop moves to "db01" and repeats the process 5. Finally, it processes "cache01"

🕵️ Common Patterns and Tips

Accessing values inside the loop: Use dictionary_name[key] to get the value for the current key
Naming your loop variable: Use a descriptive name like key, server, or hostname instead of generic names like x or item
Modifying values: You can update values inside the loop using dictionary_name[key] = new_value
Checking for key existence: Use if key in dictionary_name: before accessing to avoid errors

Example pattern: - Loop variable: host - Access value: config[host] - This gives you the configuration details for each host as you iterate

✅ Key Takeaways

Python dictionaries iterate over keys by default — no extra methods needed
This default behavior is designed for clarity and efficiency
Use the key variable inside the loop to access corresponding values
Always use descriptive loop variable names for better code readability
This pattern is consistent across all dictionary sizes and data types

📖 Quick Reference

Default loop: for key in my_dict: — iterates over keys
Access value: my_dict[key] — gets the value for the current key
Common variable names: key, k, item, or a descriptive name like user_id
Remember: The loop variable holds the key, not the value

When you loop through a dictionary in Python, it automatically iterates over its keys unless you specify otherwise.

🔧 Example 1: Basic Key Iteration

This shows the simplest way to loop through a dictionary — Python gives you each key one at a time.

engineer_scores = {"Alice": 95, "Bob": 82, "Charlie": 91}
for key in engineer_scores:
    print(key)

📤 Output: Alice Bob Charlie

🔧 Example 2: Using Keys to Access Values

This demonstrates how to get both the key and its corresponding value inside the loop.

engineer_scores = {"Alice": 95, "Bob": 82, "Charlie": 91}
for key in engineer_scores:
    value = engineer_scores[key]
    print(key, "scored", value)

📤 Output: Alice scored 95 Bob scored 82 Charlie scored 91

🔧 Example 3: Checking If a Key Exists

This shows how to use key iteration to verify membership before accessing a value.

engineer_scores = {"Alice": 95, "Bob": 82, "Charlie": 91}
search_name = "David"
found = False
for key in engineer_scores:
    if key == search_name:
        found = True
        break
print("Found:", found)

📤 Output: Found: False

🔧 Example 4: Building a List of Keys

This demonstrates collecting all keys into a list during iteration for later use.

engineer_scores = {"Alice": 95, "Bob": 82, "Charlie": 91}
key_list = []
for key in engineer_scores:
    key_list.append(key)
print(key_list)

📤 Output: ['Alice', 'Bob', 'Charlie']

🔧 Example 5: Filtering Keys by Condition

This shows how to iterate over keys and only process those that meet a specific condition.

engineer_scores = {"Alice": 95, "Bob": 82, "Charlie": 91, "Diana": 78}
high_scorers = []
for key in engineer_scores:
    if engineer_scores[key] >= 90:
        high_scorers.append(key)
print("Engineers with 90+:", high_scorers)

📤 Output: Engineers with 90+: ['Alice', 'Charlie']

Comparison Table: Iteration Methods

Method	What You Get	Use Case
`for key in dict`	Keys only	Default, simplest loop
`for key in dict.keys()`	Keys only	Explicit, same as default
`for key, value in dict.items()`	Both key and value	When you need both directly
`for value in dict.values()`	Values only	When keys are not needed