📘 Dictionaries: Key-Value Pairs

🎯 Introduction

Welcome to the wonderful world of Python dictionaries! 🎉 In this guide, we’ll explore one of Python’s most powerful and versatile data structures - the dictionary.

Have you ever needed to store information where each piece of data has a unique identifier? Like a phone book 📱 where names map to numbers, or a menu 🍕 where items map to prices? That’s exactly what dictionaries are for!

By the end of this tutorial, you’ll be creating dictionaries like a pro and using them to build amazing Python applications! Let’s dive in! 🏊‍♂️

📚 Understanding Dictionaries

🤔 What is a Dictionary?

A dictionary is like a real-world dictionary 📖 - but instead of words and definitions, you can store any key-value pairs! Think of it as a super-smart container that remembers things by their names rather than their position.

In Python terms, a dictionary is a mutable, unordered collection of key-value pairs. This means you can:

• ✨ Store any type of data as values
• 🚀 Access values instantly using their keys
• 🛡️ Modify, add, or remove items anytime

💡 Why Use Dictionaries?

Here’s why Python developers love dictionaries:

1. Lightning Fast Lookups ⚡: Find any value in constant time
2. Intuitive Organization 🗂️: Store related data together
3. Flexible Structure 🎨: Keys can be strings, numbers, or tuples
4. Real-World Modeling 🌍: Perfect for representing objects and relationships

Real-world example: Imagine building a student grade tracker 📊. With dictionaries, you can map student names to their grades instantly!

🔧 Basic Syntax and Usage

📝 Creating Dictionaries

Let’s start with some friendly examples:

# 👋 Hello, Dictionaries!
empty_dict = {}  # Empty dictionary
print(f"Empty dictionary: {empty_dict}")

# 🎨 Creating a simple dictionary
person = {
    "name": "Alice",      # 👤 Person's name
    "age": 25,           # 🎂 Person's age  
    "city": "New York"   # 🏙️ Where they live
}
print(f"Person dictionary: {person}")

# 🍕 Using dict() constructor
pizza_menu = dict(
    margherita=12.99,    # 🍕 Classic choice
    pepperoni=14.99,     # 🌶️ Spicy favorite
    hawaiian=13.99       # 🍍 Controversial but delicious
)
print(f"Pizza menu: {pizza_menu}")

💡 Explanation: Notice how we can create dictionaries using curly braces {} or the dict() constructor. Both work great!

🎯 Accessing and Modifying Values

Here are the patterns you’ll use daily:

# 🏗️ Pattern 1: Accessing values
student_grades = {
    "Alice": 95,
    "Bob": 87,
    "Charlie": 92
}

# Get Alice's grade
alice_grade = student_grades["Alice"]
print(f"Alice's grade: {alice_grade} 🌟")

# 🎨 Pattern 2: Safe access with get()
# This won't crash if key doesn't exist!
david_grade = student_grades.get("David", 0)  # Default to 0
print(f"David's grade: {david_grade} (New student)")

# 🔄 Pattern 3: Modifying values
student_grades["Bob"] = 90  # Bob improved! 📈
student_grades["Diana"] = 88  # New student added! 
print(f"Updated grades: {student_grades}")

💡 Practical Examples

🛒 Example 1: Shopping Cart System

Let’s build something real:

# 🛍️ E-commerce shopping cart
class ShoppingCart:
    def __init__(self):
        self.items = {}  # Dictionary to store items
        
    # ➕ Add item to cart
    def add_item(self, product, price, quantity=1):
        if product in self.items:
            self.items[product]["quantity"] += quantity
            print(f"Added {quantity} more {product}! 🛒")
        else:
            self.items[product] = {
                "price": price,
                "quantity": quantity,
                "emoji": self._get_emoji(product)
            }
            print(f"Added {product} to cart! {self._get_emoji(product)}")
    
    # 🎨 Get emoji for product
    def _get_emoji(self, product):
        emoji_map = {
            "laptop": "💻",
            "phone": "📱",
            "headphones": "🎧",
            "book": "📚",
            "coffee": "☕"
        }
        return emoji_map.get(product.lower(), "📦")
    
    # 💰 Calculate total
    def get_total(self):
        total = 0
        for item, details in self.items.items():
            total += details["price"] * details["quantity"]
        return total
    
    # 📋 Display cart
    def show_cart(self):
        print("\n🛒 Your Shopping Cart:")
        print("-" * 40)
        for item, details in self.items.items():
            emoji = details["emoji"]
            price = details["price"]
            qty = details["quantity"]
            subtotal = price * qty
            print(f"{emoji} {item}: ${price:.2f} x {qty} = ${subtotal:.2f}")
        print("-" * 40)
        print(f"💰 Total: ${self.get_total():.2f}")

# 🎮 Let's use it!
cart = ShoppingCart()
cart.add_item("Laptop", 999.99)
cart.add_item("Coffee", 4.99, 3)
cart.add_item("Book", 19.99, 2)
cart.show_cart()

🎯 Try it yourself: Add a remove_item method and a discount code feature!

🎮 Example 2: Game Character Stats

Let’s make it fun:

# 🏆 RPG character system
class GameCharacter:
    def __init__(self, name, char_class):
        self.name = name
        self.char_class = char_class
        self.stats = self._initialize_stats()
        self.inventory = {}
        self.skills = {}
        
    # 🎲 Initialize character stats
    def _initialize_stats(self):
        base_stats = {
            "warrior": {"health": 150, "mana": 50, "strength": 20, "magic": 5},
            "mage": {"health": 80, "mana": 150, "strength": 8, "magic": 25},
            "rogue": {"health": 100, "mana": 80, "strength": 15, "magic": 10}
        }
        return base_stats.get(self.char_class, 
                             {"health": 100, "mana": 100, "strength": 10, "magic": 10})
    
    # 🎯 Learn new skill
    def learn_skill(self, skill_name, damage, mana_cost):
        self.skills[skill_name] = {
            "damage": damage,
            "mana_cost": mana_cost,
            "level": 1,
            "emoji": self._get_skill_emoji(skill_name)
        }
        print(f"🌟 {self.name} learned {skill_name}! {self._get_skill_emoji(skill_name)}")
    
    # 🎨 Get skill emoji
    def _get_skill_emoji(self, skill):
        emoji_map = {
            "fireball": "🔥",
            "ice_shard": "❄️",
            "lightning": "⚡",
            "heal": "💚",
            "stealth": "👤"
        }
        return emoji_map.get(skill.lower(), "✨")
    
    # 💎 Add item to inventory
    def add_item(self, item_name, quantity=1):
        if item_name in self.inventory:
            self.inventory[item_name] += quantity
        else:
            self.inventory[item_name] = quantity
        print(f"📦 Added {quantity}x {item_name} to inventory!")
    
    # 📊 Show character info
    def show_info(self):
        print(f"\n⚔️ Character: {self.name} the {self.char_class.title()}")
        print("📊 Stats:")
        for stat, value in self.stats.items():
            emoji = {"health": "❤️", "mana": "💙", 
                    "strength": "💪", "magic": "✨"}.get(stat, "📊")
            print(f"  {emoji} {stat.title()}: {value}")
        
        if self.skills:
            print("\n🎯 Skills:")
            for skill, details in self.skills.items():
                print(f"  {details['emoji']} {skill}: "
                      f"Damage {details['damage']}, Mana {details['mana_cost']}")

# 🎮 Create and play!
hero = GameCharacter("Aria", "mage")
hero.learn_skill("Fireball", 50, 20)
hero.learn_skill("Ice_Shard", 40, 15)
hero.add_item("Health Potion", 5)
hero.add_item("Mana Crystal", 3)
hero.show_info()

🚀 Advanced Concepts

🧙‍♂️ Dictionary Comprehensions

When you’re ready to level up, try this powerful pattern:

# 🎯 Dictionary comprehensions - create dictionaries in one line!

# Basic comprehension
squares = {x: x**2 for x in range(1, 6)}
print(f"Squares: {squares}")  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 🎨 With conditions
even_squares = {x: x**2 for x in range(1, 11) if x % 2 == 0}
print(f"Even squares: {even_squares}")

# 🌈 Transform existing dictionary
prices = {"apple": 0.5, "banana": 0.3, "orange": 0.6}
discounted = {fruit: price * 0.8 for fruit, price in prices.items()}
print(f"20% off sale: {discounted}")

# ✨ Nested dictionaries
students = ["Alice", "Bob", "Charlie"]
subjects = ["Math", "Science", "English"]
grade_book = {
    student: {subject: 0 for subject in subjects}
    for student in students
}
print(f"Grade book initialized: {grade_book}")

🏗️ Advanced Dictionary Methods

For the brave developers:

# 🚀 Advanced dictionary operations

# Merging dictionaries (Python 3.9+)
basic_stats = {"health": 100, "mana": 50}
bonus_stats = {"strength": 20, "mana": 30}  # Note: mana appears in both!

# Using the | operator (Python 3.9+)
combined = basic_stats | bonus_stats  # Right side wins for duplicates
print(f"Combined stats: {combined}")

# 🎲 setdefault - add if missing
inventory = {"sword": 1, "potion": 5}
inventory.setdefault("shield", 0)  # Adds shield: 0 if not present
inventory.setdefault("sword", 10)  # Doesn't change existing value
print(f"Inventory: {inventory}")

# 🔄 Update multiple values at once
character = {"name": "Hero", "level": 1}
character.update({"level": 5, "exp": 1000, "gold": 500})
print(f"Updated character: {character}")

# 💎 Dictionary unpacking
default_settings = {"volume": 50, "difficulty": "normal"}
user_settings = {"volume": 80, "subtitles": True}
final_settings = {**default_settings, **user_settings}
print(f"Final settings: {final_settings}")

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: KeyError When Accessing

# ❌ Wrong way - crashes if key doesn't exist!
inventory = {"sword": 1, "potion": 5}
# shields = inventory["shield"]  # 💥 KeyError!

# ✅ Correct way - use get() or check first!
shields = inventory.get("shield", 0)  # Returns 0 if not found
print(f"Shields: {shields} 🛡️")

# ✅ Or check if key exists
if "shield" in inventory:
    shields = inventory["shield"]
else:
    print("No shields in inventory! 😢")

🤯 Pitfall 2: Mutable Keys

# ❌ Dangerous - lists can't be dictionary keys!
# bad_dict = {[1, 2]: "value"}  # 💥 TypeError!

# ✅ Safe - use immutable types as keys!
good_dict = {
    (1, 2): "coordinate",      # ✅ Tuples are immutable
    "player1": "Alice",        # ✅ Strings are immutable
    42: "answer",              # ✅ Numbers are immutable
    frozenset([1, 2]): "set"   # ✅ Frozensets are immutable
}
print("All good keys! ✨")

🛠️ Best Practices

1. 🎯 Use get() for Safe Access: Avoid KeyErrors with default values
2. 📝 Choose Meaningful Keys: user_email not ue
3. 🛡️ Keep Keys Consistent: Stick to one style (snake_case recommended)
4. 🎨 Use Type Hints: Dict[str, int] for clarity
5. ✨ Consider defaultdict: For automatic default values

🧪 Hands-On Exercise

🎯 Challenge: Build a Contact Management System

Create a contact manager with these features:

📋 Requirements:

• ✅ Store contacts with name, phone, email, and tags
• 🏷️ Search contacts by name or tag
• 👥 Group contacts by tags
• 📊 Generate statistics (total contacts, contacts per tag)
• 🎨 Each contact needs an emoji based on their first tag!

🚀 Bonus Points:

• Add import/export functionality
• Implement fuzzy search
• Create a favorites system

💡 Solution

# 🎯 Contact Management System
class ContactManager:
    def __init__(self):
        self.contacts = {}
        self.tag_emojis = {
            "work": "💼",
            "family": "👨‍👩‍👧‍👦",
            "friend": "🤝",
            "vip": "⭐",
            "emergency": "🚨"
        }
    
    # ➕ Add new contact
    def add_contact(self, name, phone, email, tags=None):
        if tags is None:
            tags = []
        
        contact_id = len(self.contacts) + 1
        self.contacts[contact_id] = {
            "name": name,
            "phone": phone,
            "email": email,
            "tags": tags,
            "favorite": False,
            "emoji": self._get_contact_emoji(tags)
        }
        print(f"✅ Added {name} to contacts! {self._get_contact_emoji(tags)}")
        return contact_id
    
    # 🎨 Get emoji for contact
    def _get_contact_emoji(self, tags):
        if not tags:
            return "👤"
        return self.tag_emojis.get(tags[0], "👤")
    
    # 🔍 Search contacts
    def search(self, query):
        results = {}
        query_lower = query.lower()
        
        for contact_id, contact in self.contacts.items():
            # Search in name
            if query_lower in contact["name"].lower():
                results[contact_id] = contact
            # Search in tags
            elif any(query_lower in tag.lower() for tag in contact["tags"]):
                results[contact_id] = contact
        
        return results
    
    # 🏷️ Group by tag
    def group_by_tag(self):
        grouped = {}
        for contact in self.contacts.values():
            for tag in contact["tags"]:
                if tag not in grouped:
                    grouped[tag] = []
                grouped[tag].append(contact)
        return grouped
    
    # ⭐ Toggle favorite
    def toggle_favorite(self, contact_id):
        if contact_id in self.contacts:
            self.contacts[contact_id]["favorite"] = \
                not self.contacts[contact_id]["favorite"]
            status = "⭐ favorited" if self.contacts[contact_id]["favorite"] \
                    else "removed from favorites"
            print(f"{self.contacts[contact_id]['name']} {status}!")
    
    # 📊 Get statistics
    def get_stats(self):
        total = len(self.contacts)
        favorites = sum(1 for c in self.contacts.values() if c["favorite"])
        tag_counts = {}
        
        for contact in self.contacts.values():
            for tag in contact["tags"]:
                tag_counts[tag] = tag_counts.get(tag, 0) + 1
        
        return {
            "total_contacts": total,
            "favorites": favorites,
            "tags": tag_counts
        }
    
    # 📋 Display contacts
    def display_contacts(self):
        print("\n📱 All Contacts:")
        print("-" * 50)
        for contact_id, contact in self.contacts.items():
            emoji = contact["emoji"]
            fav = "⭐" if contact["favorite"] else ""
            tags = ", ".join(contact["tags"])
            print(f"{emoji} {contact['name']} {fav}")
            print(f"   📞 {contact['phone']} | 📧 {contact['email']}")
            if tags:
                print(f"   🏷️  {tags}")
            print()

# 🎮 Test the system!
manager = ContactManager()

# Add contacts
manager.add_contact("Alice Johnson", "555-0101", "[email protected]", ["work", "vip"])
manager.add_contact("Bob Smith", "555-0102", "[email protected]", ["friend"])
manager.add_contact("Mom", "555-0103", "[email protected]", ["family", "emergency"])
manager.add_contact("Charlie Brown", "555-0104", "[email protected]", ["work"])

# Toggle favorites
manager.toggle_favorite(1)  # Alice
manager.toggle_favorite(3)  # Mom

# Display all
manager.display_contacts()

# Show stats
stats = manager.get_stats()
print("📊 Contact Statistics:")
for key, value in stats.items():
    print(f"  {key}: {value}")

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

• ✅ Create dictionaries with confidence 💪
• ✅ Access and modify dictionary data safely 🛡️
• ✅ Use advanced features like comprehensions and merging 🎯
• ✅ Avoid common mistakes that trip up beginners 🐛
• ✅ Build real applications with dictionaries! 🚀

Remember: Dictionaries are one of Python’s superpowers! They make your code cleaner, faster, and more intuitive. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered Python dictionaries!

Here’s what to do next:

1. 💻 Practice with the exercises above
2. 🏗️ Build a small project using dictionaries (inventory system, grade tracker, etc.)
3. 📚 Move on to our next tutorial: Sets and Frozen Sets
4. 🌟 Share your dictionary creations with others!

Remember: Every Python expert started where you are now. Keep coding, keep learning, and most importantly, have fun with dictionaries! 🚀

Happy coding! 🎉🚀✨