如何使用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表示鍵值對的數量。