How to access a dictionary in Python

Python dictionaries store key-value pairs that let you organize and access data efficiently. These versatile data structures use curly braces {} and colons to map unique keys to their corresponding values.

This guide covers essential dictionary techniques, real-world applications, and debugging tips, with code examples created using Claude, an AI assistant built by Anthropic.

Basic dictionary access with square brackets

student = {'name': 'Alice', 'age': 22, 'courses': ['Math', 'CS']}
print(student['name'])
print(student['courses'][1])

Alice
CS

Square bracket notation provides direct access to dictionary values through their keys. In the example, student['name'] retrieves 'Alice' by using the exact key match. This method is fast and efficient since dictionaries use hash tables internally for O(1) lookup time.

The square brackets also enable nested access for compound data structures. When accessing student['courses'][1], Python first retrieves the courses list, then indexes into position 1 to get 'CS'. This chaining capability makes dictionaries ideal for:

• Organizing hierarchical data structures
• Building complex data relationships
• Implementing caching mechanisms

Common dictionary operations

Beyond basic square bracket access, Python dictionaries offer powerful methods and techniques that make data manipulation more robust and flexible.

Using the get() method for safer access

student = {'name': 'Alice', 'age': 22}
print(student.get('name'))
print(student.get('grade', 'Not Found'))  # Provides default value if key doesn't exist

Alice
Not Found

The get() method provides a safer alternative to square bracket notation when accessing dictionary values. Unlike square brackets which raise a KeyError for missing keys, get() gracefully handles non-existent keys by returning None or a specified default value.

• The first line student.get('name') retrieves 'Alice' just like square brackets would
• The second line student.get('grade', 'Not Found') demonstrates error prevention by returning 'Not Found' instead of crashing when accessing the missing 'grade' key

This approach proves especially valuable when working with user input, API responses, or any scenario where dictionary keys might be uncertain. You can seamlessly handle missing data without wrapping code in try-except blocks.

Accessing keys, values, and items

student = {'name': 'Alice', 'age': 22, 'major': 'Computer Science'}
print(list(student.keys()))
print(list(student.values()))
print(list(student.items()))

['name', 'age', 'major']
['Alice', 22, 'Computer Science']
[('name', 'Alice'), ('age', 22), ('major', 'Computer Science')]

Python dictionaries provide three essential view methods that let you examine their contents in different ways. The keys() method returns all dictionary keys in a list-like format, while values() gives you just the stored values. For a complete picture, items() returns key-value pairs as tuples.

• student.keys() outputs ['name', 'age', 'major']. This view updates automatically when you modify the dictionary
• student.values() shows ['Alice', 22, 'Computer Science']. It's useful when you need to process values independently
• student.items() creates pairs like ('name', 'Alice'). This format works perfectly with Python's for loops for iteration

Converting these views to lists with the list() function creates a static snapshot of the dictionary's current state. This proves helpful when you need to store or manipulate the data separately.

Working with nested dictionaries

person = {
    'name': 'Bob',
    'address': {
        'city': 'New York',
        'zip': 10001
    }
}
print(person['address']['city'])
print(f"{person['name']} lives in {person['address']['city']}")

New York
Bob lives in New York

Nested dictionaries embed one dictionary inside another, creating hierarchical data structures. The example shows a person dictionary containing both direct values and a nested address dictionary.

• Access nested values by chaining square brackets: person['address']['city'] first gets the address dictionary, then retrieves 'New York' from it
• This structure helps organize related data logically. Address details stay grouped together while maintaining a clear connection to the person
• String formatting with f-strings makes it easy to combine values from different nesting levels into readable output

Nested dictionaries excel at representing real-world relationships where objects contain other objects. Common examples include user profiles, configuration settings, and JSON data from APIs.

Advanced dictionary techniques

Building on these foundational techniques, Python dictionaries offer powerful features like defaultdict, dictionary comprehensions, and the | operator that streamline data manipulation and error handling.

Dictionary comprehensions for transformation

prices = {'apple': 0.5, 'banana': 0.25, 'orange': 0.75}
doubled_prices = {fruit: price * 2 for fruit, price in prices.items()}
filtered_prices = {k: v for k, v in prices.items() if v > 0.3}
print(doubled_prices)
print(filtered_prices)

{'apple': 1.0, 'banana': 0.5, 'orange': 1.5}
{'apple': 0.5, 'orange': 0.75}

Dictionary comprehensions provide a concise way to create new dictionaries by transforming or filtering existing ones. The syntax mirrors list comprehensions but uses curly braces and requires both a key and value expression.

• The doubled_prices example creates a new dictionary where each fruit's price is multiplied by 2. It maintains the original keys while transforming only the values
• In filtered_prices, the comprehension includes a conditional statement if v > 0.3 that selectively includes only fruits with prices above 30 cents

This approach eliminates the need for explicit loops and temporary variables. You can combine transformations and filtering in a single line while maintaining readable code that clearly expresses your intent.

Using defaultdict to handle missing keys

from collections import defaultdict
fruit_count = defaultdict(int)
fruits = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
for fruit in fruits:
    fruit_count[fruit] += 1
print(dict(fruit_count))

{'apple': 3, 'banana': 2, 'orange': 1}

defaultdict automatically handles missing dictionary keys by creating a default value when you access a non-existent key. In this example, defaultdict(int) initializes new keys with zero, making it perfect for counting occurrences.

• When the code encounters each fruit in the list, fruit_count[fruit] += 1 either increments an existing count or starts from zero for new fruits
• This eliminates the need to check if a key exists before incrementing its value
• The regular dictionary would raise a KeyError on the first attempt to increment a missing key

The final output shows how many times each fruit appears in the list. defaultdict streamlines frequency counting tasks by removing boilerplate key existence checks from your code.

Merging dictionaries with the | operator

user_info = {'name': 'Charlie', 'age': 30}
additional_info = {'job': 'Developer', 'city': 'San Francisco'}
complete_info = user_info | additional_info
print(complete_info)

{'name': 'Charlie', 'age': 30, 'job': 'Developer', 'city': 'San Francisco'}

The | operator, introduced in Python 3.9, combines two dictionaries into a new one. This merge operator creates a fresh dictionary containing all key-value pairs from both sources, with later dictionaries taking precedence for duplicate keys.

• When merging user_info with additional_info, Python creates a new dictionary that preserves the original data structures
• The operation follows left-to-right precedence. Keys from the right dictionary override matching keys from the left
• This syntax offers a cleaner alternative to traditional methods like dict.update() or unpacking with double asterisks

The merged result contains all four key-value pairs, making it ideal for combining user data from different sources or building complete configuration objects.

Get unstuck faster with Claude

Claude is an AI assistant created by Anthropic that excels at helping developers write, debug, and understand Python code. It combines deep technical knowledge with clear, accessible explanations to guide you through programming challenges.

Working alongside you as an AI code mentor, Claude helps you navigate complex dictionary operations, resolve tricky syntax issues, and implement best practices. It can explain concepts like nested dictionaries, suggest optimal data structures, or help you refactor code for better performance.

Start accelerating your Python development today. Sign up for free at Claude.ai to get personalized guidance and move past coding roadblocks faster.

Some real-world applications

Building on the advanced techniques we've explored, Python dictionaries power real-world applications from text analysis to interactive menu systems that streamline development workflows.

Using dictionaries for word frequency analysis

Dictionaries provide an elegant way to track how often words appear in text by using the words as keys and their frequencies as values, enabling efficient text analysis and natural language processing tasks.

text = "the quick brown fox jumps over the lazy dog"
word_count = {}
for word in text.lower().split():
    word_count[word] = word_count.get(word, 0) + 1
print(word_count)
print(f"Most frequent word: {max(word_count, key=word_count.get)}")

This code creates a dictionary to count word occurrences in a text string. The text.lower().split() converts the string to lowercase and breaks it into individual words. For each word, the code uses get() to safely retrieve its current count from the dictionary, defaulting to 0 if the word isn't found yet. It then increments that count by 1.

The final line finds the most frequent word using max() with a key function. The key=word_count.get parameter tells max() to compare words based on their frequency values rather than the words themselves.

• The dictionary stores each unique word as a key
• Values track how many times each word appears
• Using get() prevents errors when encountering new words

Building a data-driven menu system with dict as a command dispatcher

Dictionaries excel as command dispatchers by mapping user inputs directly to functions, enabling clean and maintainable menu-driven interfaces that eliminate complex if-elif chains.

def show_help():
    return "Displaying help information"
    
def process_order():
    return "Processing your order"

commands = {
    'help': show_help,
    'order': process_order
}

user_input = 'help'
result = commands.get(user_input, lambda: "Invalid command")()
print(result)

This code demonstrates a flexible command pattern implementation using a dictionary as a function lookup table. The commands dictionary maps string keys to their corresponding function objects, creating a direct relationship between user inputs and actions.

• The show_help and process_order functions serve as simple command handlers
• When executing commands.get(user_input), Python retrieves the matching function based on the input string
• The lambda: "Invalid command" provides a fallback response for unknown commands

The trailing parentheses () immediately call the retrieved function. This approach scales elegantly as you add more commands. Simply define new functions and add them to the dictionary without modifying the execution logic.

Common errors and challenges

Python dictionaries can trigger subtle errors that impact code reliability when you access keys incorrectly, modify data during loops, or misunderstand object references.

Handling KeyError when accessing non-existent keys

Accessing dictionary keys directly with square bracket notation can trigger a KeyError when the key doesn't exist. This common pitfall affects Python developers who assume a key's presence without verification. The following code demonstrates how this error manifests when trying to access a non-existent phone key.

user_data = {'name': 'John', 'email': 'john@example.com'}
# This will raise a KeyError
phone = user_data['phone']
print(f"User's phone: {phone}")

The code attempts to directly access a dictionary key that doesn't exist in user_data. Since Python can't find a matching 'phone' key, it immediately halts execution with a KeyError. The following code demonstrates a robust solution to this common challenge.

user_data = {'name': 'John', 'email': 'john@example.com'}
# Using get() method with a default value
phone = user_data.get('phone', 'Not provided')
print(f"User's phone: {phone}")

The get() method provides a safer way to access dictionary values by returning a default value when a key doesn't exist. Instead of crashing with a KeyError, the code gracefully handles missing data by returning 'Not provided' as a fallback.

• Watch for this error when working with user input or API responses where data availability is uncertain
• Use get() whenever you're unsure if a key exists in your dictionary
• Consider setting meaningful default values that help debug issues or maintain application flow

This pattern proves especially valuable in production environments where robust error handling prevents application crashes and improves user experience.

Avoiding errors when modifying dictionaries during iteration

Modifying a dictionary while iterating through it can trigger a RuntimeError. Python raises this error to prevent unpredictable behavior when you add or remove dictionary items during a for loop. The code below demonstrates this common pitfall when trying to remove low-scoring students.

scores = {'Alice': 85, 'Bob': 45, 'Charlie': 92, 'Dave': 38}
# This will raise RuntimeError: dictionary changed size during iteration
for name, score in scores.items():
    if score < 50:
        del scores[name]
print(scores)

The for loop attempts to modify the dictionary's structure by deleting entries while Python actively uses that same structure for iteration. This creates an unstable state that Python prevents by raising an error. Let's examine a safer approach in the code below.

scores = {'Alice': 85, 'Bob': 45, 'Charlie': 92, 'Dave': 38}
# Create a new dictionary instead of modifying during iteration
passing_scores = {name: score for name, score in scores.items() if score >= 50}
print(passing_scores)

Dictionary comprehension offers a safer alternative to modifying dictionaries during iteration. Instead of deleting items from the original dictionary, passing_scores creates a new dictionary that includes only the entries meeting our criteria. This approach prevents runtime errors and produces cleaner, more maintainable code.

• Watch for this error when filtering, transforming, or cleaning dictionary data
• Consider using comprehensions or creating a list of keys to remove when you need to modify multiple entries
• Remember that dictionary views reflect live changes. Create a static list of items first if you need to modify the original dictionary

Understanding dictionary reference behavior

Python dictionaries use reference semantics when assigned to new variables. This means simply assigning a dictionary to another variable creates a reference to the same data structure instead of a separate copy. The code below demonstrates how modifying one reference affects all others pointing to the same dictionary.

original = {'name': 'Alice', 'scores': [85, 90, 78]}
duplicate = original  # This doesn't create a new copy
duplicate['name'] = 'Bob'  # Modifies both dictionaries!
print(f"Original: {original}")
print(f"Duplicate: {duplicate}")

When you assign duplicate = original, Python creates a new reference to the same dictionary in memory. Any changes to either variable affect both because they point to identical data. The code below demonstrates how to properly create independent copies.

import copy
original = {'name': 'Alice', 'scores': [85, 90, 78]}
duplicate = copy.deepcopy(original)  # Creates independent copy
duplicate['name'] = 'Bob'  # Only modifies the duplicate
print(f"Original: {original}")
print(f"Duplicate: {duplicate}")

The copy.deepcopy() function creates a completely independent copy of a dictionary and its nested objects. Unlike shallow copying or direct assignment, deep copying ensures that modifying the duplicate won't affect the original data structure. This proves essential when working with complex dictionaries containing nested lists, dictionaries, or custom objects.

• Watch for unexpected changes when multiple parts of your code reference the same dictionary
• Use deepcopy() when you need to create truly independent copies for data processing or state management
• Remember that simple assignment with = only creates a new reference to the same dictionary

This pattern becomes particularly important in larger applications where dictionaries pass between functions or store in data structures. Proper copying prevents subtle bugs from propagating through your system.

Learning or leveling up? Use Claude

Claude combines expert Python knowledge with intuitive teaching abilities to guide you through dictionary challenges and complex data structures. This AI assistant from Anthropic understands your code's context and provides targeted suggestions to improve your implementations.

• Dictionary Debugging: Ask "What's wrong with my dictionary iteration code?" and Claude will identify common pitfalls like modifying dictionaries during loops
• Performance Tips: Ask "How can I make this dictionary lookup faster?" and Claude will suggest optimizations like using get() or defaultdict
• Code Review: Ask "Review my nested dictionary implementation" and Claude will analyze your code's structure, suggesting cleaner approaches
• Best Practices: Ask "What's the safest way to merge these dictionaries?" and Claude will explain modern techniques using the | operator
• Error Prevention: Ask "How do I handle missing dictionary keys?" and Claude will demonstrate robust error handling patterns

Experience personalized coding guidance by signing up for free at Claude.ai.

For a more integrated development experience, Claude Code brings AI assistance directly into your terminal, enabling seamless dictionary operations and code improvements without leaving your development environment.