Python Dictionaries: The Key-Value Pairs That'll Change How You Store Data

 1# Creating dictionaries - it's this intuitive
 2student = {
 3    'name': 'Alice Johnson',
 4    'age': 22,
 5    'major': 'Computer Science',
 6    'gpa': 3.8
 7}
 8
 9prices = {
10    'coffee': 4.50,
11    'sandwich': 8.75,
12    'cookie': 2.25
13}
14
15empty_dict = {}
16
17print("Student info:", student)
18print("Menu prices:", prices)
19print("Empty dictionary:", empty_dict)

 1def demonstrate_dictionary_creation():
 2    """Show different ways to create dictionaries in Python."""
 3    
 4    # Method 1: Direct creation with curly braces
 5    colors = {'red': '#FF0000', 'green': '#00FF00', 'blue': '#0000FF'}
 6    print(f"Direct creation: {colors}")
 7    
 8    # Method 2: Using the dict() constructor
 9    coordinates = dict(x=10, y=20, z=5)
10    print(f"With dict(): {coordinates}")
11    
12    # Method 3: From lists of tuples
13    pairs = [('apple', 5), ('banana', 3), ('orange', 8)]
14    fruit_count = dict(pairs)
15    print(f"From tuples: {fruit_count}")
16    
17    # Method 4: Dictionary comprehension
18    squares = {x: x**2 for x in range(5)}
19    print(f"Dict comprehension: {squares}")
20    
21    # Method 5: Using dict.fromkeys() for default values
22    default_scores = dict.fromkeys(['alice', 'bob', 'charlie'], 0)
23    print(f"Default values: {default_scores}")
24    
25    # Method 6: Converting from other mappings
26    original = {'a': 1, 'b': 2}
27    copy_dict = dict(original)
28    print(f"From another dict: {copy_dict}")
29    
30    # Method 7: Zip two lists together
31    keys = ['name', 'age', 'city']
32    values = ['John', 30, 'Boston']
33    person = dict(zip(keys, values))
34    print(f"Zipped together: {person}")
35
36demonstrate_dictionary_creation()

 1def demonstrate_dictionary_access():
 2    """Show how to access values in dictionaries."""
 3    
 4    movie = {
 5        'title': 'The Matrix',
 6        'year': 1999,
 7        'director': 'Wachowski Sisters',
 8        'rating': 8.7,
 9        'genres': ['Action', 'Sci-Fi']
10    }
11    
12    print(f"Movie data: {movie}")
13    print()
14    
15    # Direct access with square brackets
16    print("=== Direct Access ===")
17    print(f"Title: {movie['title']}")
18    print(f"Year: {movie['year']}")
19    print(f"Rating: {movie['rating']}")
20    print()
21    
22    # Safe access with get() method
23    print("=== Safe Access with get() ===")
24    director = movie.get('director', 'Unknown')
25    budget = movie.get('budget', 'Not available')
26    print(f"Director: {director}")
27    print(f"Budget: {budget}")  # Key doesn't exist, returns default
28    print()
29    
30    # Check if key exists before accessing
31    print("=== Checking for Keys ===")
32    if 'genres' in movie:
33        print(f"Genres: {movie['genres']}")
34    
35    if 'sequel' not in movie:
36        print("No sequel information available")
37    
38    # Get all keys, values, or items
39    print("\n=== Dictionary Views ===")
40    print(f"All keys: {list(movie.keys())}")
41    print(f"All values: {list(movie.values())}")
42    print(f"All items: {list(movie.items())}")
43    
44    # Dictionary length
45    print(f"\nNumber of fields: {len(movie)}")
46
47demonstrate_dictionary_access()

 1def demonstrate_dictionary_modification():
 2    """Show how to modify dictionaries in various ways."""
 3    
 4    # Start with a simple inventory
 5    inventory = {'apples': 50, 'bananas': 30}
 6    print(f"Initial inventory: {inventory}")
 7    print()
 8    
 9    # Adding new items
10    print("=== Adding Items ===")
11    
12    # Direct assignment
13    inventory['oranges'] = 25
14    print(f"After adding oranges: {inventory}")
15    
16    # Using setdefault() - adds only if key doesn't exist
17    inventory.setdefault('apples', 100)  # Won't change existing value
18    inventory.setdefault('grapes', 40)   # Will add new key
19    print(f"After setdefault: {inventory}")
20    
21    # Update with another dictionary
22    new_items = {'pears': 20, 'berries': 15}
23    inventory.update(new_items)
24    print(f"After update: {inventory}")
25    print()
26    
27    # Modifying existing values
28    print("=== Modifying Values ===")
29    
30    # Direct assignment
31    inventory['apples'] = 45  # Sold 5 apples
32    print(f"After selling apples: {inventory}")
33    
34    # Increment values
35    inventory['bananas'] += 10  # Restocked bananas
36    print(f"After restocking bananas: {inventory}")
37    
38    # Complex modification
39    if 'oranges' in inventory:
40        inventory['oranges'] = max(0, inventory['oranges'] - 30)  # Can't go negative
41    print(f"After selling oranges: {inventory}")
42    print()
43    
44    # Removing items
45    print("=== Removing Items ===")
46    
47    # pop() removes and returns value
48    sold_grapes = inventory.pop('grapes', 0)  # Default if key missing
49    print(f"Sold {sold_grapes} grapes")
50    print(f"After selling grapes: {inventory}")
51    
52    # popitem() removes and returns arbitrary key-value pair
53    item, count = inventory.popitem()
54    print(f"Removed {item}: {count}")
55    print(f"After popitem: {inventory}")
56    
57    # del statement removes by key
58    if 'pears' in inventory:
59        del inventory['pears']
60        print(f"After deleting pears: {inventory}")
61    
62    # clear() empties the dictionary
63    backup = inventory.copy()
64    inventory.clear()
65    print(f"After clear: {inventory}")
66    print(f"Backup copy: {backup}")
67
68demonstrate_dictionary_modification()

 1def demonstrate_essential_dictionary_methods():
 2    """Show the most useful dictionary methods for beginners."""
 3    
 4    # Sample data to work with
 5    scores = {'Alice': 95, 'Bob': 87, 'Charlie': 92, 'Diana': 88, 'Eve': 90}
 6    print(f"Test scores: {scores}")
 7    print()
 8    
 9    # Navigation and inspection
10    print("=== Navigation and Inspection ===")
11    
12    # Get all keys
13    students = list(scores.keys())
14    print(f"Students: {students}")
15    
16    # Get all values
17    all_scores = list(scores.values())
18    print(f"All scores: {all_scores}")
19    
20    # Get key-value pairs
21    pairs = list(scores.items())
22    print(f"Score pairs: {pairs}")
23    
24    # Find statistics
25    highest_score = max(scores.values())
26    lowest_score = min(scores.values())
27    average_score = sum(scores.values()) / len(scores)
28    
29    print(f"Highest score: {highest_score}")
30    print(f"Lowest score: {lowest_score}")
31    print(f"Average score: {average_score:.1f}")
32    print()
33    
34    # Searching and filtering
35    print("=== Searching and Filtering ===")
36    
37    # Find who got the highest score
38    top_student = max(scores, key=scores.get)
39    print(f"Top student: {top_student} with {scores[top_student]}")
40    
41    # Find students above average
42    above_average = {name: score for name, score in scores.items() 
43                    if score > average_score}
44    print(f"Above average: {above_average}")
45    
46    # Count scores in ranges
47    a_grades = len([score for score in scores.values() if score >= 90])
48    b_grades = len([score for score in scores.values() if 80 <= score < 90])
49    print(f"A grades (90+): {a_grades}")
50    print(f"B grades (80-89): {b_grades}")
51    print()
52    
53    # Merging and copying
54    print("=== Merging and Copying ===")
55    
56    # Create new scores
57    new_students = {'Frank': 85, 'Grace': 93}
58    
59    # Merge dictionaries (Python 3.9+)
60    all_scores = scores | new_students
61    print(f"Merged scores: {all_scores}")
62    
63    # Alternative merging for older Python
64    combined = scores.copy()
65    combined.update(new_students)
66    print(f"Combined scores: {combined}")
67    
68    # Shallow vs deep copy demonstration
69    nested_data = {'class_a': {'Alice': 95, 'Bob': 87}, 'class_b': {'Charlie': 92}}
70    shallow_copy = nested_data.copy()
71    
72    # Modifying nested data affects shallow copy
73    nested_data['class_a']['Alice'] = 98
74    print(f"Original after change: {nested_data}")
75    print(f"Shallow copy after change: {shallow_copy}")
76    
77    # Deep copy solution
78    import copy
79    nested_original = {'class_a': {'Alice': 95, 'Bob': 87}}
80    deep_copy = copy.deepcopy(nested_original)
81    nested_original['class_a']['Alice'] = 98
82    print(f"Original: {nested_original}")
83    print(f"Deep copy: {deep_copy}")
84
85demonstrate_essential_dictionary_methods()

 1def demonstrate_dictionary_iteration():
 2    """Show different ways to iterate through dictionaries."""
 3    
 4    # Sample product catalog
 5    products = {
 6        'laptop': {'price': 999, 'stock': 5, 'category': 'electronics'},
 7        'coffee': {'price': 12, 'stock': 50, 'category': 'beverages'},
 8        'notebook': {'price': 3, 'stock': 100, 'category': 'office'},
 9        'headphones': {'price': 199, 'stock': 15, 'category': 'electronics'}
10    }
11    
12    print("=== Basic Iteration Patterns ===")
13    
14    # Iterate over keys (default behavior)
15    print("Product names:")
16    for product in products:
17        print(f"  - {product}")
18    print()
19    
20    # Iterate over keys explicitly
21    print("Product names (explicit keys):")
22    for product in products.keys():
23        print(f"  - {product}")
24    print()
25    
26    # Iterate over values
27    print("Product details:")
28    for details in products.values():
29        print(f"  Price: ${details['price']}, Stock: {details['stock']}")
30    print()
31    
32    # Iterate over key-value pairs (most useful)
33    print("Complete product info:")
34    for name, details in products.items():
35        print(f"  {name}: ${details['price']} ({details['stock']} in stock)")
36    print()
37    
38    print("=== Practical Iteration Examples ===")
39    
40    # Find expensive products
41    expensive_products = []
42    for name, details in products.items():
43        if details['price'] > 100:
44            expensive_products.append(name)
45    print(f"Expensive products (>$100): {expensive_products}")
46    
47    # Calculate total inventory value
48    total_value = 0
49    for name, details in products.items():
50        item_value = details['price'] * details['stock']
51        total_value += item_value
52        print(f"  {name}: ${item_value} (${details['price']} × {details['stock']})")
53    print(f"Total inventory value: ${total_value}")
54    print()
55    
56    # Group by category
57    print("Products by category:")
58    categories = {}
59    for name, details in products.items():
60        category = details['category']
61        if category not in categories:
62            categories[category] = []
63        categories[category].append(name)
64    
65    for category, items in categories.items():
66        print(f"  {category}: {', '.join(items)}")
67    print()
68    
69    # Dictionary comprehension examples
70    print("=== Dictionary Comprehensions ===")
71    
72    # Extract just prices
73    prices = {name: details['price'] for name, details in products.items()}
74    print(f"Prices only: {prices}")
75    
76    # Filter electronics
77    electronics = {name: details for name, details in products.items() 
78                  if details['category'] == 'electronics'}
79    print(f"Electronics: {electronics}")
80    
81    # Apply discount to expensive items
82    discounted = {name: details['price'] * 0.9 if details['price'] > 100 else details['price']
83                 for name, details in products.items()}
84    print(f"Discounted prices: {discounted}")
85
86demonstrate_dictionary_iteration()

  1class ContactManager:
  2    """A simple contact manager using Python dictionaries."""
  3    
  4    def __init__(self):
  5        self.contacts = {}
  6        self.groups = {}
  7    
  8    def add_contact(self, name, email, phone=None, company=None):
  9        """Add a new contact."""
 10        if not name or not email:
 11            print("❌ Name and email are required")
 12            return False
 13        
 14        if name in self.contacts:
 15            print(f"❌ Contact '{name}' already exists")
 16            return False
 17        
 18        contact = {
 19            'email': email,
 20            'phone': phone,
 21            'company': company,
 22            'created': self._get_timestamp(),
 23            'groups': []
 24        }
 25        
 26        self.contacts[name] = contact
 27        print(f"✓ Added contact: {name}")
 28        return True
 29    
 30    def update_contact(self, name, **kwargs):
 31        """Update existing contact information."""
 32        if name not in self.contacts:
 33            print(f"❌ Contact '{name}' not found")
 34            return False
 35        
 36        # Update allowed fields
 37        allowed_fields = ['email', 'phone', 'company']
 38        updated_fields = []
 39        
 40        for field, value in kwargs.items():
 41            if field in allowed_fields:
 42                old_value = self.contacts[name].get(field, 'None')
 43                self.contacts[name][field] = value
 44                updated_fields.append(f"{field}: {old_value} → {value}")
 45        
 46        if updated_fields:
 47            print(f"✓ Updated {name}: {', '.join(updated_fields)}")
 48        else:
 49            print("❌ No valid fields to update")
 50        
 51        return len(updated_fields) > 0
 52    
 53    def remove_contact(self, name):
 54        """Remove a contact."""
 55        if name not in self.contacts:
 56            print(f"❌ Contact '{name}' not found")
 57            return False
 58        
 59        # Remove from all groups
 60        for group_name in self.contacts[name]['groups']:
 61            if group_name in self.groups:
 62                self.groups[group_name].discard(name)
 63        
 64        del self.contacts[name]
 65        print(f"🗑️ Removed contact: {name}")
 66        return True
 67    
 68    def find_contact(self, name):
 69        """Find and display contact information."""
 70        if name not in self.contacts:
 71            print(f"❌ Contact '{name}' not found")
 72            return None
 73        
 74        contact = self.contacts[name]
 75        print(f"\n📋 Contact: {name}")
 76        print(f"  Email: {contact['email']}")
 77        print(f"  Phone: {contact.get('phone', 'Not provided')}")
 78        print(f"  Company: {contact.get('company', 'Not provided')}")
 79        print(f"  Groups: {', '.join(contact['groups']) if contact['groups'] else 'None'}")
 80        print(f"  Created: {contact['created']}")
 81        
 82        return contact
 83    
 84    def search_contacts(self, query):
 85        """Search contacts by name, email, or company."""
 86        query = query.lower()
 87        matches = {}
 88        
 89        for name, contact in self.contacts.items():
 90            # Search in name, email, and company
 91            search_fields = [
 92                name.lower(),
 93                contact['email'].lower(),
 94                (contact.get('company') or '').lower()
 95            ]
 96            
 97            if any(query in field for field in search_fields):
 98                matches[name] = contact
 99        
100        return matches
101    
102    def create_group(self, group_name):
103        """Create a new contact group."""
104        if group_name in self.groups:
105            print(f"❌ Group '{group_name}' already exists")
106            return False
107        
108        self.groups[group_name] = set()
109        print(f"✓ Created group: {group_name}")
110        return True
111    
112    def add_to_group(self, contact_name, group_name):
113        """Add contact to a group."""
114        if contact_name not in self.contacts:
115            print(f"❌ Contact '{contact_name}' not found")
116            return False
117        
118        if group_name not in self.groups:
119            self.create_group(group_name)
120        
121        self.groups[group_name].add(contact_name)
122        self.contacts[contact_name]['groups'].append(group_name)
123        print(f"✓ Added {contact_name} to group {group_name}")
124        return True
125    
126    def list_contacts(self, group_name=None):
127        """List all contacts or contacts in a specific group."""
128        if group_name:
129            if group_name not in self.groups:
130                print(f"❌ Group '{group_name}' not found")
131                return
132            
133            contacts_to_show = {name: self.contacts[name] 
134                              for name in self.groups[group_name]}
135            print(f"\n📂 Contacts in group '{group_name}':")
136        else:
137            contacts_to_show = self.contacts
138            print(f"\n📋 All Contacts ({len(self.contacts)} total):")
139        
140        if not contacts_to_show:
141            print("  No contacts found")
142            return
143        
144        for name, contact in sorted(contacts_to_show.items()):
145            company = f" ({contact.get('company', 'No company')})" if contact.get('company') else ""
146            print(f"  {name}: {contact['email']}{company}")
147    
148    def get_statistics(self):
149        """Get contact statistics."""
150        total_contacts = len(self.contacts)
151        total_groups = len(self.groups)
152        
153        # Count contacts by company
154        companies = {}
155        contacts_with_phone = 0
156        
157        for contact in self.contacts.values():
158            if contact.get('phone'):
159                contacts_with_phone += 1
160            
161            company = contact.get('company', 'No company')
162            companies[company] = companies.get(company, 0) + 1
163        
164        print(f"\n📊 Contact Statistics:")
165        print(f"  Total contacts: {total_contacts}")
166        print(f"  Total groups: {total_groups}")
167        print(f"  Contacts with phone: {contacts_with_phone}")
168        print(f"  Companies represented: {len(companies) - (1 if 'No company' in companies else 0)}")
169        
170        if companies:
171            print(f"  Largest company: {max(companies.items(), key=lambda x: x[1])}")
172    
173    def _get_timestamp(self):
174        """Get current timestamp."""
175        from datetime import datetime
176        return datetime.now().strftime("%Y-%m-%d %H:%M")
177
178def demonstrate_contact_manager():
179    """Show the contact manager in action."""
180    print("=== Contact Manager Demo ===")
181    
182    # Create contact manager
183    cm = ContactManager()
184    
185    # Add some contacts
186    cm.add_contact("Alice Johnson", "alice@email.com", "555-0123", "TechCorp")
187    cm.add_contact("Bob Smith", "bob@email.com", phone="555-0124")
188    cm.add_contact("Charlie Brown", "charlie@company.com", "555-0125", "DesignCo")
189    cm.add_contact("Diana Prince", "diana@email.com", company="TechCorp")
190    cm.add_contact("", "invalid@email.com")  # Test validation
191    
192    # Create groups and add contacts
193    cm.create_group("Work")
194    cm.create_group("Tech Team")
195    cm.add_to_group("Alice Johnson", "Work")
196    cm.add_to_group("Alice Johnson", "Tech Team")
197    cm.add_to_group("Diana Prince", "Work")
198    cm.add_to_group("Bob Smith", "Tech Team")
199    
200    # List contacts
201    cm.list_contacts()
202    cm.list_contacts("Work")
203    
204    # Search functionality
205    print("\n🔍 Search results for 'tech':")
206    tech_results = cm.search_contacts("tech")
207    for name in tech_results:
208        print(f"  Found: {name}")
209    
210    # Update contact
211    cm.update_contact("Bob Smith", company="StartupXYZ", phone="555-9999")
212    
213    # Find specific contact
214    cm.find_contact("Alice Johnson")
215    
216    # Get statistics
217    cm.get_statistics()
218    
219    # Remove contact
220    cm.remove_contact("Charlie Brown")
221    cm.list_contacts()
222
223# Run the demo
224demonstrate_contact_manager()

  1def demonstrate_dictionary_patterns():
  2    """Show common Python dictionary patterns and idioms."""
  3    
  4    # Sample data for demonstrations
  5    sales_data = [
  6        {'product': 'laptop', 'quantity': 2, 'price': 999},
  7        {'product': 'mouse', 'quantity': 5, 'price': 25},
  8        {'product': 'laptop', 'quantity': 1, 'price': 999},
  9        {'product': 'keyboard', 'quantity': 3, 'price': 75},
 10        {'product': 'mouse', 'quantity': 2, 'price': 25}
 11    ]
 12    
 13    print("=== Aggregation Patterns ===")
 14    
 15    # Count occurrences
 16    product_counts = {}
 17    for sale in sales_data:
 18        product = sale['product']
 19        product_counts[product] = product_counts.get(product, 0) + sale['quantity']
 20    print(f"Product quantities: {product_counts}")
 21    
 22    # Using defaultdict for cleaner counting
 23    from collections import defaultdict
 24    
 25    revenue_by_product = defaultdict(float)
 26    for sale in sales_data:
 27        product = sale['product']
 28        revenue = sale['quantity'] * sale['price']
 29        revenue_by_product[product] += revenue
 30    print(f"Revenue by product: {dict(revenue_by_product)}")
 31    
 32    # Group by key
 33    sales_by_product = defaultdict(list)
 34    for sale in sales_data:
 35        sales_by_product[sale['product']].append(sale)
 36    
 37    print("Sales grouped by product:")
 38    for product, sales in sales_by_product.items():
 39        total_qty = sum(sale['quantity'] for sale in sales)
 40        print(f"  {product}: {len(sales)} transactions, {total_qty} units")
 41    
 42    print("\n=== Transformation Patterns ===")
 43    
 44    # Convert list of dicts to dict of lists
 45    students = [
 46        {'name': 'Alice', 'math': 95, 'science': 87},
 47        {'name': 'Bob', 'math': 78, 'science': 92},
 48        {'name': 'Charlie', 'math': 85, 'science': 88}
 49    ]
 50    
 51    # Transpose to subject-based view
 52    subjects = defaultdict(list)
 53    for student in students:
 54        for subject, score in student.items():
 55            if subject != 'name':
 56                subjects[subject].append(score)
 57    
 58    print(f"Scores by subject: {dict(subjects)}")
 59    
 60    # Calculate averages
 61    averages = {subject: sum(scores) / len(scores) 
 62               for subject, scores in subjects.items()}
 63    print(f"Subject averages: {averages}")
 64    
 65    print("\n=== Filtering and Conditional Patterns ===")
 66    
 67    # Filter dictionary by condition
 68    high_scores = {name: score for name, score in averages.items() if score >= 85}
 69    print(f"High-scoring subjects: {high_scores}")
 70    
 71    # Safe nested access
 72    nested_data = {
 73        'user': {
 74            'profile': {
 75                'name': 'John',
 76                'settings': {'theme': 'dark', 'notifications': True}
 77            }
 78        }
 79    }
 80    
 81    # Dangerous way (can raise KeyError)
 82    # theme = nested_data['user']['profile']['settings']['theme']
 83    
 84    # Safe way using get() chain
 85    theme = nested_data.get('user', {}).get('profile', {}).get('settings', {}).get('theme', 'default')
 86    print(f"User theme: {theme}")
 87    
 88    # Multiple key checking
 89    required_keys = ['name', 'email', 'age']
 90    user_data = {'name': 'Alice', 'email': 'alice@example.com', 'city': 'Boston'}
 91    
 92    missing_keys = [key for key in required_keys if key not in user_data]
 93    if missing_keys:
 94        print(f"Missing required fields: {missing_keys}")
 95    else:
 96        print("All required fields present")
 97    
 98    print("\n=== Merging and Combining Patterns ===")
 99    
100    # Merge dictionaries with conflict resolution
101    default_config = {'theme': 'light', 'font_size': 12, 'auto_save': True}
102    user_config = {'theme': 'dark', 'font_size': 14}
103    
104    # Python 3.9+ union operator
105    final_config = default_config | user_config
106    print(f"Final config: {final_config}")
107    
108    # Combine values instead of overwriting
109    inventory_a = {'apples': 50, 'bananas': 30, 'oranges': 40}
110    inventory_b = {'apples': 25, 'berries': 60, 'oranges': 20}
111    
112    combined_inventory = inventory_a.copy()
113    for item, quantity in inventory_b.items():
114        combined_inventory[item] = combined_inventory.get(item, 0) + quantity
115    
116    print(f"Combined inventory: {combined_inventory}")
117    
118    # Dictionary of dictionaries update
119    user_profiles = {
120        'alice': {'age': 25, 'city': 'Boston'},
121        'bob': {'age': 30, 'city': 'NYC'}
122    }
123    
124    updates = {
125        'alice': {'city': 'San Francisco', 'job': 'Engineer'},
126        'charlie': {'age': 28, 'city': 'Chicago', 'job': 'Designer'}
127    }
128    
129    for user, new_data in updates.items():
130        if user in user_profiles:
131            user_profiles[user].update(new_data)
132        else:
133            user_profiles[user] = new_data
134    
135    print(f"Updated profiles: {user_profiles}")
136
137demonstrate_dictionary_patterns()

  1def demonstrate_common_mistakes():
  2    """Show common dictionary mistakes and how to avoid them."""
  3    
  4    print("=== Mistake 1: Using Mutable Objects as Keys ===")
  5    
  6    # WRONG - Lists are mutable and can't be keys
  7    # coordinates = {[0, 0]: 'origin', [1, 1]: 'point'}  # This raises TypeError
  8    
  9    # RIGHT - Use tuples instead
 10    coordinates = {(0, 0): 'origin', (1, 1): 'point', (2, 2): 'diagonal'}
 11    print(f"Coordinate map: {coordinates}")
 12    
 13    # Also okay - strings, numbers, frozensets
 14    point_info = {
 15        'origin': (0, 0),
 16        42: 'special number',
 17        frozenset(['a', 'b']): 'frozen set key'
 18    }
 19    print(f"Mixed key types: {point_info}")
 20    print()
 21    
 22    print("=== Mistake 2: KeyError vs Safe Access ===")
 23    
 24    user_data = {'name': 'Alice', 'age': 25}
 25    
 26    # DANGEROUS - Can raise KeyError
 27    try:
 28        email = user_data['email']  # Key doesn't exist!
 29    except KeyError:
 30        print("KeyError: 'email' key not found")
 31    
 32    # SAFE WAYS
 33    email = user_data.get('email', 'No email provided')
 34    print(f"Safe access: {email}")
 35    
 36    # Check first, then access
 37    if 'email' in user_data:
 38        email = user_data['email']
 39    else:
 40        email = 'No email provided'
 41    print(f"Check then access: {email}")
 42    print()
 43    
 44    print("=== Mistake 3: Modifying Dictionary While Iterating ===")
 45    
 46    # WRONG WAY - Don't modify while iterating
 47    prices = {'apple': 1.0, 'banana': 0.5, 'cherry': 2.0, 'date': 3.0}
 48    print(f"Original prices: {prices}")
 49    
 50    # This can cause problems:
 51    # for item, price in prices.items():
 52    #     if price > 2.0:
 53    #         del prices[item]  # Don't do this!
 54    
 55    # RIGHT WAY 1 - Collect keys to remove
 56    to_remove = []
 57    for item, price in prices.items():
 58        if price > 2.0:
 59            to_remove.append(item)
 60    
 61    for item in to_remove:
 62        del prices[item]
 63    print(f"After removing expensive items: {prices}")
 64    
 65    # RIGHT WAY 2 - Create new dictionary
 66    prices = {'apple': 1.0, 'banana': 0.5, 'cherry': 2.0, 'date': 3.0}
 67    affordable_prices = {item: price for item, price in prices.items() if price <= 2.0}
 68    print(f"Affordable items (new dict): {affordable_prices}")
 69    print()
 70    
 71    print("=== Mistake 4: Shallow vs Deep Copy Issues ===")
 72    
 73    # Shallow copy with nested structures
 74    original = {
 75        'alice': {'scores': [85, 90, 78], 'grade': 'B+'},
 76        'bob': {'scores': [92, 88, 94], 'grade': 'A-'}
 77    }
 78    
 79    shallow_copy = original.copy()
 80    
 81    # This affects both dictionaries!
 82    shallow_copy['alice']['scores'].append(95)
 83    print(f"Original after shallow copy modification: {original}")
 84    print(f"Shallow copy: {shallow_copy}")
 85    
 86    # Deep copy solution
 87    import copy
 88    original = {
 89        'alice': {'scores': [85, 90, 78], 'grade': 'B+'},
 90        'bob': {'scores': [92, 88, 94], 'grade': 'A-'}
 91    }
 92    
 93    deep_copy = copy.deepcopy(original)
 94    deep_copy['alice']['scores'].append(95)
 95    print(f"Original after deep copy modification: {original}")
 96    print(f"Deep copy: {deep_copy}")
 97    print()
 98    
 99    print("=== Mistake 5: Dictionary Assignment vs Copy ===")
100    
101    dict1 = {'a': 1, 'b': 2}
102    dict2 = dict1  # This creates a reference, not a copy!
103    dict2['c'] = 3
104    print(f"dict1 after modifying dict2: {dict1}")  # Both changed!
105    
106    # Correct ways to copy
107    dict3 = {'a': 1, 'b': 2}
108    dict4 = dict3.copy()  # or dict(dict3) or {**dict3}
109    dict4['c'] = 3
110    print(f"dict3 after copying and modifying: {dict3}")  # Unchanged
111    print(f"dict4: {dict4}")
112    print()
113    
114    print("=== Mistake 6: Assuming Dictionary Order (Pre-Python 3.7) ===")
115    
116    # In Python 3.7+, dictionaries maintain insertion order
117    ordered_dict = {'first': 1, 'second': 2, 'third': 3}
118    print(f"Modern Python preserves order: {list(ordered_dict.keys())}")
119    
120    # For explicit ordering in older Python or when order is critical
121    from collections import OrderedDict
122    explicit_order = OrderedDict([('first', 1), ('second', 2), ('third', 3)])
123    print(f"OrderedDict guarantees order: {list(explicit_order.keys())}")
124    
125    # If you need sorted keys
126    data = {'zebra': 1, 'apple': 2, 'banana': 3}
127    sorted_keys = sorted(data.keys())
128    print(f"Sorted keys: {sorted_keys}")
129    sorted_items = [(k, data[k]) for k in sorted_keys]
130    print(f"Items in alphabetical order: {sorted_items}")
131
132demonstrate_common_mistakes()

 1# Creating dictionaries
 2student = {'name': 'Alice', 'age': 20, 'major': 'CS'}
 3empty = {}
 4from_pairs = dict([('a', 1), ('b', 2)])
 5comprehension = {x: x**2 for x in range(5)}
 6
 7# Accessing elements
 8name = student['name']              # Direct access (can raise KeyError)
 9age = student.get('age', 0)         # Safe access with default
10exists = 'major' in student         # Check if key exists
11
12# Adding/modifying elements
13student['gpa'] = 3.8               # Add or update
14student.setdefault('year', 1)      # Add only if key doesn't exist
15student.update({'city': 'Boston'}) # Add multiple items
16
17# Removing elements
18gpa = student.pop('gpa', 0)         # Remove and return (with default)
19item = student.popitem()            # Remove arbitrary item
20del student['city']                 # Delete by key
21student.clear()                     # Remove all items
22
23# Navigation
24keys = list(student.keys())         # All keys
25values = list(student.values())     # All values
26items = list(student.items())       # All key-value pairs
27length = len(student)               # Number of items
28
29# Iteration
30for key in student:                 # Iterate over keys
31for value in student.values():      # Iterate over values
32for key, value in student.items():  # Iterate over pairs
33
34# Dictionary comprehensions
35squares = {x: x**2 for x in range(5)}
36filtered = {k: v for k, v in student.items() if v != 'Alice'}
37
38# Merging dictionaries
39dict1 = {'a': 1, 'b': 2}
40dict2 = {'c': 3, 'd': 4}
41merged = dict1 | dict2              # Python 3.9+
42merged = {**dict1, **dict2}         # Alternative syntax