Accessing Values by Keys

🏷️ Dictionaries / Creating and Accessing Dictionaries

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

🔍 Context Introduction

Dictionaries are one of the most powerful data structures in Python. Unlike lists that use numeric indices, dictionaries store data in key-value pairs. This means you can look up a value using a unique key, much like how you would look up a word in a physical dictionary to find its definition.

For engineers working with configuration files, API responses, or system metadata, dictionaries are everywhere. Understanding how to access values by their keys is essential for reading and manipulating structured data efficiently.

⚙️ What Are Keys and Values?

A key is a unique identifier (usually a string or number) used to store and retrieve data.
A value is the data associated with that key, which can be any Python data type (string, number, list, even another dictionary).
Keys must be immutable (strings, numbers, tuples) and unique within a dictionary.

Example of a simple dictionary:

Dictionary: {"hostname": "web-server-01", "port": 443, "ssl_enabled": True}
Keys: "hostname", "port", "ssl_enabled"
Values: "web-server-01", 443, True

🛠️ Accessing Values Using Square Brackets

The most common way to access a value is by placing the key inside square brackets, just like indexing a list.

Syntax: dictionary_name["key_name"]
Example: If you have server_config = {"hostname": "db-01", "port": 3306}, then server_config["hostname"] returns "db-01"
Important: If the key does not exist, Python will raise a KeyError and stop execution.

🕵️ Accessing Values Using the .get() Method

A safer way to access values is using the .get() method. This method allows you to specify a default value if the key is missing.

Syntax: dictionary_name.get("key_name", "default_value")
Example: server_config.get("timeout", 30) returns 30 if the key "timeout" does not exist
If no default is provided and the key is missing, .get() returns None instead of raising an error

📊 Comparison: Square Brackets vs .get() Method

Feature	Square Brackets	.get() Method
Syntax	dict["key"]	dict.get("key")
Missing key behavior	Raises KeyError	Returns None or default value
Default value support	Not supported	Supported via second argument
Use case	When you are sure the key exists	When key may or may not exist
Code safety	Less safe	More safe for dynamic data

🧪 Practical Examples

Example 1: Accessing a known key

Dictionary: system_info = {"os": "Ubuntu 22.04", "kernel": "5.15", "uptime": "30 days"}
Access: system_info["os"] returns "Ubuntu 22.04"
Access: system_info.get("kernel") returns "5.15"

Example 2: Handling a missing key safely

Dictionary: app_config = {"debug": False, "max_connections": 100}
Using square brackets: app_config["timeout"] would raise a KeyError
Using .get(): app_config.get("timeout", 60) returns 60 (the default value)

Example 3: Checking if a key exists before accessing

You can use the in keyword to check: "hostname" in server_config returns True or False
Combined approach: if "hostname" in server_config: print(server_config["hostname"])

🎯 Common Pitfalls to Avoid

Spelling mistakes: Keys are case-sensitive. "Hostname" and "hostname" are different keys.
Using mutable keys: Lists or other dictionaries cannot be used as keys. Use strings, numbers, or tuples instead.
Assuming key order: In older Python versions, dictionaries were unordered. In Python 3.7+, insertion order is preserved, but do not rely on this for critical logic.
Forgetting quotes: Keys must be quoted if they are strings. server_config[hostname] will look for a variable named hostname, not the string "hostname".

✅ Summary

Use square brackets when you are confident the key exists and want immediate feedback if it does not.
Use .get() when working with uncertain or dynamic data to avoid crashes and provide fallback values.
Always verify key existence with the in operator before accessing if using square brackets.
Remember that keys are case-sensitive and must be immutable types.

Mastering dictionary access is a foundational skill that will serve you well when parsing JSON data, managing configuration files, or working with any structured data in Python.

Accessing values by keys retrieves the data stored in a dictionary using its unique key identifier.

🔧 Example 1: Accessing a value using a string key

This example shows how to get a value from a dictionary by providing the exact key name.

engineer = {"name": "Alice", "role": "DevOps", "years": 5}
print(engineer["name"])

📤 Output: Alice

🔧 Example 2: Accessing values with integer keys

This example demonstrates that dictionary keys can be integers, not just strings.

scores = {101: 85, 102: 92, 103: 78}
print(scores[102])

📤 Output: 92

🔧 Example 3: Using the get() method to avoid KeyError

This example shows how to safely access a key that might not exist in the dictionary.

server_config = {"host": "10.0.0.1", "port": 8080}
result = server_config.get("protocol")
print(result)

📤 Output: None

🔧 Example 4: Providing a default value with get()

This example shows how to return a custom default when a key is missing.

user_prefs = {"theme": "dark", "language": "en"}
timeout = user_prefs.get("timeout", 30)
print(timeout)

📤 Output: 30

🔧 Example 5: Accessing nested dictionary values

This example shows how to chain key lookups to reach data inside nested dictionaries.

project = {
    "name": "Pipeline",
    "team": {"lead": "Bob", "members": 4}
}
lead_name = project["team"]["lead"]
print(lead_name)

📤 Output: Bob

📊 Comparison: Access Methods

Method	Syntax	Returns if key missing	Use case
Bracket access	`dict["key"]`	Raises `KeyError`	When key is guaranteed to exist
`get()` without default	`dict.get("key")`	`None`	When key might be missing
`get()` with default	`dict.get("key", default)`	Default value	When you need a fallback value