Python | Interconversion between Dictionary and Bytes

Interconversion between data is quite popular and this particular article discusses about how interconversion of dictionary into bytes and vice versa can be obtained. Let’s look at the method that can help us achieve this particular task. 

Method : Using encode() + dumps() + decode() + loads() The encode and dumps function together performs the task of converting the dictionary to string and then to corresponding byte value. This can be interconverted using the decode and loads function which returns the string from bytes and converts that to the dictionary again. 

The original dictionary is : {'Gfg': 1, 'best': 3, 'is': 2}
The type after conversion to bytes is : <class 'bytes'>
The value after conversion to bytes is : b'{"Gfg": 1, "best": 3, "is": 2}'
The type after conversion to dict is : <class 'dict'>
The value after conversion to dict is : {'Gfg': 1, 'best': 3, 'is': 2}

Method #2: using pickle module

Approach

The pickle module to convert a dictionary to bytes and vice versa. pickle is a built-in module in Python that provides functionality for serializing and de-serializing Python objects, including dictionaries.

Algorithm

1. Import the pickle module
2. Define the dictionary
3. Convert the dictionary to bytes using pickle.dumps()
4. Print the type and value of the bytes object
5. Convert the bytes object back to dictionary using pickle.loads()
6. Print the type and value of the dictionary object

Type of bytes object: <class 'bytes'>
Value of bytes object: b'\x80\x03}q\x00(X\x03\x00\x00\x00Gfgq\x01K\x01X\x04\x00\x00\x00bestq\x02K\x03X\x02\x00\x00\x00isq\x03K\x02u.'
Type of dictionary object: <class 'dict'>
Value of dictionary object: {'Gfg': 1, 'best': 3, 'is': 2}

Time complexity: The time complexity of this approach is O(n), where n is the number of key-value pairs in the dictionary.

Auxiliary Space: The space complexity of this approach is O(n), where n is the number of key-value

Method 3 :  using the JSON module in Python. 

step-by-step approach 

• Import the JSON module using import json.
• Define a Python dictionary my_dict with some key-value pairs.
• Convert the dictionary to a JSON string using the json.dumps() function. This function takes a Python object (in this case, the dictionary my_dict) and returns a JSON-encoded string.
• Store the resulting JSON string in the variable json_str.
• Print the type and value of the json_str variable using the print() function. The type() function returns the type of the variable (in this case, str), and the print() function displays the value of the variable in the console.
• Convert the JSON string back to a Python dictionary using the json.loads() function. This function takes a JSON-encoded string (in this case, json_str) and returns a Python object (in this case, a dictionary).
• Store the resulting dictionary in the variable dict_obj.
• Print the type and value of the dict_obj variable using the print() function, just like in step 5.
• The program is now complete and will exit.

Type of JSON string: <class 'str'>
Value of JSON string: {"Gfg": 1, "best": 3, "is": 2}
Type of dictionary object: <class 'dict'>
Value of dictionary object: {'Gfg': 1, 'best': 3, 'is': 2}

The time complexity of this method is O(n) 

The auxiliary space required is O(n), where n is the size of the dictionary.

Method 4:  using numpy:

Algorithm:

1. Define a dictionary ‘my_dict’ with key-value pairs.
2. Use pickle.dumps() method to convert the dictionary object to bytes object ‘bytes_dict’.
3. Print the type and value of bytes object.
4. Use pickle.loads() method to convert the bytes object back to dictionary object ‘dict_obj’.
5. Print the type and value of the dictionary object.

Output:
Type of ndarray object: <class 'numpy.ndarray'>
Value of ndarray object: [['Gfg' '1']
['best' '3']
['is' '2']]
Type of dictionary object: <class 'dict'>
Value of dictionary object: {'Gfg': '1', 'best': '3', 'is': '2'}

Time Complexity:

Creating a dictionary has O(n) time complexity, where n is the number of key-value pairs.
pickle.dumps() and pickle.loads() methods have O(n) time complexity, where n is the size of the object being converted.
Printing values has O(1) time complexity.
Therefore, the overall time complexity is O(n).
Space Complexity:

The space required for creating the dictionary is O(n), where n is the number of key-value pairs.
The space required for bytes object ‘bytes_dict’ and dictionary object ‘dict_obj’ is also O(n), where n is the size of the dictionary.
The space required for other variables and print statements is O(1).
Therefore, the overall space complexity is O(n).