Python Dictionary Complete Guide: From Basics to Advanced Techniques

Python dictionaries are one of the most powerful and versatile data structures. This comprehensive guide covers everything from basic operations to advanced techniques for efficient data manipulation.

Table of Contents #

Dictionary Fundamentals
Creating and Initializing Dictionaries
Accessing and Modifying Data
Dictionary Methods
Advanced Operations
Performance and Best Practices
Real-World Applications

Dictionary Fundamentals #

Understanding Dictionaries #

Learn the core concepts of Python dictionaries:

🐍 Try it yourself

# Basic dictionary concepts
print("Dictionary Fundamentals:")

# Key-value pairs
student = {
    'name': 'Alice Johnson',
    'age': 22,
    'major': 'Computer Science',
    'gpa': 3.8,
    'enrolled': True
}

print(f"Student dictionary: {student}")
print(f"Type: {type(student)}")
print(f"Number of items: {len(student)}")

# Keys must be immutable
valid_keys = {
    'string_key': 'value1',
    42: 'value2',
    (1, 2): 'value3',
    True: 'value4'
}

print(f"\nValid key types: {valid_keys}")

# Dictionary properties
print(f"\nDictionary properties:")
print(f"- Ordered (Python 3.7+): {list(student.keys())}")
print(f"- Mutable: Can be modified after creation")
print(f"- No duplicate keys: Each key is unique")
print(f"- Values can be any type: {[type(v).__name__ for v in student.values()]}")

# Empty dictionaries
empty_dict1 = {}
empty_dict2 = dict()

print(f"\nEmpty dictionaries:")
print(f"Using {{}}: {empty_dict1}")
print(f"Using dict(): {empty_dict2}")
print(f"Are they equal? {empty_dict1 == empty_dict2}")

Output:

Click "Run Code" to see the output

Dictionary vs Other Data Structures #

Compare dictionaries with other Python data structures:

🐍 Try it yourself

# Comparison with other data structures

# Same data in different structures
data = [
    ('name', 'Alice'),
    ('age', 22),
    ('city', 'New York')
]

# As list of tuples
list_data = data

# As dictionary
dict_data = dict(data)

# As list of lists
list_of_lists = [list(item) for item in data]

print("Data representation comparison:")
print(f"List of tuples: {list_data}")
print(f"Dictionary: {dict_data}")
print(f"List of lists: {list_of_lists}")

# Access time comparison (conceptual)
print(f"\nAccess patterns:")

# Dictionary - O(1) average case
print(f"Dict access 'name': {dict_data['name']}")

# List - O(n) linear search
name_from_list = None
for key, value in list_data:
    if key == 'name':
        name_from_list = value
        break
print(f"List search 'name': {name_from_list}")

# Memory usage demonstration
import sys

# Create larger datasets for comparison
large_data = [(f'key_{i}', i) for i in range(1000)]
large_dict = dict(large_data)
large_list = large_data

print(f"\nMemory usage (1000 items):")
print(f"Dictionary: {sys.getsizeof(large_dict)} bytes")
print(f"List of tuples: {sys.getsizeof(large_list)} bytes")

# Functionality comparison
print(f"\nFunctionality differences:")
print(f"Dict supports key lookup: 'name' in dict_data = {'name' in dict_data}")
print(f"Dict maintains insertion order (Python 3.7+)")
print(f"List maintains insertion order and allows duplicates")
print(f"Dict keys must be immutable, list elements can be any type")

Output:

Click "Run Code" to see the output

Creating and Initializing Dictionaries #

Multiple Creation Methods #

Explore different ways to create dictionaries:

🐍 Try it yourself

# Various dictionary creation methods

# Method 1: Literal syntax
literal_dict = {
    'apple': 'red',
    'banana': 'yellow',
    'grape': 'purple'
}

# Method 2: dict() constructor
constructor_dict = dict(apple='red', banana='yellow', grape='purple')

# Method 3: From list of tuples
tuple_list = [('apple', 'red'), ('banana', 'yellow'), ('grape', 'purple')]
from_tuples = dict(tuple_list)

# Method 4: From zip
keys = ['apple', 'banana', 'grape']
values = ['red', 'yellow', 'purple']
from_zip = dict(zip(keys, values))

# Method 5: Dictionary comprehension
comprehension_dict = {fruit: color for fruit, color in tuple_list}

print("Dictionary creation methods:")
print(f"Literal: {literal_dict}")
print(f"Constructor: {constructor_dict}")
print(f"From tuples: {from_tuples}")
print(f"From zip: {from_zip}")
print(f"Comprehension: {comprehension_dict}")
print(f"All equal? {all(d == literal_dict for d in [constructor_dict, from_tuples, from_zip, comprehension_dict])}")

# Advanced creation techniques

# Method 6: Using dict.fromkeys()
default_dict = dict.fromkeys(['a', 'b', 'c'], 0)
print(f"\nUsing fromkeys(): {default_dict}")

# Method 7: Nested dictionary creation
nested_dict = {
    'fruits': {'apple': 'red', 'banana': 'yellow'},
    'vegetables': {'carrot': 'orange', 'lettuce': 'green'},
    'grains': {'rice': 'white', 'wheat': 'brown'}
}
print(f"Nested dictionary: {nested_dict}")

# Method 8: Dynamic creation with conditions
numbers = range(1, 11)
conditional_dict = {
    num: 'even' if num % 2 == 0 else 'odd' 
    for num in numbers 
    if num % 3 != 0  # Exclude multiples of 3
}
print(f"Conditional creation: {conditional_dict}")

# Method 9: From multiple sources
base_config = {'host': 'localhost', 'port': 8080}
user_config = {'port': 3000, 'debug': True}

# Merge dictionaries (Python 3.9+)
merged_config = base_config | user_config
print(f"Merged config: {merged_config}")

# Alternative merging for older Python versions
merged_alt = {**base_config, **user_config}
print(f"Alternative merge: {merged_alt}")

Output:

Click "Run Code" to see the output

Default Values and Initialization Patterns #

Handle missing keys and initialize with defaults:

🐍 Try it yourself

# Default value patterns
from collections import defaultdict

# Problem: KeyError when accessing missing keys
scores = {'Alice': 85, 'Bob': 92}

try:
    charlie_score = scores['Charlie']  # This will raise KeyError
except KeyError:
    print("KeyError when accessing missing key")

# Solution 1: Using get() method
charlie_score = scores.get('Charlie', 0)  # Returns 0 if not found
print(f"Using get(): Charlie's score = {charlie_score}")

# Solution 2: Using get() with calculation
diana_score = scores.get('Diana', sum(scores.values()) / len(scores))
print(f"Diana's score (default to average): {diana_score:.1f}")

# Solution 3: Using setdefault()
eve_score = scores.setdefault('Eve', 75)  # Adds to dict if not present
print(f"Using setdefault(): {scores}")

# Solution 4: Using defaultdict
score_tracker = defaultdict(int)  # Default value is 0
score_tracker.update(scores)

print(f"\ndefaultdict examples:")
print(f"Frank's score: {score_tracker['Frank']}")  # Automatically creates with 0
print(f"Updated tracker: {dict(score_tracker)}")

# Advanced defaultdict patterns

# Grouping data
students = [
    ('Alice', 'Math'),
    ('Bob', 'Science'),
    ('Alice', 'English'),
    ('Charlie', 'Math'),
    ('Bob', 'Math')
]

# Group by student
student_subjects = defaultdict(list)
for student, subject in students:
    student_subjects[student].append(subject)

print(f"\nGrouped by student: {dict(student_subjects)}")

# Count occurrences
subject_counts = defaultdict(int)
for student, subject in students:
    subject_counts[subject] += 1

print(f"Subject counts: {dict(subject_counts)}")

# Nested defaultdict
grade_book = defaultdict(lambda: defaultdict(list))

# Add grades
grades = [
    ('Alice', 'Math', 85),
    ('Alice', 'Math', 90),
    ('Bob', 'Science', 92),
    ('Alice', 'English', 88)
]

for student, subject, grade in grades:
    grade_book[student][subject].append(grade)

print(f"\nNested grade book:")
for student, subjects in grade_book.items():
    print(f"  {student}:")
    for subject, subject_grades in subjects.items():
        avg = sum(subject_grades) / len(subject_grades)
        print(f"    {subject}: {subject_grades} (avg: {avg:.1f})")

# Custom default factory
def create_person_template():
    return {
        'name': 'Unknown',
        'age': 0,
        'skills': [],
        'active': True
    }

people_db = defaultdict(create_person_template)

# Accessing non-existent person creates template
new_person = people_db['person_1']
print(f"\nNew person template: {new_person}")

# Modify the template
people_db['Alice'] = {
    'name': 'Alice Johnson',
    'age': 28,
    'skills': ['Python', 'JavaScript'],
    'active': True
}

print(f"Alice's record: {people_db['Alice']}")

Output:

Click "Run Code" to see the output

Accessing and Modifying Data #

Safe Access Methods #

Learn various ways to access dictionary data safely:

🐍 Try it yourself

# Dictionary access methods

person = {
    'name': 'John Doe',
    'age': 30,
    'email': 'john@example.com',
    'address': {
        'street': '123 Main St',
        'city': 'New York',
        'zip': '10001'
    },
    'phone_numbers': ['555-1234', '555-5678']
}

print("Dictionary access methods:")

# Direct access (can raise KeyError)
print(f"Name: {person['name']}")

# Safe access with get()
job_title = person.get('job_title', 'Not specified')
print(f"Job title: {job_title}")

# Access nested data safely
def safe_get_nested(dictionary, *keys, default=None):
    """Safely access nested dictionary values"""
    for key in keys:
        if isinstance(dictionary, dict) and key in dictionary:
            dictionary = dictionary[key]
        else:
            return default
    return dictionary

# Test safe nested access
city = safe_get_nested(person, 'address', 'city')
country = safe_get_nested(person, 'address', 'country', default='Unknown')

print(f"City: {city}")
print(f"Country: {country}")

# Multiple value access
keys_to_get = ['name', 'age', 'job_title']
values = [person.get(key, 'N/A') for key in keys_to_get]
result = dict(zip(keys_to_get, values))

print(f"Multiple access: {result}")

# Conditional access with validation
def get_valid_email(data):
    email = data.get('email')
    if email and '@' in email:
        return email
    return None

valid_email = get_valid_email(person)
print(f"Valid email: {valid_email}")

# Access with type checking
def get_typed_value(dictionary, key, expected_type, default=None):
    """Get value with type validation"""
    value = dictionary.get(key, default)
    if isinstance(value, expected_type):
        return value
    return default

age = get_typed_value(person, 'age', int, 0)
phone_numbers = get_typed_value(person, 'phone_numbers', list, [])

print(f"Typed access - Age: {age}, Phone numbers: {phone_numbers}")

Output:

Click "Run Code" to see the output

Modification and Update Operations #

Master different ways to modify dictionary data:

🐍 Try it yourself

# Dictionary modification operations

# Starting with a base dictionary
inventory = {
    'apples': 50,
    'bananas': 30,
    'oranges': 25
}

print(f"Initial inventory: {inventory}")

# Basic modifications

# Add new item
inventory['grapes'] = 40
print(f"After adding grapes: {inventory}")

# Update existing item
inventory['apples'] += 20  # Restock apples
print(f"After restocking apples: {inventory}")

# Conditional update
if inventory.get('bananas', 0) < 50:
    inventory['bananas'] = 50
print(f"After conditional restock: {inventory}")

# Bulk updates

# Method 1: Using update()
new_stock = {'pears': 35, 'apples': 80, 'kiwis': 20}
inventory.update(new_stock)
print(f"After bulk update: {inventory}")

# Method 2: Dictionary unpacking (Python 3.5+)
additional_stock = {'mangoes': 15, 'berries': 25}
inventory = {**inventory, **additional_stock}
print(f"After unpacking update: {inventory}")

# Method 3: Using dictionary union (Python 3.9+)
more_stock = {'coconuts': 10}
inventory = inventory | more_stock
print(f"After union update: {inventory}")

# Complex modifications

# Increment with setdefault
def add_to_inventory(inv, item, quantity):
    inv.setdefault(item, 0)
    inv[item] += quantity

add_to_inventory(inventory, 'lemons', 30)
add_to_inventory(inventory, 'apples', 10)  # Add to existing
print(f"After setdefault additions: {inventory}")

# Batch processing with list of operations
operations = [
    ('add', 'limes', 20),
    ('remove', 'bananas', 10),
    ('set', 'oranges', 40),
    ('add', 'new_fruit', 5)
]

def process_operations(inv, ops):
    for operation, item, value in ops:
        if operation == 'add':
            inv[item] = inv.get(item, 0) + value
        elif operation == 'remove':
            inv[item] = max(0, inv.get(item, 0) - value)
        elif operation == 'set':
            inv[item] = value
        
        # Remove items with zero quantity
        if inv.get(item, 0) == 0:
            inv.pop(item, None)

process_operations(inventory, operations)
print(f"After batch operations: {inventory}")

# Safe deletion methods

# Method 1: Using pop() with default
removed_item = inventory.pop('kiwis', 0)
print(f"Removed kiwis: {removed_item}, Updated inventory: {inventory}")

# Method 2: Using del with existence check
if 'coconuts' in inventory:
    del inventory['coconuts']
    print(f"Deleted coconuts: {inventory}")

# Method 3: Using popitem() (removes last inserted)
if inventory:
    last_item = inventory.popitem()
    print(f"Removed last item {last_item}: {inventory}")

# Atomic operations for concurrent access simulation
import copy

def atomic_update(original_dict, updates):
    """Simulate atomic dictionary update"""
    temp_dict = copy.deepcopy(original_dict)
    try:
        for key, value in updates.items():
            if callable(value):
                # Allow function-based updates
                temp_dict[key] = value(temp_dict.get(key, 0))
            else:
                temp_dict[key] = value
        return temp_dict, True
    except Exception as e:
        print(f"Update failed: {e}")
        return original_dict, False

# Test atomic update
current_inventory = {'apples': 100, 'bananas': 50}

updates = {
    'apples': lambda x: x + 25,  # Add 25 apples
    'bananas': lambda x: x - 10,  # Remove 10 bananas
    'oranges': 30  # Add 30 oranges
}

new_inventory, success = atomic_update(current_inventory, updates)

if success:
    current_inventory = new_inventory
    print(f"Atomic update successful: {current_inventory}")
else:
    print("Atomic update failed, inventory unchanged")

Output:

Click "Run Code" to see the output

Dictionary Methods #

Essential Methods Overview #

Master all important dictionary methods:

🐍 Try it yourself

# Comprehensive dictionary methods demonstration

# Sample data
student_grades = {
    'Alice': 85,
    'Bob': 92,
    'Charlie': 78,
    'Diana': 96,
    'Eve': 88
}

print("Dictionary Methods Demonstration:")
print(f"Original data: {student_grades}")

# 1. keys(), values(), items()
print(f"\nView methods:")
print(f"Keys: {list(student_grades.keys())}")
print(f"Values: {list(student_grades.values())}")
print(f"Items: {list(student_grades.items())}")

# 2. get() with different defaults
print(f"\nget() method:")
print(f"Alice's grade: {student_grades.get('Alice')}")
print(f"Frank's grade: {student_grades.get('Frank', 'Not found')}")
print(f"Grace's grade: {student_grades.get('Grace', 0)}")

# 3. setdefault()
test_dict = student_grades.copy()
frank_grade = test_dict.setdefault('Frank', 75)
print(f"\nsetdefault() - Frank's grade: {frank_grade}")
print(f"Updated dict: {test_dict}")

# 4. update() variations
print(f"\nupdate() method variations:")

# Update with dictionary
test_dict1 = student_grades.copy()
test_dict1.update({'Grace': 82, 'Henry': 79})
print(f"Update with dict: {test_dict1}")

# Update with keyword arguments
test_dict2 = student_grades.copy()
test_dict2.update(Grace=82, Henry=79)
print(f"Update with kwargs: {test_dict2}")

# Update with list of tuples
test_dict3 = student_grades.copy()
test_dict3.update([('Grace', 82), ('Henry', 79)])
print(f"Update with tuples: {test_dict3}")

# 5. pop() and popitem()
test_dict = student_grades.copy()

# pop() with key
removed_grade = test_dict.pop('Charlie', 'Not found')
print(f"\npop() Charlie: {removed_grade}")
print(f"After pop: {test_dict}")

# pop() non-existent key with default
missing_grade = test_dict.pop('Zack', 'Student not found')
print(f"pop() missing student: {missing_grade}")

# popitem() - removes last inserted (Python 3.7+)
if test_dict:
    last_student = test_dict.popitem()
    print(f"popitem(): {last_student}")
    print(f"After popitem: {test_dict}")

# 6. clear()
test_dict = student_grades.copy()
test_dict.clear()
print(f"\nAfter clear(): {test_dict}")

# 7. copy() vs deep copy
import copy

nested_dict = {
    'class_a': {'Alice': 85, 'Bob': 92},
    'class_b': {'Charlie': 78, 'Diana': 96}
}

shallow_copy = nested_dict.copy()
deep_copy = copy.deepcopy(nested_dict)

# Modify original
nested_dict['class_a']['Alice'] = 100

print(f"\nCopy behavior:")
print(f"Original: {nested_dict}")
print(f"Shallow copy: {shallow_copy}")  # Alice changed here too
print(f"Deep copy: {deep_copy}")        # Alice unchanged here

# 8. fromkeys() class method
subjects = ['Math', 'Science', 'English', 'History']
default_grades = dict.fromkeys(subjects, 0)
print(f"\nfromkeys(): {default_grades}")

# Caution with mutable defaults
# WRONG way - all keys share the same list object
wrong_way = dict.fromkeys(['a', 'b', 'c'], [])
wrong_way['a'].append(1)
print(f"Wrong way (shared list): {wrong_way}")

# RIGHT way - use comprehension for mutable defaults
right_way = {key: [] for key in ['a', 'b', 'c']}
right_way['a'].append(1)
print(f"Right way (separate lists): {right_way}")

Output:

Click "Run Code" to see the output

Advanced Method Applications #

Apply dictionary methods to solve real problems:

🐍 Try it yourself

# Advanced dictionary method applications

# 1. Data aggregation and analysis
sales_data = [
    {'product': 'laptop', 'category': 'electronics', 'amount': 1200, 'region': 'north'},
    {'product': 'phone', 'category': 'electronics', 'amount': 800, 'region': 'south'},
    {'product': 'desk', 'category': 'furniture', 'amount': 300, 'region': 'north'},
    {'product': 'laptop', 'category': 'electronics', 'amount': 1200, 'region': 'south'},
    {'product': 'chair', 'category': 'furniture', 'amount': 150, 'region': 'north'}
]

# Aggregate sales by category
def aggregate_by_field(data, group_field, sum_field):
    result = {}
    for record in data:
        key = record[group_field]
        value = record[sum_field]
        result[key] = result.get(key, 0) + value
    return result

category_sales = aggregate_by_field(sales_data, 'category', 'amount')
region_sales = aggregate_by_field(sales_data, 'region', 'amount')

print("Sales Analysis:")
print(f"By category: {category_sales}")
print(f"By region: {region_sales}")

# 2. Dictionary merging strategies
def merge_dictionaries(*dicts, strategy='last_wins'):
    """Merge multiple dictionaries with different strategies"""
    if strategy == 'last_wins':
        result = {}
        for d in dicts:
            result.update(d)
        return result
    
    elif strategy == 'sum_values':
        result = {}
        for d in dicts:
            for key, value in d.items():
                if isinstance(value, (int, float)):
                    result[key] = result.get(key, 0) + value
                else:
                    result[key] = value
        return result
    
    elif strategy == 'collect_all':
        result = {}
        for d in dicts:
            for key, value in d.items():
                result.setdefault(key, []).append(value)
        return result

# Test merging strategies
dict1 = {'a': 10, 'b': 20, 'c': 'hello'}
dict2 = {'a': 5, 'b': 15, 'd': 'world'}
dict3 = {'a': 3, 'e': 25}

print(f"\nMerging strategies:")
print(f"Last wins: {merge_dictionaries(dict1, dict2, dict3, strategy='last_wins')}")
print(f"Sum values: {merge_dictionaries(dict1, dict2, dict3, strategy='sum_values')}")
print(f"Collect all: {merge_dictionaries(dict1, dict2, dict3, strategy='collect_all')}")

# 3. Configuration management
class ConfigManager:
    def __init__(self, defaults=None):
        self.config = defaults.copy() if defaults else {}
        self.history = []
    
    def set(self, key, value):
        old_value = self.config.get(key)
        self.config[key] = value
        self.history.append(('set', key, old_value, value))
    
    def get(self, key, default=None):
        return self.config.get(key, default)
    
    def update_from_dict(self, updates):
        changes = {}
        for key, value in updates.items():
            old_value = self.config.get(key)
            if old_value != value:
                changes[key] = (old_value, value)
                self.config[key] = value
        
        if changes:
            self.history.append(('bulk_update', changes))
    
    def remove(self, key):
        if key in self.config:
            old_value = self.config.pop(key)
            self.history.append(('remove', key, old_value, None))
            return old_value
        return None
    
    def reset_to_defaults(self, defaults):
        old_config = self.config.copy()
        self.config = defaults.copy()
        self.history.append(('reset', old_config, self.config))
    
    def get_history(self):
        return self.history.copy()
    
    def export_config(self):
        return self.config.copy()

# Test configuration manager
default_config = {'host': 'localhost', 'port': 8080, 'debug': False}
config_mgr = ConfigManager(default_config)

print(f"\nConfiguration Management:")
print(f"Initial config: {config_mgr.export_config()}")

config_mgr.set('debug', True)
config_mgr.update_from_dict({'host': '0.0.0.0', 'timeout': 30})
config_mgr.remove('port')

print(f"Final config: {config_mgr.export_config()}")
print(f"Change history: {config_mgr.get_history()}")

# 4. Data transformation and filtering
def transform_dict(data, transformers=None, filters=None):
    """Apply transformations and filters to dictionary"""
    transformers = transformers or {}
    filters = filters or {}
    
    result = {}
    
    for key, value in data.items():
        # Apply filters
        if filters:
            skip = False
            for filter_key, filter_func in filters.items():
                if filter_key == key and not filter_func(value):
                    skip = True
                    break
            if skip:
                continue
        
        # Apply transformations
        if key in transformers:
            value = transformers[key](value)
        
        result[key] = value
    
    return result

# Test transformation
raw_data = {
    'name': '  alice johnson  ',
    'age': '25',
    'salary': '75000.50',
    'active': 'true',
    'score': '-1'  # Invalid score
}

transformers = {
    'name': lambda x: x.strip().title(),
    'age': int,
    'salary': float,
    'active': lambda x: x.lower() == 'true'
}

filters = {
    'score': lambda x: int(x) >= 0  # Only positive scores
}

cleaned_data = transform_dict(raw_data, transformers, filters)
print(f"\nData transformation:")
print(f"Raw: {raw_data}")
print(f"Cleaned: {cleaned_data}")

Output:

Click "Run Code" to see the output

Advanced Operations #

Dictionary Comprehensions and Expressions #

Master advanced dictionary creation patterns:

🐍 Try it yourself

# Advanced dictionary comprehensions

# Basic comprehensions review
numbers = range(1, 11)
squares = {n: n**2 for n in numbers}
print(f"Basic comprehension: {squares}")

# Conditional comprehensions
even_squares = {n: n**2 for n in numbers if n % 2 == 0}
print(f"Conditional: {even_squares}")

# Complex expressions and transformations
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# Word analysis dictionary
word_analysis = {
    word: {
        'length': len(word),
        'vowels': sum(1 for char in word.lower() if char in 'aeiou'),
        'consonants': sum(1 for char in word.lower() if char.isalpha() and char not in 'aeiou'),
        'first_letter': word[0].upper(),
        'last_letter': word[-1].upper()
    }
    for word in words
    if len(word) >= 4  # Only words with 4+ characters
}

print(f"\nWord analysis:")
for word, analysis in word_analysis.items():
    print(f"  {word}: {analysis}")

# Nested comprehensions
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Create coordinate to value mapping
coordinate_map = {
    (row_idx, col_idx): value
    for row_idx, row in enumerate(matrix)
    for col_idx, value in enumerate(row)
}
print(f"\nCoordinate mapping: {coordinate_map}")

# Inverse mapping (value to coordinates)
value_to_coords = {
    value: (row_idx, col_idx)
    for row_idx, row in enumerate(matrix)
    for col_idx, value in enumerate(row)
}
print(f"Value to coordinates: {value_to_coords}")

# Advanced filtering and transformation
student_data = [
    {'name': 'Alice', 'grades': [85, 90, 88], 'year': 2},
    {'name': 'Bob', 'grades': [78, 85, 82], 'year': 3},
    {'name': 'Charlie', 'grades': [92, 89, 95], 'year': 1},
    {'name': 'Diana', 'grades': [96, 94, 98], 'year': 4}
]

# Complex student analysis
student_analysis = {
    student['name']: {
        'average': sum(student['grades']) / len(student['grades']),
        'highest': max(student['grades']),
        'lowest': min(student['grades']),
        'grade_range': max(student['grades']) - min(student['grades']),
        'letter_grade': (
            'A' if sum(student['grades']) / len(student['grades']) >= 90 else
            'B' if sum(student['grades']) / len(student['grades']) >= 80 else
            'C' if sum(student['grades']) / len(student['grades']) >= 70 else
            'D' if sum(student['grades']) / len(student['grades']) >= 60 else
            'F'
        ),
        'class_year': f"Year {student['year']}"
    }
    for student in student_data
    if sum(student['grades']) / len(student['grades']) >= 70  # Only passing students
}

print(f"\nStudent analysis (passing students only):")
for name, analysis in student_analysis.items():
    print(f"  {name}: Avg={analysis['average']:.1f}, "
          f"Grade={analysis['letter_grade']}, "
          f"Range={analysis['grade_range']}")

# Dictionary comprehension with external data
import random

# Generate random employee data
employee_names = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
departments = ['Engineering', 'Marketing', 'Sales', 'HR']

employee_records = {
    name: {
        'id': 1000 + idx,
        'department': random.choice(departments),
        'salary': random.randint(50000, 120000),
        'years_experience': random.randint(1, 15),
        'performance_score': round(random.uniform(3.0, 5.0), 1)
    }
    for idx, name in enumerate(employee_names)
}

# Filter high performers in Engineering
engineering_stars = {
    name: record for name, record in employee_records.items()
    if record['department'] == 'Engineering' and record['performance_score'] >= 4.5
}

print(f"\nEngineering high performers:")
for name, record in engineering_stars.items():
    print(f"  {name}: Score {record['performance_score']}, "
          f"Salary ${record['salary']:,}")

# Group employees by department with statistics
from collections import defaultdict

dept_stats = defaultdict(lambda: {'employees': [], 'total_salary': 0, 'avg_experience': 0})

for name, record in employee_records.items():
    dept = record['department']
    dept_stats[dept]['employees'].append(name)
    dept_stats[dept]['total_salary'] += record['salary']

# Calculate averages
for dept, stats in dept_stats.items():
    emp_count = len(stats['employees'])
    stats['avg_salary'] = stats['total_salary'] / emp_count
    stats['avg_experience'] = sum(
        employee_records[emp]['years_experience'] 
        for emp in stats['employees']
    ) / emp_count

print(f"\nDepartment statistics:")
for dept, stats in dept_stats.items():
    print(f"  {dept}: {len(stats['employees'])} employees, "
          f"Avg salary: ${stats['avg_salary']:,.0f}, "
          f"Avg experience: {stats['avg_experience']:.1f} years")

Output:

Click "Run Code" to see the output

Sorting and Filtering Operations #

Advanced sorting and filtering techniques:

🐍 Try it yourself

# Advanced sorting and filtering operations

# Sample data for demonstrations
products = {
    'laptop': {'price': 1200, 'rating': 4.5, 'stock': 15, 'category': 'electronics'},
    'phone': {'price': 800, 'rating': 4.2, 'stock': 30, 'category': 'electronics'},
    'desk': {'price': 300, 'rating': 4.0, 'stock': 8, 'category': 'furniture'},
    'chair': {'price': 150, 'rating': 4.3, 'stock': 25, 'category': 'furniture'},
    'tablet': {'price': 500, 'rating': 4.1, 'stock': 12, 'category': 'electronics'},
    'bookshelf': {'price': 200, 'rating': 3.9, 'stock': 5, 'category': 'furniture'}
}

print("Product catalog:")
for name, details in products.items():
    print(f"  {name}: ${details['price']}, rating {details['rating']}, stock {details['stock']}")

# 1. Sorting by different criteria

# Sort by price (ascending)
by_price = dict(sorted(products.items(), key=lambda item: item[1]['price']))
print(f"\nSorted by price (low to high):")
for name, details in list(by_price.items())[:3]:
    print(f"  {name}: ${details['price']}")

# Sort by rating (descending)
by_rating = dict(sorted(products.items(), key=lambda item: item[1]['rating'], reverse=True))
print(f"\nSorted by rating (high to low):")
for name, details in list(by_rating.items())[:3]:
    print(f"  {name}: {details['rating']} stars")

# Sort by multiple criteria
by_category_then_price = dict(sorted(
    products.items(),
    key=lambda item: (item[1]['category'], item[1]['price'])
))
print(f"\nSorted by category, then price:")
for name, details in by_category_then_price.items():
    print(f"  {name} ({details['category']}): ${details['price']}")

# 2. Advanced filtering

# Filter by single condition
electronics = {
    name: details for name, details in products.items()
    if details['category'] == 'electronics'
}
print(f"\nElectronics products: {list(electronics.keys())}")

# Filter by multiple conditions
premium_electronics = {
    name: details for name, details in products.items()
    if details['category'] == 'electronics' and details['price'] > 600 and details['rating'] >= 4.2
}
print(f"Premium electronics: {list(premium_electronics.keys())}")

# Filter with complex logic
good_deals = {
    name: details for name, details in products.items()
    if (details['price'] < 400 and details['rating'] >= 4.0) or 
       (details['category'] == 'electronics' and details['stock'] > 20)
}
print(f"Good deals: {list(good_deals.keys())}")

# 3. Custom filtering functions

def filter_products(products, **criteria):
    """Flexible product filtering with multiple criteria"""
    result = {}
    
    for name, details in products.items():
        matches = True
        
        # Price range
        if 'min_price' in criteria and details['price'] < criteria['min_price']:
            matches = False
        if 'max_price' in criteria and details['price'] > criteria['max_price']:
            matches = False
        
        # Rating threshold
        if 'min_rating' in criteria and details['rating'] < criteria['min_rating']:
            matches = False
        
        # Stock availability
        if 'min_stock' in criteria and details['stock'] < criteria['min_stock']:
            matches = False
        
        # Category filter
        if 'categories' in criteria and details['category'] not in criteria['categories']:
            matches = False
        
        # Custom condition function
        if 'condition' in criteria and not criteria['condition'](details):
            matches = False
        
        if matches:
            result[name] = details
    
    return result

# Test custom filtering
filtered_products = filter_products(
    products,
    min_price=200,
    max_price=1000,
    min_rating=4.0,
    categories=['electronics', 'furniture'],
    condition=lambda details: details['stock'] > 10
)

print(f"\nCustom filtered products:")
for name, details in filtered_products.items():
    print(f"  {name}: ${details['price']}, {details['rating']} stars, {details['stock']} in stock")

# 4. Statistical operations

def analyze_products(products):
    """Generate statistical analysis of products"""
    if not products:
        return {}
    
    prices = [details['price'] for details in products.values()]
    ratings = [details['rating'] for details in products.values()]
    stocks = [details['stock'] for details in products.values()]
    
    analysis = {
        'count': len(products),
        'price_stats': {
            'min': min(prices),
            'max': max(prices),
            'avg': sum(prices) / len(prices),
            'median': sorted(prices)[len(prices) // 2]
        },
        'rating_stats': {
            'min': min(ratings),
            'max': max(ratings),
            'avg': sum(ratings) / len(ratings)
        },
        'stock_stats': {
            'min': min(stocks),
            'max': max(stocks),
            'total': sum(stocks),
            'avg': sum(stocks) / len(stocks)
        },
        'category_breakdown': {}
    }
    
    # Category breakdown
    for name, details in products.items():
        category = details['category']
        if category not in analysis['category_breakdown']:
            analysis['category_breakdown'][category] = 0
        analysis['category_breakdown'][category] += 1
    
    return analysis

# Analyze all products
full_analysis = analyze_products(products)
print(f"\nProduct analysis:")
print(f"Total products: {full_analysis['count']}")
print(f"Price range: ${full_analysis['price_stats']['min']} - ${full_analysis['price_stats']['max']}")
print(f"Average price: ${full_analysis['price_stats']['avg']:.2f}")
print(f"Average rating: {full_analysis['rating_stats']['avg']:.2f}")
print(f"Category breakdown: {full_analysis['category_breakdown']}")

# Compare different segments
electronics_analysis = analyze_products(electronics)
furniture = {name: details for name, details in products.items() if details['category'] == 'furniture'}
furniture_analysis = analyze_products(furniture)

print(f"\nComparison:")
print(f"Electronics avg price: ${electronics_analysis['price_stats']['avg']:.2f}")
print(f"Furniture avg price: ${furniture_analysis['price_stats']['avg']:.2f}")
print(f"Electronics avg rating: {electronics_analysis['rating_stats']['avg']:.2f}")
print(f"Furniture avg rating: {furniture_analysis['rating_stats']['avg']:.2f}")

Output:

Click "Run Code" to see the output

Performance and Best Practices #

Performance Optimization Techniques #

Optimize dictionary operations for better performance:

🐍 Try it yourself

import time
import sys
from collections import defaultdict, Counter

# Performance comparison framework
def time_operation(operation, *args, **kwargs):
    start_time = time.perf_counter()
    result = operation(*args, **kwargs)
    end_time = time.perf_counter()
    return result, end_time - start_time

# 1. Dictionary creation performance
def test_creation_performance():
    size = 10000
    keys = [f"key_{i}" for i in range(size)]
    values = list(range(size))
    
    # Method 1: Dict comprehension
    def dict_comprehension():
        return {key: value for key, value in zip(keys, values)}
    
    # Method 2: dict() constructor
    def dict_constructor():
        return dict(zip(keys, values))
    
    # Method 3: Manual loop
    def manual_loop():
        result = {}
        for key, value in zip(keys, values):
            result[key] = value
        return result
    
    # Method 4: Update method
    def update_method():
        result = {}
        result.update(zip(keys, values))
        return result
    
    methods = [
        ("Dict comprehension", dict_comprehension),
        ("Dict constructor", dict_constructor),
        ("Manual loop", manual_loop),
        ("Update method", update_method)
    ]
    
    print("Dictionary creation performance (10,000 items):")
    for name, method in methods:
        _, duration = time_operation(method)
        print(f"  {name}: {duration:.6f} seconds")

test_creation_performance()

# 2. Lookup performance comparison
def test_lookup_performance():
    size = 100000
    test_dict = {f"key_{i}": i for i in range(size)}
    lookup_keys = [f"key_{i}" for i in range(0, size, 100)]  # Every 100th key
    
    # Method 1: Direct access with exception handling
    def direct_access():
        results = []
        for key in lookup_keys:
            try:
                results.append(test_dict[key])
            except KeyError:
                results.append(None)
        return results
    
    # Method 2: Using get() method
    def get_method():
        return [test_dict.get(key) for key in lookup_keys]
    
    # Method 3: Using in operator first
    def check_then_access():
        results = []
        for key in lookup_keys:
            if key in test_dict:
                results.append(test_dict[key])
            else:
                results.append(None)
        return results
    
    methods = [
        ("Direct access", direct_access),
        ("Get method", get_method),
        ("Check then access", check_then_access)
    ]
    
    print(f"\nLookup performance (1,000 lookups in {size:,} items):")
    for name, method in methods:
        _, duration = time_operation(method)
        print(f"  {name}: {duration:.6f} seconds")

test_lookup_performance()

# 3. Memory usage optimization
def test_memory_usage():
    # Regular dictionary vs __slots__ class
    class RegularPerson:
        def __init__(self, name, age, city):
            self.name = name
            self.age = age
            self.city = city
    
    class SlottedPerson:
        __slots__ = ['name', 'age', 'city']
        
        def __init__(self, name, age, city):
            self.name = name
            self.age = age
            self.city = city
    
    # Create instances
    regular_people = [RegularPerson(f"Person{i}", 20 + i % 50, f"City{i%10}") for i in range(1000)]
    slotted_people = [SlottedPerson(f"Person{i}", 20 + i % 50, f"City{i%10}") for i in range(1000)]
    
    # Dictionary approach
    dict_people = [
        {'name': f"Person{i}", 'age': 20 + i % 50, 'city': f"City{i%10}"}
        for i in range(1000)
    ]
    
    print(f"\nMemory usage comparison (1,000 objects):")
    print(f"Regular classes: {sum(sys.getsizeof(obj.__dict__) for obj in regular_people):,} bytes")
    print(f"Slotted classes: {sum(sys.getsizeof(obj) for obj in slotted_people):,} bytes")
    print(f"Dictionaries: {sum(sys.getsizeof(obj) for obj in dict_people):,} bytes")

test_memory_usage()

# 4. Best practices for dictionary operations

# Efficient counting
def test_counting_methods():
    data = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple'] * 1000
    
    # Method 1: Manual counting
    def manual_count():
        counts = {}
        for item in data:
            counts[item] = counts.get(item, 0) + 1
        return counts
    
    # Method 2: Using setdefault
    def setdefault_count():
        counts = {}
        for item in data:
            counts.setdefault(item, 0)
            counts[item] += 1
        return counts
    
    # Method 3: Using defaultdict
    def defaultdict_count():
        counts = defaultdict(int)
        for item in data:
            counts[item] += 1
        return dict(counts)
    
    # Method 4: Using Counter
    def counter_count():
        return dict(Counter(data))
    
    methods = [
        ("Manual counting", manual_count),
        ("Setdefault method", setdefault_count),
        ("Defaultdict", defaultdict_count),
        ("Counter class", counter_count)
    ]
    
    print(f"\nCounting performance ({len(data):,} items):")
    for name, method in methods:
        _, duration = time_operation(method)
        print(f"  {name}: {duration:.6f} seconds")

test_counting_methods()

# 5. Dictionary comprehension vs alternatives
def test_comprehension_performance():
    data = list(range(10000))
    
    # Method 1: Dictionary comprehension
    def dict_comp():
        return {x: x**2 for x in data if x % 2 == 0}
    
    # Method 2: Traditional loop
    def traditional_loop():
        result = {}
        for x in data:
            if x % 2 == 0:
                result[x] = x**2
        return result
    
    # Method 3: Filter + dict comprehension
    def filter_comp():
        filtered_data = filter(lambda x: x % 2 == 0, data)
        return {x: x**2 for x in filtered_data}
    
    methods = [
        ("Dict comprehension", dict_comp),
        ("Traditional loop", traditional_loop),
        ("Filter + comprehension", filter_comp)
    ]
    
    print(f"\nComprehension performance (10,000 items):")
    for name, method in methods:
        _, duration = time_operation(method)
        print(f"  {name}: {duration:.6f} seconds")

test_comprehension_performance()

# Performance best practices summary
print(f"\nPerformance Best Practices:")
print("1. Use dict.get() instead of try/except for optional lookups")
print("2. Use dictionary comprehensions for simple transformations")
print("3. Use Counter for frequency counting")
print("4. Use defaultdict to avoid key existence checks")
print("5. Consider __slots__ for memory-critical applications")
print("6. Use dict() constructor for zip() results")
print("7. Prefer 'in' operator over keys() for membership testing")

Output:

Click "Run Code" to see the output

Memory Management and Best Practices #

Essential guidelines for efficient dictionary usage:

🐍 Try it yourself

# Dictionary best practices and common pitfalls

print("Dictionary Best Practices and Common Pitfalls:")

# 1. Avoid mutable default arguments
def bad_function(data, cache={}):  # DON'T DO THIS
    """Bad: mutable default argument"""
    if 'result' not in cache:
        cache['result'] = sum(data)
    return cache['result']

def good_function(data, cache=None):  # DO THIS
    """Good: create new dict if needed"""
    if cache is None:
        cache = {}
    if 'result' not in cache:
        cache['result'] = sum(data)
    return cache['result']

# Demonstrate the problem
result1 = bad_function([1, 2, 3])
result2 = bad_function([4, 5, 6])  # Uses same cache!

print(f"Bad function results: {result1}, {result2}")

result3 = good_function([1, 2, 3])
result4 = good_function([4, 5, 6])

print(f"Good function results: {result3}, {result4}")

# 2. Efficient key existence checking
test_dict = {'a': 1, 'b': 2, 'c': 3}

# Less efficient ways
def check_inefficient(key):
    return key in test_dict.keys()  # Don't do this

def check_very_inefficient(key):
    return key in list(test_dict.keys())  # Definitely don't do this

# Efficient way
def check_efficient(key):
    return key in test_dict  # Do this

print(f"\nKey existence checking:")
print(f"Efficient check for 'a': {check_efficient('a')}")
print(f"Efficient check for 'z': {check_efficient('z')}")

# 3. Safe dictionary operations
def safe_dict_access():
    """Demonstrate safe dictionary access patterns"""
    
    user_data = {
        'name': 'John Doe',
        'email': 'john@example.com',
        'preferences': {
            'theme': 'dark',
            'notifications': True
        }
    }
    
    # Safe access to nested data
    def get_nested_value(data, *keys, default=None):
        """Safely get nested dictionary value"""
        current = data
        for key in keys:
            if isinstance(current, dict) and key in current:
                current = current[key]
            else:
                return default
        return current
    
    # Test safe access
    theme = get_nested_value(user_data, 'preferences', 'theme')
    language = get_nested_value(user_data, 'preferences', 'language', default='en')
    invalid = get_nested_value(user_data, 'settings', 'advanced', 'feature')
    
    print(f"\nSafe nested access:")
    print(f"Theme: {theme}")
    print(f"Language: {language}")
    print(f"Invalid path: {invalid}")
    
    return user_data

safe_dict_access()

# 4. Memory-efficient data structures
def demonstrate_memory_efficiency():
    """Show memory-efficient alternatives"""
    
    # For large datasets with repeated structure
    import sys
    from collections import namedtuple
    
    # Traditional approach
    traditional_records = [
        {'id': i, 'name': f'Person_{i}', 'score': i * 10}
        for i in range(1000)
    ]
    
    # Named tuple approach (more memory efficient)
    Record = namedtuple('Record', ['id', 'name', 'score'])
    namedtuple_records = [
        Record(i, f'Person_{i}', i * 10)
        for i in range(1000)
    ]
    
    # Calculate memory usage
    dict_memory = sum(sys.getsizeof(record) for record in traditional_records)
    tuple_memory = sum(sys.getsizeof(record) for record in namedtuple_records)
    
    print(f"\nMemory efficiency comparison (1000 records):")
    print(f"Traditional dicts: {dict_memory:,} bytes")
    print(f"Named tuples: {tuple_memory:,} bytes")
    print(f"Memory savings: {(dict_memory - tuple_memory) / dict_memory * 100:.1f}%")

demonstrate_memory_efficiency()

# 5. Common anti-patterns and fixes
def demonstrate_antipatterns():
    """Show common anti-patterns and better alternatives"""
    
    data = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
    
    # Anti-pattern 1: Deleting while iterating
    print(f"\nAnti-pattern demonstrations:")
    
    # DON'T DO THIS
    # for key in data:
    #     if data[key] % 2 == 0:
    #         del data[key]  # RuntimeError!
    
    # DO THIS INSTEAD
    test_data = data.copy()
    keys_to_delete = [key for key, value in test_data.items() if value % 2 == 0]
    for key in keys_to_delete:
        del test_data[key]
    
    print(f"After removing even values: {test_data}")
    
    # Anti-pattern 2: Inefficient value updates
    counter = {}
    items = ['a', 'b', 'a', 'c', 'b', 'a']
    
    # Less efficient
    for item in items:
        if item in counter:
            counter[item] += 1
        else:
            counter[item] = 1
    
    # More efficient
    from collections import defaultdict
    efficient_counter = defaultdict(int)
    for item in items:
        efficient_counter[item] += 1
    
    print(f"Counting result: {dict(efficient_counter)}")
    
    # Anti-pattern 3: Converting to list unnecessarily
    sample_dict = {'x': 1, 'y': 2, 'z': 3}
    
    # Don't do this
    # keys_list = list(sample_dict.keys())
    # for key in keys_list:
    #     print(key)
    
    # Do this instead
    for key in sample_dict:
        print(f"Processing key: {key}")

demonstrate_antipatterns()

# 6. Best practices checklist
print(f"\nDictionary Best Practices Checklist:")

best_practices = [
    "✓ Use 'key in dict' instead of 'key in dict.keys()'",
    "✓ Use dict.get() for optional values with defaults",
    "✓ Use dict.setdefault() for initialization",
    "✓ Use defaultdict for automatic default values",
    "✓ Use Counter for frequency counting",
    "✓ Avoid mutable default arguments",
    "✓ Don't modify dict while iterating",
    "✓ Use comprehensions for simple transformations",
    "✓ Consider namedtuple for repeated structures",
    "✓ Use try/except only for truly exceptional cases",
    "✓ Profile memory usage for large datasets",
    "✓ Use appropriate data structures for your use case"
]

for practice in best_practices:
    print(f"  {practice}")

# 7. Performance monitoring
def monitor_dict_performance():
    """Simple performance monitoring for dictionary operations"""
    import time
    
    class DictPerformanceMonitor:
        def __init__(self):
            self.stats = {
                'get_operations': 0,
                'set_operations': 0,
                'total_time': 0
            }
        
        def timed_get(self, dictionary, key, default=None):
            start = time.perf_counter()
            result = dictionary.get(key, default)
            end = time.perf_counter()
            
            self.stats['get_operations'] += 1
            self.stats['total_time'] += (end - start)
            return result
        
        def timed_set(self, dictionary, key, value):
            start = time.perf_counter()
            dictionary[key] = value
            end = time.perf_counter()
            
            self.stats['set_operations'] += 1
            self.stats['total_time'] += (end - start)
        
        def get_stats(self):
            return self.stats.copy()
    
    # Example usage
    monitor = DictPerformanceMonitor()
    test_dict = {}
    
    # Perform some operations
    for i in range(100):
        monitor.timed_set(test_dict, f'key_{i}', i)
        monitor.timed_get(test_dict, f'key_{i//2}')
    
    stats = monitor.get_stats()
    print(f"\nPerformance monitoring results:")
    print(f"Get operations: {stats['get_operations']}")
    print(f"Set operations: {stats['set_operations']}")
    print(f"Total time: {stats['total_time']:.6f} seconds")
    print(f"Average time per operation: {stats['total_time']/(stats['get_operations']+stats['set_operations']):.8f} seconds")

monitor_dict_performance()

Output:

Click "Run Code" to see the output

Real-World Applications #

Data Processing and Analysis #

Apply dictionaries to real-world data processing tasks:

🐍 Try it yourself

# Real-world dictionary applications

# 1. Web Analytics Data Processing
def process_web_analytics():
    """Process web analytics data using dictionaries"""
    
    # Simulated web log data
    web_logs = [
        {'ip': '192.168.1.1', 'url': '/home', 'method': 'GET', 'status': 200, 'size': 1024, 'timestamp': '2024-01-01 10:00:00'},
        {'ip': '192.168.1.2', 'url': '/api/users', 'method': 'POST', 'status': 201, 'size': 512, 'timestamp': '2024-01-01 10:01:00'},
        {'ip': '192.168.1.1', 'url': '/products', 'method': 'GET', 'status': 200, 'size': 2048, 'timestamp': '2024-01-01 10:02:00'},
        {'ip': '192.168.1.3', 'url': '/login', 'method': 'POST', 'status': 401, 'size': 256, 'timestamp': '2024-01-01 10:03:00'},
        {'ip': '192.168.1.2', 'url': '/home', 'method': 'GET', 'status': 200, 'size': 1024, 'timestamp': '2024-01-01 10:04:00'},
        {'ip': '192.168.1.1', 'url': '/checkout', 'method': 'POST', 'status': 500, 'size': 128, 'timestamp': '2024-01-01 10:05:00'}
    ]
    
    # Analytics processing
    analytics = {
        'unique_ips': set(),
        'status_counts': {},
        'method_counts': {},
        'url_popularity': {},
        'error_rate': 0,
        'total_bandwidth': 0,
        'ip_activity': {}
    }
    
    for log in web_logs:
        # Track unique IPs
        analytics['unique_ips'].add(log['ip'])
        
        # Count status codes
        status = log['status']
        analytics['status_counts'][status] = analytics['status_counts'].get(status, 0) + 1
        
        # Count HTTP methods
        method = log['method']
        analytics['method_counts'][method] = analytics['method_counts'].get(method, 0) + 1
        
        # Track URL popularity
        url = log['url']
        analytics['url_popularity'][url] = analytics['url_popularity'].get(url, 0) + 1
        
        # Calculate bandwidth
        analytics['total_bandwidth'] += log['size']
        
        # Track IP activity
        ip = log['ip']
        if ip not in analytics['ip_activity']:
            analytics['ip_activity'][ip] = {'requests': 0, 'total_size': 0, 'methods': set()}
        
        analytics['ip_activity'][ip]['requests'] += 1
        analytics['ip_activity'][ip]['total_size'] += log['size']
        analytics['ip_activity'][ip]['methods'].add(method)
    
    # Calculate error rate
    total_requests = len(web_logs)
    error_requests = sum(count for status, count in analytics['status_counts'].items() if status >= 400)
    analytics['error_rate'] = (error_requests / total_requests) * 100 if total_requests > 0 else 0
    
    # Convert sets to counts for display
    analytics['unique_ip_count'] = len(analytics['unique_ips'])
    del analytics['unique_ips']  # Remove set for cleaner display
    
    print("Web Analytics Results:")
    print(f"Total requests: {total_requests}")
    print(f"Unique IPs: {analytics['unique_ip_count']}")
    print(f"Error rate: {analytics['error_rate']:.1f}%")
    print(f"Total bandwidth: {analytics['total_bandwidth']:,} bytes")
    
    print(f"\nStatus code distribution:")
    for status, count in sorted(analytics['status_counts'].items()):
        print(f"  {status}: {count} requests")
    
    print(f"\nMost popular URLs:")
    sorted_urls = sorted(analytics['url_popularity'].items(), key=lambda x: x[1], reverse=True)
    for url, count in sorted_urls[:3]:
        print(f"  {url}: {count} requests")
    
    print(f"\nIP activity summary:")
    for ip, activity in analytics['ip_activity'].items():
        methods_str = ', '.join(activity['methods'])
        print(f"  {ip}: {activity['requests']} requests, {activity['total_size']} bytes, methods: {methods_str}")
    
    return analytics

process_web_analytics()

# 2. E-commerce Order Processing
def process_ecommerce_orders():
    """Process e-commerce orders with complex business logic"""
    
    # Sample order data
    orders = [
        {
            'order_id': 'ORD001',
            'customer_id': 'CUST001',
            'items': [
                {'product': 'laptop', 'quantity': 1, 'price': 1200},
                {'product': 'mouse', 'quantity': 2, 'price': 25}
            ],
            'shipping': 'express',
            'discount_code': 'SAVE10'
        },
        {
            'order_id': 'ORD002',
            'customer_id': 'CUST002',
            'items': [
                {'product': 'phone', 'quantity': 1, 'price': 800}
            ],
            'shipping': 'standard',
            'discount_code': None
        },
        {
            'order_id': 'ORD003',
            'customer_id': 'CUST001',
            'items': [
                {'product': 'tablet', 'quantity': 1, 'price': 500},
                {'product': 'case', 'quantity': 1, 'price': 30}
            ],
            'shipping': 'express',
            'discount_code': 'WELCOME'
        }
    ]
    
    # Business rules
    shipping_costs = {'standard': 10, 'express': 25}
    discount_codes = {'SAVE10': 0.10, 'WELCOME': 0.15, 'NEWUSER': 0.20}
    
    # Process orders
    processed_orders = {}
    customer_stats = {}
    product_stats = {}
    
    for order in orders:
        order_id = order['order_id']
        customer_id = order['customer_id']
        
        # Calculate order totals
        subtotal = sum(item['quantity'] * item['price'] for item in order['items'])
        
        # Apply discount
        discount_rate = discount_codes.get(order['discount_code'], 0)
        discount_amount = subtotal * discount_rate
        
        # Add shipping
        shipping_cost = shipping_costs.get(order['shipping'], 0)
        
        # Calculate final total
        total = subtotal - discount_amount + shipping_cost
        
        # Store processed order
        processed_orders[order_id] = {
            'customer_id': customer_id,
            'subtotal': subtotal,
            'discount_amount': discount_amount,
            'shipping_cost': shipping_cost,
            'total': total,
            'item_count': sum(item['quantity'] for item in order['items']),
            'unique_products': len(order['items'])
        }
        
        # Update customer statistics
        if customer_id not in customer_stats:
            customer_stats[customer_id] = {
                'order_count': 0,
                'total_spent': 0,
                'average_order_value': 0,
                'favorite_shipping': {}
            }
        
        customer_stats[customer_id]['order_count'] += 1
        customer_stats[customer_id]['total_spent'] += total
        customer_stats[customer_id]['average_order_value'] = (
            customer_stats[customer_id]['total_spent'] / customer_stats[customer_id]['order_count']
        )
        
        # Track shipping preferences
        shipping_method = order['shipping']
        customer_stats[customer_id]['favorite_shipping'][shipping_method] = (
            customer_stats[customer_id]['favorite_shipping'].get(shipping_method, 0) + 1
        )
        
        # Update product statistics
        for item in order['items']:
            product = item['product']
            if product not in product_stats:
                product_stats[product] = {
                    'total_quantity': 0,
                    'total_revenue': 0,
                    'order_count': 0,
                    'average_price': 0
                }
            
            product_stats[product]['total_quantity'] += item['quantity']
            product_stats[product]['total_revenue'] += item['quantity'] * item['price']
            product_stats[product]['order_count'] += 1
            product_stats[product]['average_price'] = (
                product_stats[product]['total_revenue'] / product_stats[product]['total_quantity']
            )
    
    # Display results
    print(f"\nE-commerce Order Processing Results:")
    print(f"Total orders processed: {len(processed_orders)}")
    
    total_revenue = sum(order['total'] for order in processed_orders.values())
    print(f"Total revenue: ${total_revenue:.2f}")
    
    print(f"\nCustomer Analysis:")
    for customer_id, stats in customer_stats.items():
        favorite_shipping = max(stats['favorite_shipping'].items(), key=lambda x: x[1])[0]
        print(f"  {customer_id}: {stats['order_count']} orders, "
              f"${stats['total_spent']:.2f} total, "
              f"${stats['average_order_value']:.2f} avg, "
              f"prefers {favorite_shipping}")
    
    print(f"\nProduct Performance:")
    sorted_products = sorted(product_stats.items(), key=lambda x: x[1]['total_revenue'], reverse=True)
    for product, stats in sorted_products:
        print(f"  {product}: {stats['total_quantity']} sold, "
              f"${stats['total_revenue']:.2f} revenue, "
              f"${stats['average_price']:.2f} avg price")
    
    return processed_orders, customer_stats, product_stats

process_ecommerce_orders()

# 3. Configuration Management System
def configuration_management():
    """Advanced configuration management using nested dictionaries"""
    
    # Multi-environment configuration
    configurations = {
        'development': {
            'database': {
                'host': 'localhost',
                'port': 5432,
                'name': 'dev_db',
                'user': 'dev_user',
                'password': 'dev_pass'
            },
            'api': {
                'host': '0.0.0.0',
                'port': 8000,
                'debug': True,
                'workers': 1
            },
            'cache': {
                'type': 'memory',
                'ttl': 300
            },
            'logging': {
                'level': 'DEBUG',
                'format': 'detailed'
            }
        },
        'production': {
            'database': {
                'host': 'prod-db.example.com',
                'port': 5432,
                'name': 'prod_db',
                'user': 'prod_user',
                'password': '${DB_PASSWORD}'  # Environment variable
            },
            'api': {
                'host': '0.0.0.0',
                'port': 80,
                'debug': False,
                'workers': 8
            },
            'cache': {
                'type': 'redis',
                'host': 'redis.example.com',
                'port': 6379,
                'ttl': 3600
            },
            'logging': {
                'level': 'INFO',
                'format': 'json'
            }
        }
    }
    
    def get_config(env='development', section=None):
        """Get configuration for specific environment and section"""
        config = configurations.get(env, {})
        
        if section:
            return config.get(section, {})
        return config
    
    def merge_configs(base_config, override_config):
        """Recursively merge configuration dictionaries"""
        merged = base_config.copy()
        
        for key, value in override_config.items():
            if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
                merged[key] = merge_configs(merged[key], value)
            else:
                merged[key] = value
        
        return merged
    
    def validate_config(config, required_fields):
        """Validate that configuration contains required fields"""
        missing_fields = []
        
        for field_path in required_fields:
            keys = field_path.split('.')
            current = config
            
            for key in keys:
                if isinstance(current, dict) and key in current:
                    current = current[key]
                else:
                    missing_fields.append(field_path)
                    break
        
        return missing_fields
    
    # Configuration management examples
    print(f"\nConfiguration Management Examples:")
    
    # Get database config for different environments
    dev_db = get_config('development', 'database')
    prod_db = get_config('production', 'database')
    
    print(f"Development DB: {dev_db}")
    print(f"Production DB: {prod_db}")
    
    # Merge configurations (e.g., override production with local settings)
    local_overrides = {
        'api': {'port': 8080, 'debug': True},
        'logging': {'level': 'DEBUG'}
    }
    
    modified_prod = merge_configs(get_config('production'), local_overrides)
    print(f"\nProduction with local overrides:")
    print(f"API config: {modified_prod['api']}")
    print(f"Logging config: {modified_prod['logging']}")
    
    # Validate configuration
    required_fields = [
        'database.host',
        'database.port',
        'api.host',
        'api.port',
        'logging.level'
    ]
    
    missing_dev = validate_config(get_config('development'), required_fields)
    missing_prod = validate_config(get_config('production'), required_fields)
    
    print(f"\nConfiguration validation:")
    print(f"Development missing fields: {missing_dev}")
    print(f"Production missing fields: {missing_prod}")
    
    return configurations

configuration_management()

Output:

Click "Run Code" to see the output

Conclusion #

Python dictionaries are incredibly versatile and powerful data structures that form the backbone of many Python applications. This comprehensive guide has covered:

Key Takeaways #

Fundamentals: Dictionaries are mutable, ordered (Python 3.7+), key-value mappings with O(1) average lookup time
Creation Methods: Multiple ways to create and initialize dictionaries for different use cases
Safe Access: Use .get(), .setdefault(), and proper error handling for robust code
Advanced Operations: Comprehensions, sorting, filtering, and complex data transformations
Performance: Choose appropriate methods and data structures for optimal performance
Best Practices: Follow established patterns to write maintainable and efficient code
Real-World Applications: Apply dictionary skills to data processing, analytics, and system design

When to Use Dictionaries #

✅ Fast lookups by key
✅ Mapping relationships between data
✅ Caching and memoization
✅ Configuration management
✅ Data aggregation and counting
✅ JSON-like data structures

Performance Considerations #

Use appropriate access methods (.get() vs direct access)
Consider memory usage for large datasets
Choose the right data structure for your specific needs
Profile and measure performance in real applications

Master these dictionary concepts and techniques to write more efficient, readable, and maintainable Python code!