Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Python object serialization
Serialization is a process in which an object is transformed into a format that can be stored/save (in a file or memory buffer), so we are able to deserialize it later and recover the original content/object from the serialized format. We are going to use a python pickle module to do all these operations.
What is pickling?
Python pickle module is used for serializing and de-serializing python object structures. The process to converts any kind of python objects (list, dict, etc.) into byte streams (0s and 1s) is called pickling or serialization or flattening or marshaling. We can convert the byte stream (generated through pickling) back into python objects by a process called as unpickling.
To pickle an object we just need to −
- Import the pickle
- Call the dumps() function
import pickle
class Vehicle:
def __init__(self, number_of_doors, color):
self.number_of_doors = number_of_doors
self.color = color
class Car(Vehicle):
def __init__(self, color):
Vehicle.__init__(self, 5, color)
Maruti = Car('Red')
print(str.format('My Vehicle Maruti is {0} and has {1} doors', Maruti.color, Maruti.number_of_doors))
pickle_Maruti = pickle.dumps(Maruti)
print('Here is my pickled Vehicle: ')
print(pickle_Maruti)Output
My Vehicle Maruti is Red and has 5 doors Here is my pickled Vehicle: b'\x80\x03c__main__\nCar\nq\x00)\x81q\x01}q\x02(X\x0f\x00\x00\x00number_of_doorsq\x03K\x05X\x05\x00\x00\x00colorq\x04X\x03\x00\x00\x00Redq\x05ub.'
In the above example, we have created an instance of a Car class and then we’ve pickled it, transforming our car instance into a simple array of bytes. After our car instance is pickled, we can easily store it on a binary file or in a db field and restore it later to transform back this bunch of bytes in an object hierarchy.
Note: In case we want to create a file with a pickled object, we need to use the dump() method instead of the dumps() method.
Unpickling
It is the inverse (or pickling) operation, where we take the binary stream and convert it into an object hierarchy.
The unpickling is done using the load() function of the pickle module and returns back a complete object hierarchy from the byte stream.
Below is the load
import pickle
class Vehicle:
def __init__(self, number_of_doors, color):
self.number_of_doors = number_of_doors
self.color = color
class Car(Vehicle):
def __init__(self, color):
Vehicle.__init__(self, 5, color)
Maruti = Car('Red')
print(str.format('My Vehicle Maruti is {0} and has {1} doors', Maruti.color, Maruti.number_of_doors))
pickle_Maruti = pickle.dumps(Maruti)
#Now, let's unpickle our car Maruti creating another instance, another car ... unpickle_Maruti
Hyundai = pickle.loads(pickle_Maruti)
#Set another color of our new instance
Hyundai.color = 'Black'
print(str.format("Hyundai is {0} ", Hyundai.color))
print(str.format("Maruti is {0} ", Maruti.color))In above example, you can see that we have pickled our first car object (Maruti) and then we have unpickled it to another variable (Hyundai) and so we have in a sense – cloned Maruti to create Hyundai.
Output
My Vehicle Maruti is Red and has 5 doors Hyundai is Black Maruti is Red
Pickle vs JSON
JSON stands for Javascript Object Notation, is a lightweight format for data-interchange and is humans readable. One of the big advantages of JSON over pickle is that it’s standardized and language-independent. It is much more secure and faster than pickle.
One more alternative to pickle is cPickle, which is very much like a pickle but is written in C language and is 1000 times faster. You can use the same files for pickle and cPickle.
import json
mylist = [2, 4, 5, "ab", "cd", "ef"]
print("Here is my list: ", mylist)
json_string = json.dumps(mylist )
print("Here is my json encoded object: ", json_string)
print ("Here is JSON back to a data structure: ",json.loads(json_string))Output
Here is my list: [2, 4, 5, 'ab', 'cd', 'ef'] Here is my json encoded object: [2, 4, 5, "ab", "cd", "ef"] Here is JSON back to a data structure: [2, 4, 5, 'ab', 'cd', 'ef']
In the above code, we first take the object (my list) and use the “dumps” method to returns a string and then to load JSON back to a data structure we use the “loads” method that turns a string and turns it into the JSON object data structure.
566 Views
To Continue Learning Please Login