Python Pickle ट्यूटोरियल: ऑब्जेक्ट सीरियलाइज़ेशन

हमें ऑब्जेक्ट सीरियलाइज़ेशन की आवश्यकता क्यों है?

Python Pickle पर शुरू करने से पहले, समझते हैं कि ऑब्जेक्ट सीरियलाइज़ेशन इतना महत्वपूर्ण क्यों है।

आप सोच रहे होंगे कि हम डेटा संरचनाओं को सीधे किसी टेक्स्ट फ़ाइल में सेव करके ज़रूरत पड़ने पर फिर से एक्सेस क्यों नहीं कर सकते, बजाय उन्हें सीरियलाइज़ करने के।

सीरियलाइज़ेशन के लाभ समझने के लिए एक सरल उदाहरण देखते हैं।

यहाँ छात्रों की जानकारी जैसे नाम, आयु और कक्षा वाला एक nested डिक्शनरी है:

students = {

  'Student 1': {
        'Name': "Alice", 'Age' :10, 'Grade':4,
    },   
    'Student 2': {
        'Name':'Bob', 'Age':11, 'Grade':5
    },   
    'Student 3': {
        'Name':'Elena', 'Age':14, 'Grade':8
    }   
}संचालित द्वारा

आइए “students” ऑब्जेक्ट के डेटा टाइप की जाँच करें:

type(students)संचालित द्वारा

dictसंचालित द्वारा

अब जब हमने पुष्टि कर ली कि student ऑब्जेक्ट डिक्शनरी टाइप है, तो इसे बिना सीरियलाइज़ किए टेक्स्ट फ़ाइल में लिखते हैं:

with open('student_info.txt','w') as data:
      data.write(str(students))संचालित द्वारा

ध्यान दें कि टेक्स्ट फ़ाइल में हम सिर्फ स्ट्रिंग ऑब्जेक्ट ही लिख सकते हैं, इसलिए हमने str() फ़ंक्शन का उपयोग करके डिक्शनरी को स्ट्रिंग में बदला है। इसका मतलब है कि हमारी डिक्शनरी की मूल स्थिति खो जाती है।

अब, डिक्शनरी को पढ़ते हैं, प्रिंट करते हैं और फिर से उसका टाइप जाँचते हैं:

with open("student_info.txt", 'r') as f:
    for students in f:
        print(students)

type(students)संचालित द्वारा

strसंचालित द्वारा

nested डिक्शनरी अब स्ट्रिंग के रूप में प्रिंट हो रही है, और जब हम इसकी keys या values तक पहुँचने की कोशिश करेंगे तो यह एरर देगी।

यहीं पर सीरियलाइज़ेशन काम आता है।

डिक्शनरी, डेटा फ्रेम, और nested लिस्ट जैसी जटिल डेटा टाइप्स के साथ काम करते समय, सीरियलाइज़ेशन उपयोगकर्ता को ऑब्जेक्ट की मूल स्थिति को किसी भी प्रासंगिक जानकारी को खोए बिना सुरक्षित रखने देता है।

आगे इस लेख में, हम इसी डिक्शनरी को Pickle का उपयोग करके फ़ाइल में स्टोर करना और लाइब्रेरी की मदद से उसे डी-सीरियलाइज़ करना सीखेंगे। Python dictionary comprehension के बारे में आप अलग ट्यूटोरियल में पढ़ सकते हैं। 

Python में Pickle का परिचय

Python का Pickle मॉड्यूल डेटा टाइप्स को सीरियलाइज़ और डी-सीरियलाइज़ करने के लिए एक लोकप्रिय फ़ॉर्मेट है। यह Python-नेटीव फ़ॉर्मेट है, यानी Pickle ऑब्जेक्ट्स को किसी अन्य प्रोग्रामिंग भाषा से लोड नहीं किया जा सकता।

अन्य सीरियलाइज़ेशन फ़ॉर्मेट्स की तुलना में Pickle के अपने फायदे और कमियाँ हैं।

ऑब्जेक्ट्स को सीरियलाइज़ करने के लिए Pickle के फायदे

• JSON जैसे फ़ॉर्मेट ट्यूपल और datetime ऑब्जेक्ट्स को हैंडल नहीं कर सकते, जबकि Pickle लगभग हर आम बिल्ट-इन Python डेटा टाइप को सीरियलाइज़ कर सकता है। यह ऑब्जेक्ट की सटीक स्थिति भी बनाए रखता है, जो JSON नहीं कर सकता।
• Pickle recursive संरचनाओं को स्टोर करने के लिए अच्छा विकल्प है क्योंकि यह किसी ऑब्जेक्ट को सिर्फ एक बार ही लिखता है।
• Pickle ऑब्जेक्ट्स को डी-सीरियलाइज़ करते समय लचीलापन देता है। आप आसानी से अलग-अलग वैरिएबल्स को एक Pickle फ़ाइल में सेव कर सकते हैं और उन्हें किसी अन्य Python सत्र में लोड कर सकते हैं, बिना कोड एडिट किए अपने डेटा को ठीक उसी तरह वापस पा सकते हैं।

Pickle की कमियाँ

• Pickle असुरक्षित है क्योंकि यह ऑब्जेक्ट्स बनाने के लिए दुर्भावनापूर्ण Python callables को भी निष्पादित कर सकता है। डी-सीरियलाइज़ करते समय Pickle दुर्भावनापूर्ण और गैर-दुर्भावनापूर्ण callable में अंतर नहीं कर पाता। इस वजह से डी-सीरियलाइज़ेशन के दौरान मनमाना कोड चल सकता है।
• जैसा कि पहले बताया गया, Pickle Python-विशिष्ट मॉड्यूल है, और किसी अन्य भाषा का उपयोग करते समय पिकिल्ड ऑब्जेक्ट्स को डी-सीरियलाइज़ करना मुश्किल हो सकता है।
• कई बेंचमार्क के अनुसार, Pickle JSON और ApacheThrift जैसे फ़ॉर्मेट्स की तुलना में धीमा दिखता है और बड़े सीरियलाइज़्ड वैल्यूज़ बनाता है।

Pickle की dump और load फ़ंक्शंस से ऑब्जेक्ट्स को सेव और लोड करना

Python ऑब्जेक्ट्स को सीरियलाइज़ और डी-सीरियलाइज़ करने के लिए Pickle निम्नलिखित फ़ंक्शंस का उपयोग करता है:

pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None)

pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None)

pickle.load(file, *, fix_imports=True, encoding='ASCII', errors='strict', buffers=None)

pickle.loads(data, /, *, fix_imports=True, encoding=”ASCII”, errors=”strict”, buffers=None)संचालित द्वारा

Pickle के dump() और dumps() फ़ंक्शन किसी ऑब्जेक्ट को सीरियलाइज़ करते हैं। इन दोनों में फर्क यह है कि dump() डेटा को फ़ाइल में लिखता है, जबकि dumps() उसे एक bytes ऑब्जेक्ट के रूप में लौटाता है। 

इसी तरह, load() फ़ाइल से पिकिल्ड ऑब्जेक्ट्स पढ़ता है, जबकि loads() उन्हें bytes-जैसे ऑब्जेक्ट से डी-सीरियलाइज़ करता है।

इस ट्यूटोरियल में, हम dump() और load() फ़ंक्शंस का उपयोग करके Python ऑब्जेक्ट्स को फ़ाइल में pickle और फिर unpickle करेंगे।

Pickle के साथ Python डेटा संरचनाओं का सीरियलाइज़ेशन

सूचियाँ

पहले एक सरल Python सूची बनाते हैं:

import pickle 

student_names = ['Alice','Bob','Elena','Jane','Kyle']संचालित द्वारा

अब, एक टेक्स्ट फ़ाइल खोलते हैं, dumps() फ़ंक्शन का उपयोग करके सूची उसमें लिखते हैं, और फ़ाइल बंद करते हैं:

with open('student_file.pkl', 'wb') as f:  # open a text file
    pickle.dump(student_names, f) # serialize the listसंचालित द्वारा

हमने पहले “student_file.pkl” नाम की फ़ाइल बनाई। एक्सटेंशन .pkl होना अनिवार्य नहीं है। आप इसे कुछ भी नाम दे सकते हैं और फ़ाइल फिर भी बन जाएगी। हालाँकि, .pkl एक्सटेंशन का उपयोग करना अच्छी प्रैक्टिस है ताकि आपको याद रहे कि यह Pickle फ़ाइल है।

साथ ही, ध्यान दें कि हमने फ़ाइल को wb मोड में खोला है। इसका मतलब है कि आप फ़ाइल को बाइनरी मोड में लिख रहे हैं ताकि डेटा bytes ऑब्जेक्ट में लौटे।

फिर, हम dump() फ़ंक्शन का उपयोग करके student_names सूची को फ़ाइल में स्टोर करते हैं।

अंत में, आप निम्न कोड से फ़ाइल बंद कर सकते हैं:

f.close()संचालित द्वारा

अब, फ़ाइल को डी-सीरियलाइज़ करते हैं और सूची प्रिंट करते हैं:

with open('student_file.pkl', 'rb') as f:

    student_names_loaded = pickle.load(f) # deserialize using load()
    print(student_names_loaded) # print student namesसंचालित द्वारा

ऊपर दिए गए कोड का आउटपुट इस प्रकार होना चाहिए:

['Alice', 'Bob', 'Elena', 'Jane', 'Kyle']संचालित द्वारा

ध्यान दें कि फ़ाइल को डी-सीरियलाइज़ करने के लिए हमें rb मोड यानी read binary का उपयोग करना पड़ता है। फिर, हम load() फ़ंक्शन से ऑब्जेक्ट को unpickle करते हैं, जिसके बाद हम डेटा को किसी अलग वैरिएबल में स्टोर कर सकते हैं और आवश्यकतानुसार उपयोग कर सकते हैं।

आइए अभी-अभी unpickle की गई सूची के डेटा टाइप की जाँच करते हैं:

type(student_names_loaded)संचालित द्वारा

listसंचालित द्वारा

बहुत बढ़िया! हमने इस सूची की मूल स्थिति और डेटा टाइप को सुरक्षित रखा है।

Numpy arrays

अब, थोड़ा अधिक जटिल डेटा टाइप — Numpy arrays — को सीरियलाइज़ और डी-सीरियलाइज़ करने की कोशिश करते हैं।

पहले, एक 10 बाई 10 का ones का array बनाते हैं:

import numpy as np

numpy_array = np.ones((10,10)) # 10x10 arrayसंचालित द्वारा

फिर, पहले की तरह, इस array को फ़ाइल में सीरियलाइज़ करने के लिए dump() फ़ंक्शन कॉल करते हैं:

with open('my_array.pkl','wb') as f:
    pickle.dump(numpy_array, f)संचालित द्वारा

अंत में, इस array को unpickle करते हैं और इसकी shape और डेटा टाइप जाँचते हैं ताकि सुनिश्चित हो कि इसकी मूल स्थिति बनी हुई है:

with open('my_array.pkl','rb') as f:
    unpickled_array = pickle.load(f)
    print('Array shape: '+str(unpickled_array.shape))
    print('Data type: '+str(type(unpickled_array)))संचालित द्वारा

आपको निम्न आउटपुट मिलना चाहिए:

Array shape: (10, 10)

Data type: <class 'numpy.ndarray'>संचालित द्वारा

unpickle किया गया ऑब्जेक्ट 10x10 का Numpy array है, जिसका shape और डेटा टाइप उसी तरह है जैसा हमने सीरियलाइज़ किया था।

pandas DataFrames

डेटा फ्रेम वह ऑब्जेक्ट है जिसके साथ डेटा वैज्ञानिक रोज़ काम करते हैं। Pandas DataFrame को लोड और सेव करने का सबसे लोकप्रिय तरीका इसे CSV फ़ाइल के रूप में पढ़ना और लिखना है। हमारे pandas read_csv() ट्यूटोरियल में इम्पोर्टिंग के बारे में और जानें। 

हालाँकि, यह प्रक्रिया सीरियलाइज़ेशन से धीमी होती है और यदि डेटा फ्रेम बड़ा हो, तो यह अत्यधिक समय लेने वाली हो सकती है।

आइए Pickle बनाम CSV का उपयोग करके pandas डेटा फ्रेम को सेव और लोड करने की दक्षता की तुलना उनके समय के आधार पर करें।

पहले, 100,000 पंक्तियों वाला एक pandas डेटा फ्रेम कुछ नकली डेटा के साथ बनाते हैं:

import pandas as pd
import numpy as np

# Set random seed
np.random.seed(123)

data = {'Column1': np.random.randint(0, 10, size=100000),
        'Column2': np.random.choice(['A', 'B', 'C'], size=100000),
        'Column3': np.random.rand(100000)}


# Create Pandas dataframe
df = pd.DataFrame(data)संचालित द्वारा

अब, इस डेटा फ्रेम को csv फ़ाइल के रूप में सेव करने में लगे समय की गणना करते हैं:

import time

start = time.time()

df.to_csv('pandas_dataframe.csv')

end = time.time()
print(end - start)संचालित द्वारा

0.19349145889282227संचालित द्वारा

तीन कॉलम और 100,000 पंक्तियों वाले Pandas डेटा फ्रेम को csv फ़ाइल में सेव करने में 0.19 सेकंड लगे।

देखते हैं कि क्या Pickle का उपयोग परफॉर्मेंस में सुधार कर सकता है। pandas लाइब्रेरी में to_pickle() नामक एक मेथड है, जो हमें केवल एक पंक्ति के कोड में डेटा फ्रेम को pickle फ़ाइल में सीरियलाइज़ करने देता है:

start = time.time()

df.to_pickle("my_pandas_dataframe.pkl")

end = time.time()
print(end - start)संचालित द्वारा

0.0059659481048583984संचालित द्वारा

उसी Pandas DataFrame को Pickle फ़ाइल में सेव करने में केवल 5 मिलीसेकंड लगे, जो csv की तुलना में उल्लेखनीय सुधार है।

अब, फ़ाइल को वापस Pandas में पढ़ते हैं और देखते हैं कि Pickle फ़ाइल लोड करना मात्र csv पढ़ने की तुलना में कोई परफॉर्मेंस लाभ देता है या नहीं:

# Reading the csv file into Pandas:
start1 = time.time()
df_csv = pd.read_csv("my_pandas_dataframe.csv")
end1 = time.time()
print("Time taken to read the csv file: " + str(end1 - start1) + "\n")

# Reading the Pickle file into Pandas:
start2 = time.time()
df_pkl = pd.read_pickle("my_pandas_dataframe.pkl")
end2 = time.time()
print("Time taken to read the Pickle file: " + str(end2 - start2))संचालित द्वारा

ऊपर दिए गए कोड का आउटपुट इस प्रकार होना चाहिए:

Time taken to read the csv file: 0.00677490234375

Time taken to read the Pickle file: 0.0009608268737792969संचालित द्वारा

CSV फ़ाइल को Pandas में पढ़ने में 6 मिलीसेकंड लगे, और Pickle फ़ाइल को पढ़ने में केवल 0.9 मिलीसेकंड। 

भले ही यह अंतर छोटा लगे, लेकिन बड़े Pandas डेटा फ्रेम्स को Pickle से सीरियलाइज़ करने पर काफी समय की बचत हो सकती है। Pickle हर कॉलम के डेटा टाइप को भी संरक्षित रखने में मदद करेगा और CSV फ़ाइल की तुलना में कम डिस्क स्पेस लेगा।

डिक्शनरी

अंत में, उस डिक्शनरी को सीरियलाइज़ करते हैं जिसे हमने ट्यूटोरियल के पहले भाग में टेक्स्ट फ़ाइल में लिखा था:

students = {
  'Student 1': {
        'Name': "Alice", 'Age' :10, 'Grade':4,
    },
   
    'Student 2': {
        'Name':'Bob', 'Age':11, 'Grade':5
    },
   
    'Student 3': {
        'Name':'Elena', 'Age':14, 'Grade':8
    }
}संचालित द्वारा

याद करें कि जब हमने इस डिक्शनरी को टेक्स्ट फ़ाइल के रूप में सेव किया था, हमें इसे स्ट्रिंग में बदलना पड़ा था और इसकी मूल स्थिति खो गई थी।

अब इसे Pickle का उपयोग करके सीरियलाइज़ करते हैं और फिर पढ़ते हैं ताकि सुनिश्चित हो कि इसमें अभी भी Python डिक्शनरी के सभी गुण मौजूद हैं:

# serialize the dictionary to a pickle file
with open("student_dict.pkl", "wb") as f:
    pickle.dump(students, f)
   
# deserialize the dictionary and print it out
with open("student_dict.pkl", "rb") as f:
    deserialized_dict = pickle.load(f)
    print(deserialized_dict)संचालित द्वारा

आपको निम्न आउटपुट मिलना चाहिए:

{'Student 1': {'Name': 'Alice', 'Age': 10, 'Grade': 4}, 'Student 2': {'Name': 'Bob', 'Age': 11, 'Grade': 5}, 'Student 3': {'Name': 'Elena', 'Age': 14, 'Grade': 8}}संचालित द्वारा

अब इस वैरिएबल के टाइप की जाँच करते हैं:

type(deserialized_dict)संचालित द्वारा

dictसंचालित द्वारा

इस डिक्शनरी में पहले छात्र के बारे में कुछ जानकारी एक्सेस करने की कोशिश करते हैं:

print(
    "The first student's name is "
    + deserialized_dict["Student 1"]["Name"]
    + " and she is "
    + (str(deserialized_dict["Student 1"]["Age"]))
    + " years old."
)संचालित द्वारा

The first student's name is Alice and she is 10 years old.संचालित द्वारा

बहुत अच्छा! डिक्शनरी ने अपने सभी मूल गुणों को बनाए रखा है और इसे सीरियलाइज़ेशन से पहले की तरह ही एक्सेस किया जा सकता है। और जानने के लिए हमारा Python dictionary comprehension ट्यूटोरियल देखें। 

Pickle के साथ मशीन लर्निंग मॉडल्स का सीरियलाइज़ेशन

मशीन लर्निंग मॉडल को ट्रेन करना समय लेने वाली प्रक्रिया है जो घंटों और कभी-कभी कई दिनों तक चल सकती है। जब भी आपको किसी एल्गोरिदम को दोबारा उपयोग करना हो या किसी दूसरे वातावरण में ट्रांसफर करना हो, तो उसे हर बार शुरू से ट्रेन करना व्यावहारिक नहीं है।

यदि आप मशीन लर्निंग एल्गोरिदम बनाते समय सर्वोत्तम प्रथाओं के बारे में जानना चाहते हैं, तो आप Python में हमारा Designing Machine Learning Workflows कोर्स कर सकते हैं।

Pickle आपको मशीन लर्निंग मॉडलों को उनकी वर्तमान स्थिति में सीरियलाइज़ करने देता है, जिससे उन्हें आवश्यकता पड़ने पर फिर से उपयोग करना संभव हो जाता है।

इस खंड में, हम Pickle के साथ एक मशीन लर्निंग मॉडल को सीरियलाइज़ करना सीखेंगे।

इसके लिए, पहले कुछ नकली डेटा जेनरेट करते हैं और Scikit-Learn लाइब्रेरी के साथ एक लीनियर रिग्रेशन मॉडल बनाते हैं:

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

# generate regression dataset
X, y = make_regression(n_samples=100, n_features=3, noise=0.1, random_state=1)

# train regression model
linear_model = LinearRegression()
linear_model.fit(X, y)संचालित द्वारा

अब, कुछ सारांश मॉडल पैरामीटर्स प्रिंट करते हैं:

# summary of the model
print('Model intercept :', linear_model.intercept_)
print('Model coefficients : ', linear_model.coef_)
print('Model score : ', linear_model.score(X, y))संचालित द्वारा

Model intercept : -0.010109549594702116

Model coefficients :  [44.18793068 98.97389468 58.17121618]

Model score :  0.9999993081899219संचालित द्वारा

इसके बाद, हम इस मॉडल को Pickle के dump() फ़ंक्शन का उपयोग करके सीरियलाइज़ कर सकते हैं:

with open("linear_regression.pkl", "wb") as f:
    pickle.dump(linear_model, f)संचालित द्वारा

मॉडल अब Pickle फ़ाइल के रूप में सेव हो गया है। load() फ़ंक्शन का उपयोग करके इसे डी-सीरियलाइज़ करते हैं:

with open("linear_regression.pkl", "rb") as f:
    unpickled_linear_model = pickle.load(f)संचालित द्वारा

सीरियलाइज़ किया गया मॉडल अब unpickled_linear_model वैरिएबल में लोड हो गया है। यह जाँचते हैं कि यह उसी मॉडल के बराबर है जिसे हमने शुरू में बनाया था:

# summary of the model
print('Model intercept :', unpickled_linear_model.intercept_)
print('Model coefficients : ', unpickled_linear_model.coef_)
print('Model score : ', unpickled_linear_model.score(X, y))संचालित द्वारा

आपको निम्न आउटपुट मिलना चाहिए:

Model intercept : -0.010109549594702116

Model coefficients :  [44.18793068 98.97389468 58.17121618]

Model score :  0.9999993081899219संचालित द्वारा

बहुत बढ़िया! अभी-अभी unpickle किए गए मॉडल के पैरामीटर्स वही हैं जो पहले बनाए गए मॉडल के थे। 

अब हम इस मॉडल का उपयोग किसी टेस्ट डेटासेट पर भविष्यवाणी करने, इसके ऊपर आगे ट्रेन करने, या इसे किसी अन्य वातावरण में ट्रांसफर करने के लिए कर सकते हैं।

बड़े ऑब्जेक्ट्स के लिए Python Pickle परफॉर्मेंस बढ़ाना

Pickle एक कुशल सीरियलाइज़ेशन फ़ॉर्मेट है, जो कई बेंचमार्क में JSON, XML और HDF5 से तेज़ साबित हुआ है। 

हालाँकि, अत्यधिक बड़े डेटा संरचनाओं या विशाल मशीन लर्निंग मॉडलों के साथ काम करते समय, Pickle काफी धीमा हो सकता है और सीरियलाइज़ेशन आपके कार्यप्रवाह में बाधा बन सकता है।

Pickle फ़ाइलों को सेव और लोड करने में लगने वाला समय कम करने के कुछ तरीके यहाँ दिए गए हैं:

PROTOCOL आर्गुमेंट का उपयोग करें

वर्तमान में, Pickle फ़ाइलों को सेव और लोड करने के लिए डिफ़ॉल्ट प्रोटोकॉल 4 है, जो अलग-अलग Python संस्करणों के साथ सबसे अधिक संगत है। 

हालाँकि, यदि आप अपने कार्यप्रवाह को तेज़ करना चाहते हैं, तो आप HIGHEST_PROTOCOL आर्गुमेंट का उपयोग कर सकते हैं, जो Pickle का सबसे तेज़ उपलब्ध प्रोटोकॉल है।

Pickle के सबसे संगत प्रोटोकॉल और डिफ़ॉल्ट प्रोटोकॉल के बीच परफॉर्मेंस अंतर की तुलना करने के लिए, पहले डिफ़ॉल्ट प्रोटोकॉल का उपयोग करते हुए एक Pandas DataFrame को सीरियलाइज़ करते हैं। ध्यान दें कि यदि कोई प्रोटोकॉल स्पष्ट रूप से नहीं दिया जाता, तो Pickle यही वर्ज़न उपयोग करता है:

import pickle
import time
import numpy as np

# Set random seed
np.random.seed(100)

data = {'Column1': np.random.randint(0, 10, size=100000),
        'Column2': np.random.choice(['A', 'B', 'C'], size=100000),
        'Column3': np.random.rand(100000)}

# serialize to a file

start = time.time()

with open("df1.pkl", "wb") as f:
    pickle.dump(data, f)

end = time.time()
print(end - start)संचालित द्वारा

0.006001710891723633संचालित द्वारा

Pickle के डिफ़ॉल्ट प्रोटोकॉल से DataFrame को सीरियलाइज़ करने में लगभग 6 मिलीसेकंड लगे।

अब, उसी DataFrame को highest प्रोटोकॉल से pickle करते हैं:

start = time.time()

with open("df2.pkl", "wb") as f:
    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)

end = time.time()
print(end - start)संचालित द्वारा

0.0030384063720703125संचालित द्वारा

highest प्रोटोकॉल के साथ, हमने DataFrame को आधे समय में सीरियलाइज़ कर लिया।

Pickle की जगह cPickle का उपयोग करें

cPickle मॉड्यूल Pickle का तेज़ संस्करण है जो C में लिखा गया है। इसलिए यह पूरी तरह Python में इम्प्लीमेंटेड Pickle लाइब्रेरी से तेज़ है। 

ध्यान दें कि Python3 में cPickle का नाम बदलकर _pickle कर दिया गया है, जिसे हम इम्पोर्ट करेंगे।

import _pickle as cPickle

start = time.time()

with open("df3.pkl", "wb") as f:
    cPickle.dump(data, f)

end = time.time()

print(end-start)संचालित द्वारा

0.004027366638183594संचालित द्वारा

cPickle के साथ सीरियलाइज़ेशन में लगभग 4 मिलीसेकंड लगे, जो Pickle Python मॉड्यूल की तुलना में महत्वपूर्ण सुधार है।

सिर्फ वही सीरियलाइज़ करें जिसकी ज़रूरत है

सीरियलाइज़ेशन को तेज़ करने के उपायों के बावजूद, बड़े ऑब्जेक्ट्स के लिए यह प्रक्रिया अब भी बहुत धीमी हो सकती है।

परफॉर्मेंस बेहतर करने के लिए, आप डेटा संरचना को तोड़कर केवल आवश्यक सबसेट्स को ही सीरियलाइज़ कर सकते हैं।

उदाहरण के लिए, डिक्शनरी के साथ काम करते समय, आप वे ही key-value पेयर्स निर्दिष्ट करें जिन्हें आपको फिर से एक्सेस करना है। सीरियलाइज़ करने से पहले डिक्शनरी का आकार घटाएँ, क्योंकि इससे ऑब्जेक्ट की जटिलता कम होगी और प्रक्रिया तेज़ होगी।

Python में Pickle के साथ सीरियलाइज़ेशन: आगे के कदम

बधाई हो! आपने Python में सीरियलाइज़ेशन और Pickle लाइब्रेरी के उपयोग से संबंधित अनेक विषय सीख लिए हैं।

अब आपको यह अच्छी तरह समझ आ जाना चाहिए कि सीरियलाइज़ेशन क्या है, Python डेटा संरचनाओं को Pickle से कैसे सीरियलाइज़ करना है, और अलग-अलग आर्गुमेंट्स व मॉड्यूल्स का उपयोग करके Pickle के परफॉर्मेंस को कैसे ऑप्टिमाइज़ करना है।

अपनी सीरियलाइज़ेशन समझ को बेहतर करने और इसे अपने डेटा साइंस वर्कफ़्लोज़ को सशक्त बनाने के लिए आप ये कदम उठा सकते हैं:

1. नए सीरियलाइज़ेशन फ़ॉर्मेट्स के बारे में जानें। हालाँकि इस ट्यूटोरियल में हमने केवल Pickle मॉड्यूल कवर किया, यह हर परिस्थिति में सर्वोत्तम फ़ॉर्मेट नहीं है। JSON, XML, और HDF5 जैसे अन्य फ़ॉर्मेट्स के बारे में जानना उपयोगी है, ताकि अलग-अलग उपयोग मामलों में सही विकल्प चुन सकें।
2. खुद आज़माएँ। इस ट्यूटोरियल की अवधारणाओं को अपने डेटा साइंस वर्कफ़्लो में लागू करें। अगली बार जब आप कोई नई डेटा संरचना बनाएँ या किसी गणना का आउटपुट किसी वैरिएबल में स्टोर करें, तो पूरा कोड बार-बार चलाने के बजाय उसे बाद में उपयोग के लिए सीरियलाइज़ करें।
3. ऑनलाइन कोर्स करें। अपने डेटा साइंस वर्कफ़्लोज़ को ऑप्टिमाइज़ करने और सीरियलाइज़ेशन जैसे कार्य कुशलता से करने के लिए Python डेटा संरचनाओं और ऑब्जेक्ट्स की मजबूत समझ ज़रूरी है। इसे पाने के लिए आप हमारा Data Types for Data Science in Python कोर्स कर सकते हैं।