Dictionaries & sets
Key–value maps, uniqueness, counting, grouping, and fast lookups.
How to Count Co-occurrence Pairs in Python with Nested Dictionaries
This code counts how often any two items appear together in the same group, using a nested defaultdict keyed by item pairs.
from itertools import combinations
from collections import defaultdict
def count_cooccurrences(items_per_group):
cooccurrence = defaultdict(lambda: defaultdict(int))
for group in items_per_group:
for a, b in combinations(sorted(group), 2):
cooccurrence[a][b] += 1
cooccurrence[b…How to Count Elements and Find Duplicates in a Python List
Count occurrences of each element in a list, extract unique values, and identify duplicates using Python dictionaries and sets.
def analyze_counts(data):
"""Count elements, return unique values, and find duplicates."""
# Count occurrences using a dictionary
counts = {}
for item in data:
counts[item] = counts.get(item, 0) + 1
# Alternative compact approach with set
unique_items = set(data)
# Fi…How to Count Tags with Sets and Dictionaries in Python
Count tag frequencies and collect unique tags from a list of dictionaries using Counter and sets in Python.
from collections import Counter
import json
def count_tags(entries):
"""Count tag frequencies across a list of entry dicts, using sets/dicts."""
tag_counter = Counter()
all_tags = set()
for entry in entries:
tags = set(entry["tags"])
all_tags.update(tags)
tag_counter.update(ta…How to Count Word Frequencies in Python
Count how often each word appears in a string and list the unique words using Python dictionaries and sets.
def text_processor(text):
words = text.lower().split()
word_count = {}
for word in words:
word_count[word] = word_count.get(word, 0) + 1
unique_words = set(words)
return word_count, unique_words
if __name__ == "__main__":
sample_text = "The quick brown fox jumps over the lazy dog and t…How to Count Word Frequencies in Python with Counter and Sets
This code processes a text string by lowercasing, splitting into words, counting frequencies with Counter, and extracting unique and sorted word lists using sets.
from collections import Counter
def process_text(text):
words = text.lower().split()
word_counts = Counter(words)
unique_words = set(words)
sorted_words = sorted(unique_words)
return {
"total_words": len(words),
"unique_words": len(unique_words),
"word_frequencies": di…How to Count Words and Find Common Words in Python with Dictionaries and Sets
Build a simple text processor that counts unique words with dictionaries and finds common words across text halves using sets.
def process_text(text):
"""Process text: count unique words with counts, find common words."""
words = text.lower().replace(",", "").replace(".", "").split()
word_counts = {}
for word in words:
word_counts[word] = word_counts.get(word, 0) + 1
total_words = len(words)
unique_wo…How to Create a Dict from Two Parallel Lists in Python (zip)
Build a dictionary by pairing elements from two parallel lists using Python's built-in zip function and dict constructor.
keys = ["name", "age", "city"]
values = ["Alice", 30, "New York"]
result = dict(zip(keys, values))
print(result)How to Deep Merge Nested Dicts Recursively in Python
Recursively merge two Python dictionaries, with overlay values taking precedence while preserving nested structures.
def deep_merge(base, overlay):
"""
Recursively merge two dictionaries.
Values in 'overlay' take precedence over 'base'.
"""
result = base.copy()
for key, value in overlay.items():
if key in result and isinstance(result[key], dict) and isinstance(value, dict):
result[key…How to Diff Two Dicts in Python: Added, Removed, and Changed Keys
Compare two dictionaries and report added, removed, and changed keys using Python's set operations on dict keys.
def diff_dicts(old: dict, new: dict) -> dict:
"""Compare two dicts and report added, removed, and changed keys."""
added = {k: new[k] for k in new.keys() - old.keys()}
removed = {k: old[k] for k in old.keys() - new.keys()}
common_keys = old.keys() & new.keys()
changed = {k: (old[k], new[k]) for k …How to Extract Data by Category in Python with Dictionaries and Sets
Use set comprehensions and a defaultdict to extract product names by category and compute total prices per category from a list of dictionaries.
from collections import defaultdict
# Sample data: products with categories and prices
product_data = [
{"name": "Apple", "category": "fruit", "price": 0.50},
{"name": "Banana", "category": "fruit", "price": 0.30},
{"name": "Carrot", "category": "vegetable", "price": 0.80},
{"name": "Bread", "category…How to Filter a Dictionary by Predicate on Values in Python
This code defines a reusable function that builds a new dictionary containing only the items whose values satisfy a given predicate function.
def filter_dict_by_predicate(d, predicate):
"""Return a new dict with only items whose value passes the predicate."""
return {k: v for k, v in d.items() if predicate(v)}
if __name__ == "__main__":
scores = {"Alice": 85, "Bob": 42, "Charlie": 91, "Diana": 60}
# Keep only values greater than or equal t…How to Filter a List of Dictionaries by Category in Python
Filter a list of dictionaries to include only records whose category is in an allowed set.
def filter_data(records, categories):
"""Return only records whose category is in the allowed set."""
allowed = set(categories)
filtered = []
for record in records:
if record["category"] in allowed:
filtered.append(record)
return filtered
if __name__ == "__main__":
data = …How to Find Keys with Matching Values in Two Dictionaries in Python
Find dictionary keys where both dictionaries have the exact same value by iterating over key-value pairs and comparing them.
def find_matching_values(dict1, dict2):
"""Return list of keys that have the same value in both dicts."""
matches = []
for key, value in dict1.items():
if key in dict2 and dict2[key] == value:
matches.append(key)
return matches
if __name__ == "__main__":
# Example usage
di…How to Find Symmetric Difference Between Two Python Sets
Compute elements unique to each set and build a flag dictionary showing membership across two Python sets.
def symmetric_difference_with_flags(set_a, set_b):
"""Return elements in either set but not both, grouped by which set they came from."""
only_in_a = set_a - set_b
only_in_b = set_b - set_a
print(f"Only in A: {only_in_a}")
print(f"Only in B: {only_in_b}")
print(f"Symmetric difference: {onl…How to Find the Intersection of Permission Sets in Python
This code defines a function that takes a list of permission sets and returns a set containing only the permissions common to all sets, with a short-circuit for empty results.
from typing import Set
def intersect_permissions(permission_sets: list[Set[str]]) -> Set[str]:
"""
Given a list of permission sets, return the common permissions
present in every set.
"""
if not permission_sets:
return set()
common = permission_sets[0]
for perm_set in permissi…How to Group Data by Category in Python with a Split Data Helper
This code groups a list of (category, item) pairs into a dictionary where each key is a category and each value is a list of items belonging to that category.
def split_data(categories):
"""
Group data items into buckets based on a key function.
Returns a dict where keys are bucket names and values are lists of items.
"""
buckets = {}
for category, item in categories:
if category not in buckets:
buckets[category] = []
buck…How to Group a List of Dictionaries by Key in Python
Group a list of dictionaries by a specified key field using dict.setdefault to build a dictionary of lists.
def group_by_key(records, key):
grouped = {}
for record in records:
grouped.setdefault(record[key], []).append(record)
return grouped
if __name__ == "__main__":
data = [
{"name": "Alice", "dept": "engineering"},
{"name": "Bob", "dept": "sales"},
{"name": "Carol", "dept"…How to Implement Disjoint Set Union Find in Python
Implement a Disjoint Set Union-Find data structure using a Python dictionary for parent tracking, with path compression and connectivity checks.
class DisjointSet:
def __init__(self):
self.parent = {}
def find(self, x):
# Path compression
if self.parent[x] != x:
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def union(self, x, y):
# Initialize if not present
if x not in…How to Index a List of Records by Unique ID in Python
Build a dictionary that maps each record's unique id to the record itself from a list of dictionaries.
from typing import List, Dict, Any
def index_by_id(records: List[Dict[str, Any]], id_field: str = "id") -> Dict[Any, Dict[str, Any]]:
"""Build a dictionary mapping each record's unique id to the record itself."""
return {record[id_field]: record for record in records}
if __name__ == "__main__":
sample_re…How to Invert a Dictionary in Python Safely
Swap dictionary keys and values while detecting duplicate values to prevent silent data loss.
def invert_dict_safely(d):
inverted = {}
for key, value in d.items():
if value not in inverted:
inverted[value] = key
else:
raise ValueError(f"Duplicate value '{value}' would cause data loss")
return inverted
if __name__ == "__main__":
sample = {"a": 1, "b": 2,…How to Map Dictionary Values with a Transformation Function in Python
Create a reusable function that applies a transformation to every value in a dictionary and returns a new dict.
def transform_dict_values(d, func):
"""Apply a transformation function to every value in a dictionary."""
return {key: func(value) for key, value in d.items()}
if __name__ == "__main__":
original = {"a": 1, "b": 2, "c": 3}
doubled = transform_dict_values(original, lambda x: x * 2)
print(doubled)
…How to Merge Dictionaries and Find Unique Keys in Python
Merge two dictionaries with update(), then use sets to find all unique keys and the keys shared between both dictionaries.
def merge_and_unique(dict1, dict2):
merged = dict1.copy()
merged.update(dict2)
unique_keys = set(merged.keys())
common_keys = set(dict1.keys()) & set(dict2.keys())
return merged, unique_keys, common_keys
if __name__ == "__main__":
fruits = {"apple": 3, "banana": 5, "orange": 2}
more_fruit…How to Merge Two Dictionaries in Python with the Spread Operator
Merge two Python dictionaries into one new dict using the ** unpacking (spread) operator, with later keys overriding earlier ones.
def merge_two_dicts(dict1: dict, dict2: dict) -> dict:
"""Merge two dictionaries using the spread operator pattern."""
# The ** operator unpacks key-value pairs, later keys overwrite earlier ones
merged = {**dict1, **dict2}
return merged
if __name__ == "__main__":
# Example usage with overlapping…How to Normalize Data in Python with Dictionaries and Sets
Normalize a list of dicts by keeping selected keys, stripping/lowercasing strings, and extracting unique sorted values using set comprehension.
def normalize_data(data, keys):
"""
Normalize a list of dictionaries by keeping only specified keys
and converting values to proper types.
"""
normalized = []
for item in data:
clean_item = {}
for key in keys:
value = item.get(key)
if isinstance(value, st…Browse by section
Each section groups closely related Python snippets.
Dictionaries & sets — Python code examples
What you will find here
This page collects dictionaries & sets snippets — short, copy-ready Python you can paste into our free online IDE and run without installing anything. Each sample includes a plain-English explanation and the full source code.
Samples vs tutorials and challenges
Samples are quick reference — one concept per page. For step-by-step teaching, use our Python tutorials. To test yourself, try quizzes or coding challenges. Clean up style with the Python formatter.