Python’s Pickling and Unpickling

in

So what is this magical process called “pickling” anyway? Well, it’s like taking a snapshot of an object in Python and saving it to disk. This means that if you have a complex data structure or function that takes forever to compute, you can save the results using pickle and load them back up later without having to re-run your code.

Here’s how it works: let’s say we have this list of numbers: `[1, 2, 3]`. We want to save it to a file called “numbers.pkl” so that we can load it back up later and do some more calculations with it. Here’s what you need to do:

# Import the pickle module
import pickle

# Create a list of numbers
my_list = [1, 2, 3]

# Open a file called "numbers.pkl" in write binary mode
# and assign it to the variable "f"
with open('numbers.pkl', 'wb') as f:
    # Use the dump() function from the pickle module
    # to save the list to the file
    pickle.dump(my_list, f)

# The file is now saved and can be loaded back up later
# using the load() function from the pickle module.

That’s it! Now if you want to load that list back up later (let’s say in a different script), all you have to do is this:

# Import the pickle module to allow for serialization and deserialization of Python objects
import pickle

# Open the file 'numbers.pkl' in read binary mode and assign it to the variable 'f'
with open('numbers.pkl', 'rb') as f:
    # Use the pickle.load() function to deserialize the data from the file and assign it to the variable 'my_list'
    my_list = pickle.load(f)

# Print the contents of 'my_list' to the console
print(my_list) # [1, 2, 3]

Pretty cool, right? But what if you have a more complex object that you want to save and load? Let’s say we have this function:

# This function is used to add two numbers and return the result
def my_function():
    # Assigning the value 5 to the variable x
    x = 5
    # Assigning the value 10 to the variable y
    y = 10
    # Returning the sum of x and y
    return x + y

We can pickle the results of this function using a similar process. Here’s what it looks like:

# Import the pickle module to enable pickling (serializing) and unpickling (deserializing) of Python objects
import pickle

# Define a function called my_function that takes in some input and returns a result
def my_function():
    # Function body
    pass

# Call the my_function() and store its result in a variable called my_func
my_func = my_function()

# Open a file called 'result.pkl' in write binary mode ('wb') and assign it to a variable called f
with open('result.pkl', 'wb') as f:
    # Use the pickle.dump() function to pickle (serialize) the result of my_func and write it to the file f
    pickle.dump(my_func, f)

# The result of my_func has now been pickled and saved in the file 'result.pkl'

And to load it back up later:

# Import the pickle module to enable saving and loading of python objects
import pickle

# Open the file 'result.pkl' in read binary mode and assign it to the variable 'f'
with open('result.pkl', 'rb') as f:
    # Load the saved function from the file and assign it to the variable 'my_func'
    my_func = pickle.load(f)

# Call the loaded function and print the result
print(my_func()) # prints 15 (the result of the function we saved earlier)

Pickling and unpickling in Python is a powerful tool that can save you time and make your code look cooler. Give it a try !

SICORPS