Given a dictionary having key:value pairs as byteString, the task is to convert the key:value pair to string.
Examples:
Input: {b'EmplId': b'12345', b'Name': b'Paras', b'Company': b'Cyware' }
Output: {'EmplId': '12345', 'Name': 'Paras', 'Company': 'Cyware'}
Input: {b'Key1': b'Geeks', b'Key2': b'For', b'Key3': b'Geek' }
Output: {'Key1':'Geeks', 'Key2':'For', 'Key3':'Geek' }
Method #1: By dictionary comprehension
Python3
# Python Code to convert ByteString key:value # pair of dictionary to String.# Initialising dictionary x = {b'EmplId': b'12345', b'Name': b'Paras', b'Company': b'Cyware'}# Convertingx = { y.decode('ascii'): x.get(y).decode('ascii') for y in x.keys() }# printing converted dictionaryprint(x) |
{'Name': 'Paras', 'EmplId': '12345', 'Company': 'Cyware'}
Method #2: By iterating key and values
Python3
# Python Code to convert ByteString key:value # pair of dictionary to String.# Initialising dictionary x = {b'EmplId': b'12345', b'Name': b'Paras', b'Company': b'Cyware'}# Initialising empty dictionary y = {}# Convertingfor key, value in x.items(): y[key.decode("utf-8")] = value.decode("utf-8")# printing converted dictionaryprint(y) |
{'Company': 'Cyware', 'Name': 'Paras', 'EmplId': '12345'}
Approach#3: Using the ast module
This approach defines a function byteToStr which takes a dictionary with byte string keys and values as input and returns a dictionary with string keys and values. The function converts the input dictionary to a string, replaces all occurrences of b’ with ‘ and then uses ast.literal_eval to convert the resulting string back to a dictionary. This effectively removes the b prefix from byte strings and converts them to regular strings.
Algorithm
1. Import the ast module.
2. Use the literal_eval() method from the ast module to convert the input dictionary to a string.
3. Replace the byte string markers “b’” and “‘” with empty strings to convert the byte strings to strings.
4. Use the ast.literal_eval() method again to convert the string back to a dictionary.
5. Return the new dictionary.
Python3
import astdef byteToStr(input_dict): str_dict = str(input_dict) str_dict = str_dict.replace("b'", "'").replace("'", "\"") return ast.literal_eval(str_dict)input_dict = {b'EmplId': b'12345', b'Name': b'Paras', b'Company': b'Cyware'}print(byteToStr(input_dict)) |
{'EmplId': '12345', 'Name': 'Paras', 'Company': 'Cyware'}
Time complexity: O(n) where n is the number of key-value pairs in the input dictionary.
Space complexity: O(n) since the input dictionary is converted to a string representation which takes up additional memory.
Approach#4: Using dict , map, lambda
The approach uses iterating through the key-value pairs of the input byte dictionary and decoding each byte key and value to string. Then, we can create a new dictionary using the decoded string keys and values. This can be done using dictionary comprehension or a for loop. In the given code, map() function is used to decode the byte key-value pairs and create a new dictionary.
Algorithm
1. Create an empty dictionary string_dict.
2. Iterate through each key-value pair of the input dictionary using the items() function.
3. For each key-value pair, decode the byte key and value to string using the decode() function.
4. Add the decoded key-value pair to the string_dict.
5. Return the string_dict.
Python3
def convert_byte_dict_to_string_dict(byte_dict): return dict(map(lambda item: (item[0].decode(), item[1].decode()), byte_dict.items())) byte_dict = {b'EmplId': b'12345', b'Name': b'Paras', b'Company': b'Cyware' }string_dict = convert_byte_dict_to_string_dict(byte_dict)print(string_dict) |
{'EmplId': '12345', 'Name': 'Paras', 'Company': 'Cyware'}
Time Complexity: O(n), where n is the number of key-value pairs in the input byte dictionary. This is because the code iterates through each key-value pair once and performs constant-time operations on each pair.
Space Complexity: O(n), where n is the number of key-value pairs in the input byte dictionary. This is because the code creates a new dictionary of size n to store the decoded string key-value pairs. The space complexity can be reduced to O(1) if we modify the input byte dictionary in place to store the decoded string key-value pairs instead of creating a new dictionary. However, this may not be desirable if we want to preserve the original byte dictionary.
