Sometimes, while working with Dictionaries, we can have a task in which we need to perform the conversion of converting dictionary to string, which is concatenated key-value pair. This can have application in domains in which we require to reduce storage space or require strings as target data. Let’s discuss certain ways in which this task can be performed.
Method 1: Using an empty string + for loop
In this method, we will use a for loop to iterate through the dictionary object and keep on adding the key: value pairs to the empty string.
Python3
# Python3 code to demonstrate working of# Convert Dictionary to Concatenated String# Using an empty string + for loop# initializing dictionarytest_dict = {'gfg': 1, 'is': 2, 'best': 3}# printing original dictionaryprint("The original dictionary is : " + str(test_dict))# Create an empty stringres = ' '# Convert Dictionary to Concatenated String# Using for loop and empty stringfor item in test_dict: res += item + str(test_dict[item])# printing resultprint("The dictionary after concatenation is : " + str(res)) |
The original dictionary is : {'gfg': 1, 'is': 2, 'best': 3}
The dictionary after concatenation is : gfg1is2best3
Method 2 : Using join() + items()
The combination of above functions can be used to solve this problem. In this, we need to perform the task of concatenation using join() and extraction of dictionary items is done using items().
Python3
# Python3 code to demonstrate working of # Convert Dictionary to Concatenated String# Using join() + items()# initializing dictionarytest_dict = {'gfg' : 1, 'is' : 2, 'best' : 3}# printing original dictionaryprint("The original dictionary is : " + str(test_dict))# Convert Dictionary to Concatenated String# Using join() + items()res = ''.join(key + str(val) for key, val in test_dict.items())# printing result print("The dictionary after concatenation is : " + str(res)) |
The original dictionary is : {'gfg': 1, 'is': 2, 'best': 3}
The dictionary after concatenation is : gfg1is2best3
Method 3 : Using reduce() + lambda
The combination of above functions can be used to perform this task. In this, we perform the task of concatenation using combination of reduce() and lambda.
Python3
# Python3 code to demonstrate working of # Convert Dictionary to Concatenated String# Using reduce() + lambdafrom functools import reduce# initializing dictionarytest_dict = {'gfg' : 1, 'is' : 2, 'best' : 3}# printing original dictionaryprint("The original dictionary is : " + str(test_dict))# Convert Dictionary to Concatenated String# Using reduce() + lambdares = reduce(lambda key, val : key + str(val[0]) + str(val[1]), test_dict.items(), '')# printing result print("The dictionary after concatenation is : " + str(res)) |
The original dictionary is : {'gfg': 1, 'is': 2, 'best': 3}
The dictionary after concatenation is : gfg1is2best3
Method#4: Using list comprehension with zip() function
Steps:
- Define the input dictionary
- Uses the zip() function to iterate over the keys and values of the dictionary in parallel.
- Uses a list comprehension to concatenate each key-value pair into a string using the + operator and the str() function.
- Joins the resulting list of strings using the join() method.
- Prints the concatenated string.
Python3
# Define the input dictionarymy_dict = {'gfg': 1, 'is': 2, 'best': 3}# Convert dictionary to concatenated string using a list comprehension with zip() functionconcatenated_string = ''.join([str(x) + str(y) for x, y in zip(my_dict.keys(), my_dict.values())])# Print the concatenated stringprint("The dictionary after concatenation is : ", concatenated_string) |
The dictionary after concatenation is : gfg1is2best3
Time Complexity: O(n). The zip() function in this approach has a time complexity of O(n), where n is the number of items in the dictionary. The list comprehension has a time complexity of O(n), where n is the number of items in the dictionary. The join() method has a time complexity of O(n), where n is the length of the resulting string.
Auxiliary Space: O(n). This approach creates a list of strings using a list comprehension, which has a space complexity of O(n), where n is the number of items in the dictionary. The join() method also creates a new string object, which has a space complexity of O(n), where n is the length of the resulting string.
METHOD 5: Using the map() function
APPROACH:
Using the map() function with a lambda function to concatenate the keys and values into a single string, and then using the join() method to concatenate the resulting list into a single string.
Steps:
- Create a dictionary.
- Use the map() function with a lambda function to concatenate each key and value pair into a single string.
- Convert the resulting map object into a list.
- Use the join() method to concatenate the strings in the list into a single string.
- Return the final concatenated string.
Python3
# Initializing dictionarymy_dict = {'gfg': 1, 'is': 2, 'best': 3}# Concatenate keys and values into a list# using map() with a lambda functionresult_list = list(map(lambda x: x[0] + str(x[1]), my_dict.items()))# Concatenating the list items into a single stringresult = "".join(result_list)# Printing answerprint(result) |
gfg1is2best3
Time complexity: O(n), where n is the number of items in the dictionary. The map() function, list conversion, and join() method all have a time complexity of O(n), so the overall time complexity is O(n).
Auxiliary Space: O(n), where n is the number of items in the dictionary. The map() function creates a map object that requires O(n) space, and the resulting list also requires O(n) space. The final concatenated string requires O(n) space as well. So the overall space complexity is O(n).
METHOD 6: Using re.sub() method
Intuition: We use the re.sub() function to remove all non-alphanumeric characters from the string representation of the given dictionary.
Steps:
- Import the re module.
- Define a dictionary my_dict.
- Convert the dictionary to a string using str() function.
- Apply the re.sub() function to the string with regex pattern r’\W+’ to remove all non-word characters.
- Store the resulting string in the variable result.
- Print the value of the result.
Python3
import re# Initializing listmy_dict = {'gfg': 1, 'is': 2, 'best': 3}result = re.sub(r'\W+', '', str(my_dict))# Printing answerprint(result) |
gfg1is2best3
Time Complexity: O(N), where n is the length of the resulting string. This is because the re.sub() function iterates through each character in the string once.
Auxiliary Space: O(N), where n is the length of the resulting string. This is because we create a new string that contains only alphanumeric characters.
Method 7: Using generator expression + join function
Steps:
- Use a generator expression that iterates over the key-value pairs in the dictionary, and concatenates them using string concatenation.
- Pass the generator expression to the join function to join the concatenated strings into a single string.
- Print the final concatenated string.
Python3
# Iniializing dictionary my_dict = {'gfg': 1, 'is': 2, 'best': 3}# Concatenate keys and values into a single string# using generator expression and join function result = "".join(key + str(value) for key, value in my_dict.items())# Pinting answerprint(result) |
gfg1is2best3
The time complexity of this method is O(n), where n is the number of key-value pairs in the dictionary.
The auxiliary space used is O(n), where n is the length of the final concatenated string.
