# Python | Get first N key:value pairs in given dictionary

Last Updated : 12 Apr, 2023

Given a dictionary, the task is to get N key: value pairs from given dictionary. This type of problem can be useful while some cases, like fetching first N values in web development. Note that the given dictionary is unordered, the first N pairs will not be same here all the time. In case, you need to maintain order in your problem, you can use ordered dictionary.

Code #1: Using itertools.islice() method

## Python3

 `# Python program to get N key:value pairs in given dictionary ` `# using itertools.islice() method `   `import` `itertools ` `    `  `# Initialize dictionary ` `test_dict ``=` `{``'Geeks'` `: ``1``, ``'For'``:``2``, ``'is'` `: ``3``, ``'best'` `: ``4``, ``'for'` `: ``5``, ``'CS'` `: ``6``} ` `    `  `# printing original dictionary ` `print``(``"The original dictionary : "` `+` `str``(test_dict)) ` `    `  `# Initialize limit ` `N ``=` `3` `    `  `# Using islice() + items() ` `# Get first N items in dictionary ` `out ``=` `dict``(itertools.islice(test_dict.items(), N)) ` `        `  `# printing result ` `print``(``"Dictionary limited by K is : "` `+` `str``(out)) `

Output

```The original dictionary : {'Geeks': 1, 'For': 2, 'is': 3, 'best': 4, 'for': 5, 'CS': 6}
Dictionary limited by K is : {'Geeks': 1, 'For': 2, 'is': 3}```

Time complexity: O(N) where N is the number of items to be retrieved from the dictionary.
Auxiliary space: O(N)

Code #2: Using slicing on dictionary item list

## Python3

 `# Python program to get N key:value pairs in given dictionary ` `# using list slicing ` `    `  `# Initialize dictionary ` `test_dict ``=` `{``'Geeks'` `: ``1``, ``'For'``:``2``, ``'is'` `: ``3``, ``'best'` `: ``4``, ``'for'` `: ``5``, ``'CS'` `: ``6``} ` `    `  `# printing original dictionary ` `print``(``"The original dictionary : "` `+` `str``(test_dict)) ` `    `  `# Initialize limit ` `N ``=` `3` `    `  `# Using items() + list slicing ` `# Get first K items in dictionary ` `out ``=` `dict``(``list``(test_dict.items())[``0``: N]) ` `        `  `# printing result ` `print``(``"Dictionary limited by K is : "` `+` `str``(out)) `

Output

```The original dictionary : {'Geeks': 1, 'For': 2, 'is': 3, 'best': 4, 'for': 5, 'CS': 6}
Dictionary limited by K is : {'Geeks': 1, 'For': 2, 'is': 3}```

Time complexity : O(n)
Auxiliary Space: O(n)

Code #3: Using OrderedDict

## Python3

 `# Python program to get N key:value pairs in given dictionary` `# using OrderedDict` `  `  `# importing "collections" for Ordereddict ` `import` `collections ` `    `  `# Initialize dictionary` `test_dict ``=` `{``'Geeks'` `: ``1``, ``'For'``:``2``,  ``'is'` `: ``3``, ``'best'` `: ``4``, ``'for'` `: ``5``, ``'CS'` `: ``6``} ` `    `  `# printing original dictionary ` `print``(``"The original dictionary : "` `+`  `str``(test_dict)) ` `    `  `# Initialize limit ` `N ``=` `3` `    `  `# Using OrderedDict and items() ` `# Get first K items in dictionary ` `out ``=` `collections.OrderedDict(``list``(test_dict.items())[``0``: N]) ` `        `  `# printing result  ` `print``(``"Dictionary limited by K is : "` `+` `str``(out)) ` `#This code is contributed by Edula Vinay Kumar Reddy`

Output

```The original dictionary : {'Geeks': 1, 'For': 2, 'is': 3, 'best': 4, 'for': 5, 'CS': 6}
Dictionary limited by K is : OrderedDict([('Geeks', 1), ('For', 2), ('is', 3)])```

Time complexity: O(n)
Auxiliary Space: O(n)

Method #4: Using a dictionary comprehension and zip() function.

Step-by-step approach:

1. Initialize dictionary test_dict with some key-value pairs.
2. Initialize variable N with the desired limit of key-value pairs to extract from the dictionary.
3. Use a dictionary comprehension with zip() function to extract the first N key-value pairs from the test_dict dictionary.
4. Assign the resulting dictionary to a variable called out.
5. Print the value of out.

Below is the implementation of the above approach:

## Python3

 `# Initialize dictionary` `test_dict ``=` `{``'Geeks'` `: ``1``, ``'For'``:``2``,  ``'is'` `: ``3``, ``'best'` `: ``4``, ``'for'` `: ``5``, ``'CS'` `: ``6``}`   `# printing original dictionary ` `print``(``"The original dictionary : "` `+` `str``(test_dict))`   `# Initialize limit` `N ``=` `3`   `# Using dictionary comprehension and zip()` `# Get first N items in dictionary` `out ``=` `{k: test_dict[k] ``for` `k ``in` `list``(test_dict)[:N]}`   `# printing result` `print``(``"Dictionary limited by K is : "` `+` `str``(out))`

Output

```The original dictionary : {'Geeks': 1, 'For': 2, 'is': 3, 'best': 4, 'for': 5, 'CS': 6}
Dictionary limited by K is : {'Geeks': 1, 'For': 2, 'is': 3}```

Time complexity: O(N), as we only iterate through the first N items of the dictionary.
Auxiliary space: O(N), as we create a new dictionary with N items.

Method #5: Using a for loop to iterate through the dictionary and break after N items are processed.

Step-by-step approach:

• Create a for loop to iterate through the original dictionary.
• Inside the loop, add each key-value pair to the empty dictionary.
• Check if the length of the new dictionary is equal to N.
• If it is, break out of the loop.
• Print the limited dictionary.

Below is the implementation of the above approach:

## Python3

 `# Initialize dictionary` `test_dict ``=` `{``'Geeks'` `: ``1``, ``'For'``:``2``,  ``'is'` `: ``3``, ``'best'` `: ``4``, ``'for'` `: ``5``, ``'CS'` `: ``6``}`   `# printing original dictionary ` `print``(``"The original dictionary : "` `+` `str``(test_dict))`   `# Initialize limit` `N ``=` `3`   `# Using a for loop to iterate through the dictionary` `# Get first N items in dictionary` `out ``=` `{}` `for` `key, value ``in` `test_dict.items():` `    ``out[key] ``=` `value` `    ``if` `len``(out) ``=``=` `N:` `        ``break`   `# printing result` `print``(``"Dictionary limited by K is : "` `+` `str``(out))`

Output

```The original dictionary : {'Geeks': 1, 'For': 2, 'is': 3, 'best': 4, 'for': 5, 'CS': 6}
Dictionary limited by K is : {'Geeks': 1, 'For': 2, 'is': 3}```

Time complexity: O(N), as we only iterate through the first N items in the dictionary.
Auxiliary space: O(N), as we need to create a new dictionary to store the limited items.

Method 6:  use the heapq.nsmallest() function

step-by-step approach :

1. First, the program imports the heapq module, which is a built-in module in Python for heap operations.
2. The program then initializes a dictionary named test_dict, which contains key-value pairs of strings and integers.
3. Next, the program initializes a limit N to 3, which is the number of items we want to keep in the final dictionary.
4. The program then uses the heapq.nsmallest() function to find the first N smallest items based on the dictionary values. The function takes three arguments:
5. N: the number of items to return
test_dict.items(): a list of the dictionary’s key-value pairs
key=lambda item: item[1]: a lambda function that specifies how to sort the dictionary values. In this case, we are sorting by the second item (i.e., the value).
The program then creates a dictionary named out from the first N smallest items returned by heapq.nsmallest().
6. Finally, the program prints the result of the limited dictionary out as a string.

## Python3

 `import` `heapq`   `# Initialize dictionary` `test_dict ``=` `{``'Geeks'``: ``1``, ``'For'``: ``2``, ``'is'``: ``3``, ``'best'``: ``4``, ``'for'``: ``5``, ``'CS'``: ``6``}`   `# Initialize limit` `N ``=` `3`   `# Use heapq.nsmallest() to find the first N smallest items based on the dictionary values` `items ``=` `heapq.nsmallest(N, test_dict.items(), key``=``lambda` `item: item[``1``])`   `# Create a dictionary from the first N smallest items` `out ``=` `dict``(items)`   `# printing result` `print``(``"Dictionary limited by K is : "` `+` `str``(out))`

Output

`Dictionary limited by K is : {'Geeks': 1, 'For': 2, 'is': 3}`

Time complexity of O(N log N) since it needs to sort the dictionary values using a heap.
Auxiliary space of O(N) since it needs to store at most N items in the new dictionary.

Previous
Next