Dictionary
Dictionary is an unordered collection of mutable values indexed by unique keys. Values in a dictionary can be of any datatype, mutable and can be duplicated, whereas keys can’t be repeated and are immutable.
Python program to extract values of Particular Key in Nested Values
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
dict = {"Uppercase" : {1 : "A", 2 : "B", 3 : "C", 4 : "D", 5 : "E"}, "Lowercase" : {1 : "a", 2 : "b", 3 : "c", 4 : "d", 5 : "e"}} key = 4 #using values() and keys() values1 = [value[key] for value in dict.values() if key in dict.keys()] print(values1) #Output: ['D', 'd'] #using items() values2 = [value[key] for k, value in dict.items() if key in value] print(values2) #Output: ['D', 'd'] |
- List comprehension is a compact method that defines a list and its contents at the same time. Its basic syntax consists of a square bracket with an expression that is executed for each element along with for loop to iterate over each element. Read more: List Comprehension in Python – Explained with Examples
- The keys() built-in dictionary method returns a list of all the keys in the dictionary.
- The values() built-in dictionary method returns a list of all the values in the dictionary.
- The items() built-in dictionary method returns a list of the tuple pairs of all the keys with the values in the dictionary.
Python program to convert the tuple value list to the list of the tuples
|
1 2 3 4 5 6 7 8 |
dict = {"A" : [(19, 16, 14), (11, ), (18, 6), (10, 15, 10)], "B" : [(8, ), (5, 1, 7), (2, 13, 3)], "C" : [(3, 8, 15, 6, 19, 19)], "D" : [(9, 6, 3), (2, 4, 6)]} list_tup = [(key, *ele) for key, value in dict.items() for ele in value] print(list_tup) #Output: [('A', 19, 16, 14), ('A', 11), ('A', 18, 6), ('A', 10, 15, 10), ('B', 8), ('B', 5, 1, 7), ('B', 2, 13, 3), ('C', 3, 8, 15, 6, 19, 19), ('D', 9, 6, 3), ('D', 2, 4, 6)]> |
- The ‘*’ operator unpacks every element of an iterable to other variables dynamically.
Python program to cross-map two dictionaries
|
1 2 3 4 5 6 7 8 9 10 11 12 |
dict1 = {"BetaPython:" : [9, 6, 3], "Python" : [8, 11, 5, 14, 9, 14], "For" : [6], "U" : [3, 12]} dict2 = {3 : [14], 5 : [1, 15], 8 : [6, 12, 1, 7, 4, 11, 7], 11 : [7 ,12], 14 : [9 , 4, 5]} dict3 = {key: [v for ele in value if ele in dict2 for v in dict2[ele]] for key, value in dict1.items()} print(dict3) #Output: {'BetaPython:': [14], 'Python': [6, 12, 1, 7, 4, 11, 7, 7, 12, 1, 15, 9, 4, 5, 9, 4, 5], 'For': [], 'U': [14]} |
- Dictionary comprehension is similar to set comprehension with an additional requirement of defining a key. In the comprehension expression key and values are separated by a colon ‘:’.
Python program to column mapped the tuples to the dictionary items
|
1 2 3 4 |
tup = (((1, 'I'), (2, 'II'), (3, 'III'), (4, 'IV')), (('A', 'a'), ('B', 'b'), ('C', 'c'), ('D', 'd'))) dict = {key[i] : value[i] for key, value in zip(*tup) for i in range(len(key))} print(dict) #Output: {1: 'A', 'I': 'a', 2: 'B', 'II': 'b', 3: 'C', 'III': 'c', 4: 'D', 'IV': 'd'} |
- The zip() built-in method returns an iterator of tuples, grouping the similar index of multiple sequences so that they can be used as a single entity.
Python program to pair the minimum value for the similar dictionary keys
|
1 2 3 4 5 |
list1 = [2, 4, 5, 8, 5, 2] list2 = [3, 7, 3, 5, 7, 1] dictionary = dict(sorted(zip(list1, list2), key = lambda ele: -ele[1])) print(dictionary) #Output: {4: 7, 5: 3, 8: 5, 2: 1} |
- The lambda function is a function that is defined without a name. It can have any number of arguments but only one expression as it is a small function having a single line of code. The expression is evaluated and returned.
- The sorted() built-in method takes an iterable and returns a sorted list containing the elements from the iterable, without modifying the original iterable. The key parameter defines the base criteria for sort. Read More: Sorting in python
- The dict() built-in method takes iterables and creates a new dictionary from its elements.
