Reference library

Dictionaries & sets

Key–value maps, uniqueness, counting, grouping, and fast lookups.

6 matches

Build a Case-Insensitive Dict with a Wrapper Class in Python

Create a custom dict subclass that treats keys as case-insensitive by normalizing them to lowercase, with a full set of common dict methods.

dictionary case-insensitive wrapper

Python

class CaseInsensitiveDict:
    def __init__(self, data=None):
        self._data = {}
        if data:
            self.update(data)

    def __setitem__(self, key, value):
        self._data[str(key).lower()] = value

    def __getitem__(self, key):
        return self._data[str(key).lower()]

    def __delitem__(sel…

15 0 Open

Dictionaries & sets medium

Find All Leaf Paths in a Nested Dict in Python

Recursively traverse a nested dictionary and yield every leaf path as a list of keys, including paths to empty dictionaries.

dictionary recursion nested-data

Python

def find_leaf_paths(data, path=None):
    if path is None:
        path = []
    
    if not isinstance(data, dict) or not data:
        yield path
        return
    
    for key, value in data.items():
        yield from find_leaf_paths(value, path + [key])

if __name__ == "__main__":
    nested = {
        "a": 1,
…

13 0 Open

Dictionaries & sets medium

How to Build a Two-Way Dictionary in Python

Implement a BiDict class that supports both forward key-to-value and reverse value-to-key lookups with a simple add, delete, and update API.

dictionary bidirectional class

Python

class BiDict:
    def __init__(self, data=None):
        self.forward = {}
        self.backward = {}
        if data:
            self.update(data)

    def update(self, data):
        for key, value in data.items():
            self[key] = value

    def __setitem__(self, key, value):
        self.forward[key] = val…

11 0 Open

Dictionaries & sets medium

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.

disjoint-set union-find graph

Python

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…

14 0 Open

Dictionaries & sets medium

How to Recursively Remove None Values from Nested Dictionaries in Python

Recursively removes all None values from nested dictionaries and lists while preserving non-None data.

dictionaries recursion data-cleaning

Python

def prune_none(obj):
    if isinstance(obj, dict):
        return {
            k: prune_none(v)
            for k, v in obj.items()
            if v is not None and prune_none(v) is not None
        }
    elif isinstance(obj, list):
        pruned = [prune_none(item) for item in obj]
        pruned = [item for item i…

15 0 Open

Dictionaries & sets medium

LRU Cache with OrderedDict in Python

Implement an LRU cache using collections.OrderedDict to track insertion order and evict the least-recently-used item when capacity is exceeded.

lru-cache ordereddict caching

Python

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)
        return self.cache[key]

    def put(sel…

14 0 Open

Browse by section

Each section groups closely related Python snippets.