如何使用Python将字典转换为K个大小的字典？

---

字典是Python中的键值对数据结构，其中键是唯一的，值可以重复或不重复。键和值可以是任何数据类型。在本文中，我们将了解如何使用Python将字典转换为K个大小的字典，这意味着我们将一个字典分成k个较小的字典，其中k是任何正数，即k>0。

示例

假设输入字典为 d = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'x': 8, 'y': 9}

相应的输出应该是 {'a': 1, 'b': 2, 'c': 3}, {'d': 4, 'e': 5, 'f': 6}, {'g': 7, 'x': 8, 'y': 9}

输入字典d的大小为9，因为它有9个键值对，我们只需将d分成3个较小的字典，每个字典的大小为3。

方法1：朴素方法

朴素方法通常是任何给定问题陈述中最简单或最不复杂的方法，不应将其作为解决方案。例如，当应用于字典转换时，这可能涉及遍历原始字典中的所有键，并使用基本的索引计算将它们均匀地分散到K个大小的字典中。

示例

def convert_dict_to_k_sized_dicts(dictionary, k):
    result = [{} for _ in range(k)]  # Initialize a list of empty dictionaries    
    keys = list(dictionary.keys())  # Get the keys of the original dictionary
    num_keys = len(keys)    
    for i in range(num_keys):
        key = keys[i]
        value = dictionary[key]    
	      # Determine the index of the dictionary to store the key-value pair    
        index = i % k
        # Add the key-value pair to the respective dictionary          
        result[index][key] = value      
    return result
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7,'x':8,'y':9}
k = 3
result = convert_dict_to_k_sized_dicts(my_dict, k)
print(result)

输出

[{'a': 1, 'd': 4, 'g': 7}, {'b': 2, 'e': 5, 'x': 8}, {'c': 3, 'f': 6, 'y': 9}]

方法2：使用itertools.cycle

Python的itertools模块提供了一个函数itertools.cycle()，它创建一个迭代器，可以无限循环遍历可迭代对象的元素。调用该函数时，它返回一个迭代器，该迭代器以循环方式重复返回可迭代对象中的元素，简单来说，一旦达到可迭代对象的末尾，它就会从开头重新开始，因此允许我们迭代元素而无需手动实现循环逻辑。

使用next()函数获取迭代器中的下一个项目。当提供迭代器作为参数时，将返回迭代器中的下一个项目。每次调用next()时，迭代器都会前进，并且还会返回下一个项目。next()经常用于循环中，以遍历迭代器的项目，直到处理完每个项目。当迭代器中没有更多项目时，调用next()会产生StopIteration异常，表示迭代结束。

itertools.cycle()和next()可以一起使用以创建循环迭代模式。

示例

import itertools

def convert_dict_to_k_sized_dicts(dictionary, k):
    result = [{} for _ in range(k)]    
    keys = list(dictionary.keys())
    num_keys = len(keys)    
    key_cycle = itertools.cycle(range(k))
    for i, key in enumerate(keys):
        value = dictionary[key]
        index = next(key_cycle)
        result[index][key] = value    
    return result
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'x': 8, 'y': 9}
k = 3
result = convert_dict_to_k_sized_dicts(my_dict, k)
print(result)

输出

[{'a': 1, 'd': 4, 'g': 7}, {'b': 2, 'e': 5, 'x': 8}, {'c': 3, 'f': 6, 'y': 9}]

方法3：使用字典推导和enumerate

字典推导提供了一种在Python中创建紧凑/可读字典的有效方法，而enumerate()提供了一种更简单的遍历可迭代对象的方法，同时跟踪其索引号和内容；返回一个产生索引/值对的迭代器，允许在迭代期间轻松访问这两个元素。

示例

def convert_dict_to_k_sized_dicts(dictionary, k):
    result = [{} for _ in range(k)]    
    for i, (key, value) in enumerate(dictionary.items()):
        index = i % k
        result[index][key] = value    
    return result

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'x': 8, 'y': 9}
k = 3
result = convert_dict_to_k_sized_dicts(my_dict, k)
print(result)

输出

[{'a': 1, 'd': 4, 'g': 7}, {'b': 2, 'e': 5, 'x': 8}, {'c': 3, 'f': 6, 'y': 9}]

方法4：使用列表推导和切片

只需定义一个表达式并遍历一个或多个可迭代对象，就可以使用列表推导创建列表。在本例中，列表推导有助于生成一个字典列表，每个字典都是使用字典推导创建的，该字典推导遍历由切片确定的键和值列表的子集，并帮助选择k间隔的元素。

示例

def convert_dict_to_k_sized_dicts(dictionary, k):
    keys = list(dictionary.keys())
    values = list(dictionary.values())
    return [{keys[i]: values[i] for i in range(start, len(keys), k)} for start in range(k)]

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'x': 8, 'y': 9}
k = 3
result = convert_dict_to_k_sized_dicts(my_dict, k)
print(result)

输出

[{'a': 1, 'd': 4, 'g': 7}, {'b': 2, 'e': 5, 'x': 8}, {'c': 3, 'f': 6, 'y': 9}]

方法5：使用numpy.array_split

可以使用数据处理模块Numpy的array_split()函数沿指定轴将数组分成多个子数组。它的输入是一个数组和所需数量的具有相同大小的分割，其输出是一个子数组列表。由于我们将字典分成k个相等的段，因此该函数在此情况下非常有用，因为它消除了任何手动计算或索引的需要。

示例

import numpy as np

def convert_dict_to_k_sized_dicts(dictionary, k):
    keys = list(dictionary.keys())
    values = list(dictionary.values())
    result = []
    for group in np.array_split(range(len(keys)), k):
        sub_dict = {keys[i]: values[i] for i in group}
        result.append(sub_dict)
    return result

my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'x': 8, 'y': 9}
k = 3
result = convert_dict_to_k_sized_dicts(my_dict, k)
print(result)

输出

[{'a': 1, 'b': 2, 'c': 3}, {'d': 4, 'e': 5, 'f': 6}, {'g': 7, 'x': 8, 'y': 9}]

方法6：使用zip和解包

可以使用解包方法从可迭代对象中删除组件或将变量应用于序列。借助Python方法zip()，可以有效地将多个可迭代对象组合成元素对元素的元组。组合使用时，zip()和解包函数允许同时处理来自多个可迭代对象的相关项。

示例

def convert_dict_to_k_sized_dicts(dictionary, k):
    keys = list(dictionary.keys())
    values = list(dictionary.values())
    result = [dict(zip(keys[start::k], values[start::k])) for start in range(k)]
    return result

my_dict = {'abb': 1, 'xyz': 2, 'cat': 3, 'dog': 4, 'elephant': 5, 'frog': 6, 'garlic': 7, 'x': 8, 'y': 9}
k = 3
result = convert_dict_to_k_sized_dicts(my_dict, k)
print(result)

输出

[{'abb': 1, 'dog': 4, 'garlic': 7}, {'xyz': 2, 'elephant': 5, 'x': 8}, {'cat': 3, 'frog': 6, 'y': 9}]

结论

我们已经介绍了多种方法来将Python中的字典转换为k个大小的字典。这些方法包括朴素方法；使用itertools.cycle()；使用字典推导；xenumerate()；使用列表推导和切片；使用numpy.array_split()，最后使用zip()和解包。所有方法的时间复杂度都相同，为O(n)，其中n表示键值对的数量。