Python Dictionaries: My Essential Guide

Author: Mohammad Sayem Chowdhury

Welcome! In this notebook, I'll share my journey learning about dictionaries in Python. Dictionaries have become one of my most-used data structures because of their flexibility and efficiency. By the end, you'll understand how I approach dictionary operations, from basic key-value pairs to advanced techniques.

What I'll Cover

• Understanding Dictionaries
• Creating and Accessing Dictionaries
• Dictionary Methods and Operations
• Iterating Through Dictionaries
• Nested Dictionaries
• Practical Applications

Estimated time: about 20 minutes of hands-on practice.

---

What Are Dictionaries?

I think of dictionaries as collections of key-value pairs, like a real dictionary where words (keys) have definitions (values). Unlike lists that use numerical indices, dictionaries use meaningful keys to access data.

Here's the key difference I always remember:

• Lists: Use numerical indices [0, 1, 2, ...]
• Dictionaries: Use descriptive keys ["name", "age", "city", ...]

Creating My First Dictionary

Let me start with something personal - information about myself:

# Creating a dictionary about myself
my_info = {
    "name": "Mohammad Sayem Chowdhury",
    "age": 25,
    "city": "Dhaka",
    "profession": "Data Scientist",
    "interests": ["Python", "Machine Learning", "Music"],
    "is_student": False
}

print("My personal information:")
print(my_info)
print(f"Dictionary type: {type(my_info)}")
print(f"Number of items: {len(my_info)}")

Accessing Dictionary Values

I can access values using their keys in several ways:

# Different ways to access dictionary values
print("Accessing values:")
print(f"Name: {my_info['name']}")
print(f"Age: {my_info['age']}")
print(f"City: {my_info['city']}")

# Using the get() method (my preferred way)
print(f"\nUsing get() method:")
print(f"Profession: {my_info.get('profession')}")
print(f"Country: {my_info.get('country', 'Not specified')}")  # Default value

# Checking if a key exists
if 'interests' in my_info:
    print(f"My interests: {my_info['interests']}")

Modifying Dictionaries

Unlike tuples, dictionaries are mutable, so I can change them after creation:

# Creating a dictionary for my favorite album
favorite_album = {
    "artist": "Pink Floyd",
    "title": "The Dark Side of the Moon",
    "year": 1973,
    "genre": "Progressive Rock"
}

print("Original album info:")
print(favorite_album)

# Adding new key-value pairs
favorite_album["duration"] = "43:00"
favorite_album["rating"] = 5
favorite_album["tracks"] = 10

print("\nAfter adding new information:")
print(favorite_album)

# Modifying existing values
favorite_album["rating"] = 4.8  # More precise rating
favorite_album["genre"] = "Psychedelic Rock"

print("\nAfter modifications:")
print(favorite_album)

# Removing items
del favorite_album["tracks"]  # Remove using del
removed_duration = favorite_album.pop("duration")  # Remove and return value

print(f"\nRemoved duration: {removed_duration}")
print("Final album info:")
print(favorite_album)

Dictionary Methods: My Toolkit

Python provides many useful dictionary methods that I use regularly:

# My music collection as a dictionary
music_collection = {
    "rock": ["Led Zeppelin", "The Beatles", "Queen"],
    "jazz": ["Miles Davis", "John Coltrane", "Bill Evans"],
    "classical": ["Bach", "Mozart", "Beethoven"],
    "electronic": ["Daft Punk", "Aphex Twin", "Kraftwerk"]
}

print("My music collection:")
print(music_collection)
print()

# Getting all keys, values, and items
print("All genres (keys):")
print(list(music_collection.keys()))

print("\nAll artists (values):")
all_artists = []
for artists_list in music_collection.values():
    all_artists.extend(artists_list)
print(all_artists)

print("\nAll key-value pairs (items):")
for genre, artists in music_collection.items():
    print(f"{genre}: {artists}")

# More dictionary methods I use frequently
student_grades = {
    "Mohammad": 95,
    "Sarah": 87,
    "Ahmed": 91,
    "Lisa": 89
}

print("Original grades:")
print(student_grades)

# Create a copy
grades_backup = student_grades.copy()
print(f"\nBackup created: {grades_backup}")

# Update with new data
new_grades = {"Mohammad": 97, "John": 85}
student_grades.update(new_grades)
print(f"\nAfter update: {student_grades}")

# Clear all items
grades_backup.clear()
print(f"After clearing backup: {grades_backup}")

# Using setdefault
student_grades.setdefault("Emma", 90)  # Add if key doesn't exist
student_grades.setdefault("Mohammad", 80)  # Won't change existing value
print(f"After setdefault: {student_grades}")

Iterating Through Dictionaries

There are several ways I iterate through dictionaries:

# My favorite programming languages with ratings
languages = {
    "Python": 9.5,
    "JavaScript": 8.0,
    "R": 7.5,
    "SQL": 8.5,
    "Java": 7.0
}

print("Method 1: Iterating through keys")
for language in languages:
    print(f"{language}: {languages[language]}")

print("\nMethod 2: Iterating through values")
for rating in languages.values():
    print(f"Rating: {rating}")

print("\nMethod 3: Iterating through key-value pairs")
for language, rating in languages.items():
    print(f"{language} - Rating: {rating}/10")

print("\nMethod 4: With enumeration")
for i, (language, rating) in enumerate(languages.items(), 1):
    print(f"{i}. {language}: {rating}")

Nested Dictionaries: Complex Data Structures

I often work with nested dictionaries for complex data:

# My project portfolio as nested dictionaries
portfolio = {
    "project1": {
        "name": "Stock Price Predictor",
        "language": "Python",
        "libraries": ["pandas", "scikit-learn", "matplotlib"],
        "status": "completed",
        "duration_weeks": 8
    },
    "project2": {
        "name": "Web Scraping Tool",
        "language": "Python", 
        "libraries": ["requests", "beautifulsoup4", "selenium"],
        "status": "in_progress",
        "duration_weeks": 4
    },
    "project3": {
        "name": "Data Dashboard",
        "language": "JavaScript",
        "libraries": ["React", "D3.js", "Chart.js"],
        "status": "planning",
        "duration_weeks": 6
    }
}

print("My project portfolio:")
for project_id, details in portfolio.items():
    print(f"\n{project_id.upper()}:")
    print(f"  Name: {details['name']}")
    print(f"  Language: {details['language']}")
    print(f"  Status: {details['status']}")
    print(f"  Libraries: {', '.join(details['libraries'])}")

# Accessing nested data
print(f"\nFirst project language: {portfolio['project1']['language']}")
print(f"Libraries for project2: {portfolio['project2']['libraries']}")

# Modifying nested data
portfolio['project2']['status'] = 'completed'
portfolio['project3']['libraries'].append('Node.js')
print(f"\nUpdated project2 status: {portfolio['project2']['status']}")

Dictionary Comprehensions

One of my favorite Python features - creating dictionaries with concise syntax:

# Basic dictionary comprehension
numbers = [1, 2, 3, 4, 5]
squares_dict = {num: num**2 for num in numbers}
print("Squares dictionary:", squares_dict)

# Dictionary comprehension with condition
words = ["python", "java", "javascript", "go", "rust"]
long_words = {word: len(word) for word in words if len(word) > 4}
print("Long words (>4 chars):", long_words)

# Creating a grade letter mapping
scores = {"Mohammad": 95, "Sarah": 87, "Ahmed": 91, "Lisa": 89, "John": 76}

def get_grade(score):
    if score >= 90: return 'A'
    elif score >= 80: return 'B'
    elif score >= 70: return 'C'
    else: return 'F'

grade_letters = {name: get_grade(score) for name, score in scores.items()}
print("Grade letters:", grade_letters)

# Inverting a dictionary
original = {"a": 1, "b": 2, "c": 3}
inverted = {value: key for key, value in original.items()}
print("Original:", original)
print("Inverted:", inverted)

Practical Applications

Let me show some real-world scenarios where I use dictionaries:

# Example 1: Counting occurrences
text = "hello world this is a hello world example"
word_count = {}

for word in text.split():
    word_count[word] = word_count.get(word, 0) + 1

print("Word frequency:")
for word, count in sorted(word_count.items()):
    print(f"{word}: {count}")

# Using defaultdict for cleaner counting
from collections import defaultdict
word_count_v2 = defaultdict(int)
for word in text.split():
    word_count_v2[word] += 1

print("\nUsing defaultdict:")
print(dict(word_count_v2))

# Example 2: Configuration management
app_config = {
    "database": {
        "host": "localhost",
        "port": 5432,
        "name": "myapp_db",
        "user": "admin"
    },
    "api": {
        "version": "v1",
        "timeout": 30,
        "rate_limit": 1000
    },
    "features": {
        "caching": True,
        "logging": True,
        "debug": False
    }
}

def get_config_value(config, path):
    """Get nested configuration value using dot notation."""
    keys = path.split('.')
    value = config
    for key in keys:
        value = value.get(key)
        if value is None:
            return None
    return value

# Using the configuration
db_host = get_config_value(app_config, "database.host")
api_timeout = get_config_value(app_config, "api.timeout")
debug_mode = get_config_value(app_config, "features.debug")

print(f"Database host: {db_host}")
print(f"API timeout: {api_timeout}")
print(f"Debug mode: {debug_mode}")

# Example 3: Data transformation
raw_data = [
    ("Mohammad", "Computer Science", 3.8),
    ("Sarah", "Mathematics", 3.9),
    ("Ahmed", "Physics", 3.7),
    ("Lisa", "Engineering", 3.85)
]

# Transform to dictionary of dictionaries
students_db = {}
for name, major, gpa in raw_data:
    students_db[name] = {
        "major": major,
        "gpa": gpa,
        "status": "Dean's List" if gpa >= 3.75 else "Good Standing"
    }

print("Students database:")
for name, info in students_db.items():
    print(f"{name}: {info}")

# Group by major
by_major = {}
for name, info in students_db.items():
    major = info["major"]
    if major not in by_major:
        by_major[major] = []
    by_major[major].append(name)

print("\nStudents by major:")
for major, students in by_major.items():
    print(f"{major}: {students}")

---

My Key Takeaways

Dictionaries have revolutionized how I organize and access data in Python. Here's what I consider most important:

1. Key-Value Mapping: Perfect for creating logical connections between data
2. Fast Lookups: O(1) average time complexity for accessing values
3. Flexibility: Can store any type of data as values
4. Mutability: Easy to modify, add, or remove items
5. Iteration Options: Multiple ways to loop through data

I use dictionaries for:

• Configuration management
• Data transformation and grouping
• Caching and memoization
• Counting and frequency analysis
• API response handling
• Database-like operations

The combination of dictionaries with list/set comprehensions creates powerful, readable code for data processing tasks.

Copyright © 2025 Mohammad Sayem Chowdhury. This notebook and its content are shared for personal learning and inspiration.

---

Next Steps in My Dictionary Journey

Mastering dictionaries opened the door to more advanced concepts like classes, JSON handling, and database operations. They're fundamental to almost every Python application I build.

— Mohammad Sayem Chowdhury