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

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 

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 

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

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:

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:

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.

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.