Runs in your browser — no installs needed

Master Python's
Essential Data Structures

Ten focused, hands-on lessons covering the standard library features that separate good Python from great Python. Every concept comes with live, editable code you can run instantly.

10

Lessons

25+

Code examples

0

Dependencies

∞

Runs allowed

How to use this tutorial

Each lesson explains a concept with clear prose, then gives you a live code editor to experiment in. The code runs via Pyodide — a real CPython runtime compiled to WebAssembly — so it behaves exactly like Python on your machine.

Edit any code in the editor — it's fully interactive
Press Run or hit Ctrl+Enter / Cmd+Enter to execute
Hit ↺ Reset to restore the original code
Navigate with the sidebar or the Prev/Next buttons

Try it now

This playground is fully live. Edit the code and hit Run to verify Python is working:

topics = [
    "dict", "defaultdict", "OrderedDict",
    "Counter", "heapq", "bisect",
    "deque", "f-strings", "Comprehensions", "dataclass"
]

print("Welcome to the Python Data Structures Tutorial!")
print(f"You'll learn {len(topics)} topics:\n")

for i, topic in enumerate(topics, 1):
    print(f"  {i:2}. {topic}")

print(f"\nLet's start with the fundamentals!")

Output

Click "Run" to execute

01 / 10

dict — Python Dictionaries

The dictionary is Python's most versatile built-in data structure — a hash map storing key-value pairs with O(1) average-case lookup. Understanding dict deeply unlocks almost every other data structure in this course.

Creating and accessing dictionaries

Dictionaries are created with curly braces { } or the dict() constructor. Keys can be any hashable type — strings, numbers, tuples. Access values with d[key] or the safer d.get(key, default) which returns None (or your default) instead of raising a KeyError.

d.get(key) — safe access, returns None if missing
d.get(key, default) — returns default if key missing
key in d — fast O(1) membership test
d.keys(), d.values(), d.items() — view objects

# Phone book application
phonebook = {
    "Alice": "555-1234",
    "Bob":   "555-5678",
    "Carol": "555-9012",
}

# Safe access with .get()
print("Alice:", phonebook.get("Alice"))
print("Dave:", phonebook.get("Dave", "Not found"))

# Add and update entries
phonebook["Dave"] = "555-3456"
phonebook["Alice"] = "555-0000"  # overwrite

print("\nUpdated phonebook:")
for name, number in phonebook.items():
    print(f"  {name}: {number}")

print(f"\nContacts: {len(phonebook)}")
print(f"'Bob' in phonebook: {'Bob' in phonebook}")

Output

Click "Run" to execute

Advanced dict features

Modern Python (3.9+) supports the merge operator | to combine dictionaries. Dict comprehensions let you transform data concisely. setdefault() inserts a key only if it doesn't already exist, making it ideal for initializing nested structures.

a | b — merge dicts (3.9+), b wins on conflicts
{k: v for k, v in ...} — dict comprehension
d.setdefault(key, []) — insert default only if missing
d.pop(key, default) — remove and return value

# Word frequency counter using dict comprehension
text = "the quick brown fox jumps over the lazy dog the fox"
words = text.split()

# Manual approach with setdefault
freq = {}
for word in words:
    freq[word] = freq.get(word, 0) + 1

# Or as a comprehension (counts unique first, then accumulate)
# Top words using dict comprehension to filter
top = {k: v for k, v in freq.items() if v > 1}

print("All word frequencies:")
for word, count in sorted(freq.items(), key=lambda x: -x[1]):
    bar = "█" * count
    print(f"  {word:<8} {bar} ({count})")

print(f"\nWords appearing more than once: {top}")

# Merge two dicts (Python 3.9+)
defaults = {"timeout": 30, "retries": 3, "verbose": False}
overrides = {"timeout": 60, "verbose": True}
config = defaults | overrides
print(f"\nMerged config: {config}")

Output

Click "Run" to execute

Nested dictionaries

Dicts can hold any value — including other dicts. Use setdefault or carefully structured comprehensions to build nested structures without KeyError surprises.

# Student grade database
students = [
    ("Alice", "Math", 92),
    ("Bob",   "Math", 78),
    ("Alice", "Science", 88),
    ("Bob",   "Science", 95),
    ("Carol", "Math", 84),
]

# Build nested dict: {student: {subject: grade}}
grades = {}
for name, subject, grade in students:
    grades.setdefault(name, {})[subject] = grade

print("Student grade report:")
for student, subjects in grades.items():
    avg = sum(subjects.values()) / len(subjects)
    print(f"\n  {student}:")
    for subject, grade in subjects.items():
        print(f"    {subject}: {grade}")
    print(f"    Average: {avg:.1f}")

Output

Click "Run" to execute

02 / 10

defaultdict — Auto-Initializing Dicts

collections.defaultdict is a dict subclass that calls a factory function to supply missing values automatically — eliminating the boilerplate of setdefault and key in d checks.

The problem with regular dicts

When building a dict that maps keys to lists or counts, a regular dict forces you to check if the key exists before appending or incrementing. This leads to repetitive if key not in d: d[key] = [] patterns. defaultdict eliminates all of that by automatically creating a default value on first access.

defaultdict(list) — missing keys return an empty []
defaultdict(int) — missing keys return 0
defaultdict(set) — missing keys return an empty set()
The factory can be any zero-argument callable, including lambdas

Tip: defaultdict is a drop-in replacement for dict — all regular dict methods work the same way.

from collections import defaultdict

# Group students by grade level — no KeyError, no setdefault!
students = [
    ("Alice", "A"), ("Bob", "B"), ("Carol", "A"),
    ("Dave", "C"), ("Eve", "B"), ("Frank", "A"),
]

# With regular dict (verbose):
# groups = {}
# for name, grade in students:
#     if grade not in groups:
#         groups[grade] = []
#     groups[grade].append(name)

# With defaultdict (clean):
groups = defaultdict(list)
for name, grade in students:
    groups[name[0]]  # accessing a missing key auto-creates []
    groups[grade].append(name)

print("Students by grade:")
for grade in sorted(groups):
    print(f"  Grade {grade}: {', '.join(groups[grade])}")

# Word count with defaultdict(int)
text = "apple banana apple cherry banana apple"
count = defaultdict(int)
for word in text.split():
    count[word] += 1  # no need to check if key exists

print("\nWord counts:", dict(count))

Output

Click "Run" to execute

Graph adjacency list with defaultdict

One of the most common uses of defaultdict(list) is building graph representations. Each node maps to a list of its neighbors, and adding edges requires no initialization code.

from collections import defaultdict

# Build an undirected graph with defaultdict(list)
edges = [
    ("A", "B"), ("A", "C"), ("B", "D"),
    ("C", "D"), ("D", "E"), ("B", "E"),
]

graph = defaultdict(list)
for u, v in edges:
    graph[u].append(v)
    graph[v].append(u)  # undirected

print("Graph adjacency list:")
for node in sorted(graph):
    print(f"  {node} → {sorted(graph[node])}")

# BFS traversal using the graph
from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    order = []
    while queue:
        node = queue.popleft()
        if node not in visited:
            visited.add(node)
            order.append(node)
            queue.extend(sorted(graph[node]))
    return order

print(f"\nBFS from 'A': {bfs(graph, 'A')}")

Output

Click "Run" to execute

03 / 10

OrderedDict — Ordered Dictionaries

collections.OrderedDict remembers insertion order (like all modern Python dicts) but adds extra powers: move_to_end(), order-sensitive equality, and popitem from either end — ideal for LRU caches.

When to use OrderedDict over dict

Since Python 3.7, regular dict preserves insertion order too. So why use OrderedDict? Two reasons: move_to_end() lets you reorder keys in O(1), and two OrderedDicts compare as unequal if their keys appear in different order — handy for history-aware data.

od.move_to_end(key) — move to last position
od.move_to_end(key, last=False) — move to first position
od.popitem(last=True) — remove & return last item (LIFO)
od.popitem(last=False) — remove & return first item (FIFO)

from collections import OrderedDict

# Task queue where priority can change
tasks = OrderedDict()
tasks["email"]    = "medium"
tasks["report"]   = "high"
tasks["meeting"]  = "low"
tasks["deploy"]   = "critical"

print("Initial task order:")
for task, priority in tasks.items():
    print(f"  [{priority:8}] {task}")

# Promote "email" to front (urgent!)
tasks.move_to_end("email", last=False)
# Demote "meeting" to end
tasks.move_to_end("meeting")

print("\nAfter reordering:")
for task, priority in tasks.items():
    print(f"  [{priority:8}] {task}")

# Order-sensitive equality
d1 = OrderedDict([("a", 1), ("b", 2)])
d2 = OrderedDict([("b", 2), ("a", 1)])
print(f"\nd1 == d2 (OrderedDict): {d1 == d2}")
print(f"d1 == d2 (regular dict): {dict(d1) == dict(d2)}")

Output

Click "Run" to execute

LRU Cache implementation

A Least Recently Used (LRU) cache evicts the oldest-accessed item when capacity is full. OrderedDict.move_to_end() makes this elegant: on every access, move the item to the back; on eviction, pop from the front.

Tip: Python's functools.lru_cache does this automatically for functions. Use OrderedDict when you need a manual, size-bounded cache structure.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)  # mark as recently used
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)  # evict LRU item

    def __repr__(self):
        return f"LRU{list(self.cache.items())}"

# Simulate cache with capacity 3
cache = LRUCache(3)
cache.put("page1", "Home")
cache.put("page2", "About")
cache.put("page3", "Blog")
print(f"After 3 inserts: {cache}")

cache.get("page1")            # access page1 → moves to end
print(f"After get page1:  {cache}")

cache.put("page4", "Contact") # page2 evicted (LRU)
print(f"After add page4:  {cache}")
print(f"page2 in cache: {cache.get('page2') != -1}")

Output

Click "Run" to execute

04 / 10

Counter — Counting Made Easy

collections.Counter is a dict subclass designed for tallying hashable objects. It includes powerful methods for finding top items, combining counts, and set-like operations between tallies.

Creating and using Counter

Pass any iterable — string, list, tuple — to Counter() and it counts element occurrences automatically. Missing keys return 0 (not a KeyError). Counters support arithmetic: adding two counters sums their counts; subtracting removes or zeros out.

Counter(iterable) — count elements in one call
c.most_common(n) — top n elements by count
c.elements() — iterator over elements with repetition
c + d, c - d, c & d, c | d — arithmetic ops

from collections import Counter

# Character frequency analysis
text = "mississippi"
char_freq = Counter(text)

print(f"Character frequencies in '{text}':")
for char, count in char_freq.most_common():
    bar = "█" * count
    print(f"  '{char}': {bar} ({count})")

# Most common characters
top3 = char_freq.most_common(3)
print(f"\nTop 3: {top3}")

# Accessing missing keys returns 0 (no KeyError)
print(f"\n'z' count: {char_freq['z']}")

# elements() — iterate with repetition
print(f"Sorted elements: {''.join(sorted(char_freq.elements()))}")

Output

Click "Run" to execute

Counter arithmetic and inventory tracking

Counter arithmetic is useful for inventory systems, shopping carts, and any scenario where you combine or subtract tallies. The & operator finds the intersection (minimum counts), and | finds the union (maximum counts).

from collections import Counter

# Warehouse inventory
warehouse = Counter({"apples": 50, "bananas": 30, "oranges": 20})
# Customer order
order = Counter({"apples": 8, "bananas": 5, "grapes": 3})

print("Warehouse:", dict(warehouse))
print("Order:", dict(order))

# Process the order
remaining = warehouse - order
print("\nAfter fulfilling order:", dict(remaining))

# Find what we can't fill (grapes not in warehouse)
unfulfillable = order - warehouse
print("Unfulfillable items:", dict(unfulfillable))

# Restock arrival
restock = Counter({"oranges": 40, "grapes": 25, "apples": 10})
warehouse += restock
print("\nAfter restock:", dict(warehouse))

# Items in both warehouse AND order (intersection)
overlap = warehouse & order
print("Items in both:", dict(overlap))

Output

Click "Run" to execute

05 / 10

heapq — Priority Queues

Python's heapq module implements a min-heap on top of a regular list, giving you O(log n) push and pop with the smallest element always at index 0. The secret to priority queues, Dijkstra's algorithm, and efficient top-K problems.

Min-heap fundamentals

A heap is a complete binary tree where every parent is smaller than its children. Python's heapq stores this as a flat list. Always call heapq.heapify() to convert an existing list, and use heappush/heappop to maintain the heap property.

heapq.heappush(heap, item) — add item, O(log n)
heapq.heappop(heap) — remove & return smallest, O(log n)
heapq.heapify(list) — convert list to heap in-place, O(n)
heap[0] — peek at smallest without removing, O(1)

Max-heap trick: Python only has min-heap. For max-heap, negate your values: push -x and negate when popping.

import heapq

# Priority queue: (priority, task_name)
# Lower number = higher priority
task_heap = []
tasks = [
    (3, "Write tests"),
    (1, "Fix critical bug"),
    (4, "Update docs"),
    (2, "Code review"),
    (1, "Deploy hotfix"),
]

for priority, name in tasks:
    heapq.heappush(task_heap, (priority, name))

print("Processing tasks (highest priority first):")
while task_heap:
    priority, name = heapq.heappop(task_heap)
    print(f"  [P{priority}] {name}")

# heapify an existing list
numbers = [5, 1, 8, 3, 9, 2, 7]
heapq.heapify(numbers)
print(f"\nHeapified: {numbers}")
print(f"Smallest element: {numbers[0]}")

# nlargest and nsmallest
data = [15, 3, 42, 7, 19, 1, 88, 23]
print(f"\nTop 3 largest:  {heapq.nlargest(3, data)}")
print(f"Top 3 smallest: {heapq.nsmallest(3, data)}")

Output

Click "Run" to execute

Merging sorted iterables

heapq.merge() combines multiple sorted iterables into a single sorted stream without loading everything into memory — ideal for large data sets.

import heapq

# Merge sorted log files (by timestamp)
server1_logs = [(1, "Request A"), (4, "Request D"), (7, "Request G")]
server2_logs = [(2, "Request B"), (5, "Request E"), (8, "Request H")]
server3_logs = [(3, "Request C"), (6, "Request F"), (9, "Request I")]

merged = heapq.merge(server1_logs, server2_logs, server3_logs)

print("Merged server logs (chronological):")
for timestamp, event in merged:
    source = "S1" if "A" in event or "D" in event or "G" in event else \
             "S2" if "B" in event or "E" in event or "H" in event else "S3"
    print(f"  t={timestamp}  [{source}]  {event}")

# K largest elements using a min-heap of size k
def k_largest(data, k):
    heap = data[:k]
    heapq.heapify(heap)
    for item in data[k:]:
        if item > heap[0]:
            heapq.heapreplace(heap, item)
    return sorted(heap, reverse=True)

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(f"\nTop 4 from {numbers}:")
print(f"  {k_largest(numbers, 4)}")

Output

Click "Run" to execute

06 / 10

bisect — Binary Search

The bisect module provides O(log n) binary search into already-sorted lists, and efficient sorted insertion. Stop linear-scanning sorted data — use bisect to find insertion points in microseconds.

bisect_left and bisect_right

Both functions return the insertion point for a value in a sorted list. bisect_left returns the leftmost position (before any existing equal elements); bisect_right returns the rightmost position (after them). insort combines find and insert in one O(log n) + O(n) call.

bisect.bisect_left(a, x) — index of first item ≥ x
bisect.bisect_right(a, x) — index of first item > x
bisect.insort(a, x) — insert x keeping sorted order
Use the returned index to search efficiently: a[i] == x

import bisect

# Grade assignment using bisect
# Classic recipe from Python docs
breakpoints = [60, 70, 80, 90]
grades      = ["F", "D", "C", "B", "A"]

def letter_grade(score):
    # bisect_right: score 90 → index 4 → "A"
    # score 89 → index 3 → "B"
    return grades[bisect.bisect_right(breakpoints, score)]

scores = [45, 60, 72, 80, 88, 92, 100]
print("Grade calculator:")
for score in scores:
    grade = letter_grade(score)
    bar = "▓" * (score // 10)
    print(f"  {score:3}  {bar}  → {grade}")

# Count how many scores fall in each grade band
from collections import Counter
grade_dist = Counter(letter_grade(s) for s in scores)
print(f"\nGrade distribution: {dict(sorted(grade_dist.items()))}")

Output

Click "Run" to execute

Maintaining a sorted list with insort

bisect.insort() keeps a list sorted as you add items — no need to sort again after each insertion. This is much faster than repeated list.sort() calls when you're inserting items one by one.

import bisect

# Leaderboard that stays sorted automatically
scores = []

def add_score(name, score):
    # insort maintains ascending order
    bisect.insort(scores, (score, name))

def show_leaderboard():
    print("Leaderboard (highest to lowest):")
    for rank, (score, name) in enumerate(reversed(scores), 1):
        print(f"  #{rank}  {name:<12} {score}")

add_score("Alice",   1520)
add_score("Bob",     1380)
add_score("Carol",   1610)
add_score("Dave",    1490)
add_score("Eve",     1610)   # tie with Carol

show_leaderboard()

# Find insertion point for a new score
new_score = 1500
pos = bisect.bisect_left(scores, (new_score,))
print(f"\nA score of {new_score} would rank #{len(scores) - pos + 1}")

Output

Click "Run" to execute

07 / 10

deque — Double-Ended Queue

collections.deque is a thread-safe, O(1) append and pop from both ends. Unlike lists, prepending to a deque does not shift the entire array — making it the right choice for queues, sliding windows, and history buffers.

deque operations

Think of a deque as a double-ended tape. You can add or remove from either end in constant time. The maxlen parameter caps the size — new items push old ones off the opposite end automatically, which is perfect for rolling windows and bounded history.

dq.append(x) / dq.appendleft(x) — add to right/left
dq.pop() / dq.popleft() — remove from right/left
dq.rotate(n) — rotate right by n (negative = left)
deque(maxlen=n) — auto-evicts oldest item on overflow

from collections import deque

class BrowserHistory:
    def __init__(self, max_history=5):
        self.back_stack = deque()
        self.forward_stack = deque()
        self.current = None

    def visit(self, url):
        if self.current:
            self.back_stack.append(self.current)
        self.current = url
        self.forward_stack.clear()
        print(f"  → Visiting: {url}")

    def back(self):
        if self.back_stack:
            self.forward_stack.append(self.current)
            self.current = self.back_stack.pop()
            print(f"  ← Back to: {self.current}")

    def forward(self):
        if self.forward_stack:
            self.back_stack.append(self.current)
            self.current = self.forward_stack.pop()
            print(f"  → Forward to: {self.current}")

browser = BrowserHistory()
browser.visit("google.com")
browser.visit("python.org")
browser.visit("docs.python.org")
browser.back()
browser.back()
browser.forward()
browser.visit("pypi.org")   # clears forward history
print(f"\nCurrent: {browser.current}")
print(f"Can go back: {len(browser.back_stack)} pages")

Output

Click "Run" to execute

Sliding window with maxlen

A deque(maxlen=k) automatically maintains a rolling window of the last k items. As you append new items, the oldest are automatically evicted from the left — no manual slice management needed.

from collections import deque

# Rolling average of sensor readings
def rolling_average(data, window=3):
    window_dq = deque(maxlen=window)
    averages = []
    for value in data:
        window_dq.append(value)
        avg = sum(window_dq) / len(window_dq)
        averages.append(round(avg, 1))
    return averages

temps = [22, 24, 19, 21, 25, 28, 26, 23, 20, 18]
avgs  = rolling_average(temps, window=3)

print("Temperature sensor (rolling 3-day average):")
print(f"{'Day':>4}  {'Temp':>6}  {'3d Avg':>8}")
print("  " + "-" * 22)
for i, (t, a) in enumerate(zip(temps, avgs), 1):
    trend = "↑" if i > 1 and a > avgs[i-2] else "↓" if i > 1 else " "
    print(f"  {i:>2}    {t:>4}°C    {a:>5}°C {trend}")

# Palindrome checker using deque
def is_palindrome(s):
    dq = deque(s.lower().replace(" ", ""))
    while len(dq) > 1:
        if dq.popleft() != dq.pop():
            return False
    return True

words = ["racecar", "hello", "level", "python", "madam"]
print("\nPalindrome check:")
for w in words:
    print(f"  {w:<10} → {is_palindrome(w)}")

Output

Click "Run" to execute

08 / 10

f-strings — Modern String Formatting

F-strings (formatted string literals, introduced in Python 3.6) are the fastest, most readable way to embed expressions in strings. They support inline expressions, format specs, alignment, and even self-documenting debug output with the = suffix.

Expressions and format specs

Any valid Python expression can go inside the curly braces of an f-string. After the expression, add a colon and a format spec: f"{value:.2f}" for two decimal places, f"{value:>10}" for right-aligned in 10 characters, f"{value:,}" for thousands separator.

f"{x:.2f}" — float with 2 decimal places
f"{x:,}" — thousands separator
f"{x:>10}" / f"{x:<10}" / f"{x:^10}" — alignment
f"{x=}" — debug: prints x=value (Python 3.8+)

# Receipt formatter using f-string alignment
items = [
    ("Python Cookbook",      3,  49.99),
    ("Mechanical Keyboard",  1, 189.00),
    ("USB-C Cable",          2,  12.50),
    ("Coffee",               5,   4.75),
]

width = 42
print("=" * width)
print(f"{'RECEIPT':^{width}}")
print("=" * width)
print(f"{'Item':<22} {'Qty':>4} {'Price':>7} {'Total':>8}")
print("-" * width)

subtotal = 0
for name, qty, price in items:
    total = qty * price
    subtotal += total
    print(f"{name:<22} {qty:>4} {price:>7.2f} {total:>8.2f}")

tax      = subtotal * 0.085
grand    = subtotal + tax

print("-" * width)
print(f"{'Subtotal':>34} {subtotal:>8,.2f}")
print(f"{'Tax (8.5%)':>34} {tax:>8,.2f}")
print("=" * width)
print(f"{'TOTAL':>34} {grand:>8,.2f}")
print("=" * width)

Output

Click "Run" to execute

Debugging with = and number formatting

Python 3.8 added the = specifier: f"{x=}" expands to x=42 — the variable name and its value — which is extremely useful for debugging without adding extra print arguments. You can combine it with format specs: f"{x=:.2f}".

import math

# Debug with = specifier (Python 3.8+)
x = 42
radius = 7.5
area = math.pi * radius ** 2

print(f"{x=}")
print(f"{radius=}")
print(f"{area=:.2f}")
print(f"{math.sqrt(x)=:.4f}")

# Number formatting showcase
big_number = 1_234_567.89
print(f"\n{'Format':<20} {'Result'}")
print("-" * 40)
print(f"  {{:,}}            → {big_number:,}")
print(f"  {{:.2f}}          → {big_number:.2f}")
print(f"  {{:,.2f}}         → {big_number:,.2f}")
print(f"  {{:e}}            → {big_number:e}")
print(f"  {{:010.2f}}       → {big_number:010.2f}")

# Nested f-strings for dynamic formatting
align = ">"
width = 12
value = 99.5
print(f"\nDynamic alignment: '{f'{value:{align}{width}.1f}'}'")

# Binary, hex, octal
n = 255
print(f"\n{n} in different bases:")
print(f"  Binary:  {n:b}")
print(f"  Octal:   {n:o}")
print(f"  Hex:     {n:x}  (or uppercase: {n:X})")

Output

Click "Run" to execute

09 / 10

Comprehensions — Pythonic Iteration

Comprehensions are concise, readable syntax for building collections by transforming and filtering iterables. Python supports list, dict, set, and generator comprehensions — each unlocking a different pattern for writing expressive, fast, idiomatic Python.

List, dict, and set comprehensions

The formula is always: [expression for item in iterable if condition]. The if condition part is optional. Dict comprehensions use {key: value for ...}; set comprehensions use {value for ...}.

[x**2 for x in range(10)] — list of squares
{k: v for k, v in d.items() if v > 0} — filter a dict
{word.lower() for word in text.split()} — unique lowercase words
Comprehensions are 20–50% faster than equivalent for-loop + append

# Data pipeline: transform, filter, aggregate

sales = [
    {"name": "Alice", "amount": 1200, "region": "North"},
    {"name": "Bob",   "amount":  450, "region": "South"},
    {"name": "Carol", "amount": 2100, "region": "North"},
    {"name": "Dave",  "amount":  800, "region": "East"},
    {"name": "Eve",   "amount": 1750, "region": "South"},
]

# List comprehension: filter high performers
high_performers = [s["name"] for s in sales if s["amount"] > 1000]
print(f"High performers (>$1000): {high_performers}")

# Dict comprehension: name → amount mapping
name_to_amount = {s["name"]: s["amount"] for s in sales}
print(f"\nSales map: {name_to_amount}")

# Set comprehension: unique regions
regions = {s["region"] for s in sales}
print(f"Regions: {regions}")

# Dict comprehension: total by region
from collections import defaultdict
by_region = defaultdict(int)
for s in sales:
    by_region[s["region"]] += s["amount"]

# Dict comprehension to format the result
formatted = {k: f"${v:,}" for k, v in sorted(by_region.items())}
print(f"\nRevenue by region: {formatted}")

Output

Click "Run" to execute

Nested comprehensions and generators

Comprehensions can be nested for matrix operations or flattening structures. Generator expressions use () instead of [] and are lazy — they compute one item at a time, using almost no memory. Use generators when you only iterate once and don't need the full list in memory.

Tip: Pass a generator expression directly to sum(), any(), all(), min(), max() — no brackets needed: sum(x**2 for x in data)

# Matrix operations with nested comprehensions

# Create a 4x4 identity matrix
n = 4
identity = [[1 if i == j else 0 for j in range(n)] for i in range(n)]

print("4×4 Identity matrix:")
for row in identity:
    print("  " + "  ".join(str(x) for x in row))

# Matrix transpose
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transpose = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

print("\nOriginal matrix:")
for row in matrix:
    print(" ", row)
print("Transposed:")
for row in transpose:
    print(" ", row)

# Flatten a nested list
nested = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat = [x for sublist in nested for x in sublist]
print(f"\nFlattened: {flat}")

# Generator expression — memory efficient
numbers = range(1, 1001)
total   = sum(x**2 for x in numbers if x % 3 == 0)
print(f"\nSum of squares (multiples of 3, 1-1000): {total:,}")

# any() / all() with generators
data = [2, 4, 6, 8, 10, 11]
print(f"All even: {all(x % 2 == 0 for x in data)}")
print(f"Any odd:  {any(x % 2 != 0 for x in data)}")

Output

Click "Run" to execute

10 / 10

dataclass — Modern Data Containers

@dataclass (Python 3.7+) automatically generates __init__, __repr__, and __eq__ from field annotations — eliminating boilerplate for data-holding classes while adding optional ordering, freezing (immutability), and post-init validation.

Basic dataclass usage

Annotate class-level variables with types and decorate with @dataclass. Python generates __init__ with matching parameters automatically. Use field(default_factory=list) for mutable defaults — never use mutable defaults directly (same rule as regular function arguments).

@dataclass — generates __init__, __repr__, __eq__
@dataclass(frozen=True) — immutable (hashable, usable as dict key)
@dataclass(order=True) — generates <, >, etc.
field(default_factory=list) — safe mutable default
__post_init__ — runs after __init__ for validation

from dataclasses import dataclass, field

@dataclass
class Product:
    name:     str
    price:    float
    category: str = "General"
    tags:     list = field(default_factory=list)

    def discounted(self, pct):
        return self.price * (1 - pct / 100)

# __init__ is auto-generated
laptop = Product("ThinkPad X1", 1299.99, "Electronics", ["work", "portable"])
mouse  = Product("MX Master 3", 99.99, "Electronics")
book   = Product("Fluent Python", 49.99)

print(laptop)       # __repr__ is auto-generated
print(mouse)
print(book)

# __eq__ compares field values
p1 = Product("Widget", 9.99)
p2 = Product("Widget", 9.99)
print(f"\np1 == p2: {p1 == p2}")  # True — compares fields, not identity

# Method usage
print(f"\n{laptop.name} at 15% off: ${laptop.discounted(15):.2f}")

Output

Click "Run" to execute

Frozen dataclasses, ordering, and __post_init__

frozen=True makes instances immutable and hashable — you can use them as dictionary keys or in sets. order=True generates comparison methods based on field order. __post_init__ runs validation or derived-field computation right after __init__.

from dataclasses import dataclass, field
from typing import ClassVar

# Frozen + ordered: playing cards
@dataclass(frozen=True, order=True)
class Card:
    rank: int   # sort key (compared first)
    suit: str

    SUITS: ClassVar = {"♠": "Spades", "♥": "Hearts", "♦": "Diamonds", "♣": "Clubs"}
    RANKS: ClassVar = {1: "A", 11: "J", 12: "Q", 13: "K"}

    def __str__(self):
        rank_str = self.RANKS.get(self.rank, str(self.rank))
        return f"{rank_str}{self.suit}"

# Create a hand of cards
hand = [Card(10, "♠"), Card(1, "♥"), Card(13, "♣"), Card(7, "♦"), Card(1, "♠")]
print("Hand:", " ".join(str(c) for c in hand))
print("Sorted:", " ".join(str(c) for c in sorted(hand)))

# Frozen → hashable → usable in sets
unique = set(hand)
print(f"Unique cards: {len(unique)}")

# __post_init__ for validation
@dataclass
class Config:
    host:    str
    port:    int = 8080
    timeout: int = 30
    url:     str = field(init=False)  # derived field

    def __post_init__(self):
        if not (1 <= self.port <= 65535):
            raise ValueError(f"Invalid port: {self.port}")
        self.url = f"http://{self.host}:{self.port}"

cfg = Config("localhost", 3000)
print(f"\nConfig: {cfg}")
print(f"URL: {cfg.url}")

Output

Click "Run" to execute

Inventory system — putting it all together

A real-world example combining dataclass with field(default_factory), __post_init__ validation, and methods for a complete inventory management system.

from dataclasses import dataclass, field

@dataclass
class Item:
    name:     str
    price:    float
    quantity: int = 0

    def __post_init__(self):
        if self.price < 0:
            raise ValueError(f"Price cannot be negative: {self.price}")

    @property
    def value(self):
        return self.price * self.quantity

    def restock(self, qty):
        self.quantity += qty
        return self

    def sell(self, qty):
        if qty > self.quantity:
            raise ValueError(f"Only {self.quantity} '{self.name}' in stock")
        self.quantity -= qty
        return self

@dataclass
class Inventory:
    items: list = field(default_factory=list)

    def add(self, item):
        self.items.append(item)

    def total_value(self):
        return sum(i.value for i in self.items)

    def low_stock(self, threshold=5):
        return [i for i in self.items if i.quantity < threshold]

    def report(self):
        print(f"{'Item':<20} {'Price':>8} {'Qty':>6} {'Value':>10}")
        print("-" * 48)
        for item in sorted(self.items, key=lambda x: -x.value):
            print(f"{item.name:<20} {item.price:>8.2f} {item.quantity:>6} {item.value:>10.2f}")
        print("-" * 48)
        print(f"{'TOTAL VALUE':>36} {self.total_value():>10.2f}")

inv = Inventory()
inv.add(Item("Laptop",     999.99).restock(10))
inv.add(Item("Mouse",       29.99).restock(50))
inv.add(Item("Keyboard",    79.99).restock(3))
inv.add(Item("Monitor",    349.99).restock(7))

inv.items[0].sell(3)
inv.report()

low = inv.low_stock()
print(f"\nLow stock alert: {[i.name for i in low]}")

Output

Click "Run" to execute

Master Python'sEssential Data Structures

How to use this tutorial

Try it now

dict — Python Dictionaries

Creating and accessing dictionaries

Advanced dict features

Nested dictionaries

defaultdict — Auto-Initializing Dicts

The problem with regular dicts

Graph adjacency list with defaultdict

OrderedDict — Ordered Dictionaries

When to use OrderedDict over dict

LRU Cache implementation

Counter — Counting Made Easy

Creating and using Counter

Counter arithmetic and inventory tracking

heapq — Priority Queues

Min-heap fundamentals

Merging sorted iterables

bisect — Binary Search

bisect_left and bisect_right

Maintaining a sorted list with insort

deque — Double-Ended Queue

deque operations

Sliding window with maxlen

f-strings — Modern String Formatting

Expressions and format specs

Debugging with = and number formatting

Comprehensions — Pythonic Iteration

List, dict, and set comprehensions

Nested comprehensions and generators

dataclass — Modern Data Containers

Basic dataclass usage

Frozen dataclasses, ordering, and __post_init__

Inventory system — putting it all together

Master Python's
Essential Data Structures