How to split Python dictionary into multiple keys, dividing the values equally?

Sometimes you need to distribute dictionary values equally across new keys. This is useful for data partitioning, load balancing, or creating balanced datasets from existing data structures.

Basic Dictionary Splitting

Here's how to split a dictionary into multiple keys with equal distribution of values ?

# Original dictionary
data = {'items': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}
num_splits = 3

# Calculate chunk size
chunk_size = len(data['items']) // num_splits
remainder = len(data['items']) % num_splits

# Split the values
result = {}
start = 0

for i in range(num_splits):
    # Add one extra item to first 'remainder' chunks
    current_chunk_size = chunk_size + (1 if i < remainder else 0)
    end = start + current_chunk_size
    
    result[f'items_{i+1}'] = data['items'][start:end]
    start = end

print(result)

{'items_1': [1, 2, 3, 4], 'items_2': [5, 6, 7, 8], 'items_3': [9, 10]}

Using a Function for Reusability

Create a reusable function to split any dictionary key ?

def split_dict_values(dictionary, key, num_splits):
    """Split dictionary values into multiple keys equally"""
    if key not in dictionary:
        return dictionary
    
    values = dictionary[key]
    chunk_size = len(values) // num_splits
    remainder = len(values) % num_splits
    
    # Remove original key
    result = {k: v for k, v in dictionary.items() if k != key}
    
    start = 0
    for i in range(num_splits):
        current_chunk_size = chunk_size + (1 if i < remainder else 0)
        end = start + current_chunk_size
        result[f'{key}_{i+1}'] = values[start:end]
        start = end
    
    return result

# Example usage
original = {'products': ['A', 'B', 'C', 'D', 'E', 'F', 'G'], 'category': 'electronics'}
split_result = split_dict_values(original, 'products', 3)
print(split_result)

{'category': 'electronics', 'products_1': ['A', 'B', 'C'], 'products_2': ['D', 'E'], 'products_3': ['F', 'G']}

Handling Multiple Keys

Split multiple dictionary keys simultaneously ?

def split_multiple_keys(dictionary, keys_to_split, num_splits):
    """Split multiple dictionary keys into equal parts"""
    result = {k: v for k, v in dictionary.items() if k not in keys_to_split}
    
    for key in keys_to_split:
        if key in dictionary:
            values = dictionary[key]
            chunk_size = len(values) // num_splits
            remainder = len(values) % num_splits
            
            start = 0
            for i in range(num_splits):
                current_chunk_size = chunk_size + (1 if i < remainder else 0)
                end = start + current_chunk_size
                result[f'{key}_{i+1}'] = values[start:end]
                start = end
    
    return result

# Example with multiple keys
data = {
    'numbers': [1, 2, 3, 4, 5, 6, 7, 8],
    'letters': ['a', 'b', 'c', 'd', 'e', 'f'],
    'metadata': 'important'
}

split_data = split_multiple_keys(data, ['numbers', 'letters'], 2)
print(split_data)

{'metadata': 'important', 'numbers_1': [1, 2, 3, 4], 'numbers_2': [5, 6, 7, 8], 'letters_1': ['a', 'b', 'c'], 'letters_2': ['d', 'e', 'f']}

Using List Comprehension

A more concise approach using list comprehension ?

def split_dict_compact(dictionary, key, num_splits):
    """Compact version using list comprehension"""
    if key not in dictionary:
        return dictionary
    
    values = dictionary[key]
    chunk_size = len(values) // num_splits
    remainder = len(values) % num_splits
    
    # Create chunks
    chunks = []
    start = 0
    for i in range(num_splits):
        current_size = chunk_size + (1 if i < remainder else 0)
        chunks.append(values[start:start + current_size])
        start += current_size
    
    # Build result dictionary
    result = {k: v for k, v in dictionary.items() if k != key}
    result.update({f'{key}_{i+1}': chunk for i, chunk in enumerate(chunks)})
    
    return result

# Example usage
test_dict = {'scores': [95, 87, 92, 78, 85, 90, 88]}
split_scores = split_dict_compact(test_dict, 'scores', 3)
print(split_scores)

{'scores_1': [95, 87, 92], 'scores_2': [78, 85], 'scores_3': [90, 88]}

Comparison of Approaches

Conclusion

Dictionary splitting is useful for data partitioning and load distribution. Use the function approach for reusability or list comprehension for concise code. Always handle remainder elements to ensure equal distribution.