Open In App

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

Last Updated : 12 Apr, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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.



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads