उद्देश्य

struct मॉड्यूल का उपयोग करके नए खेत का अंतिम डेटा ब्रेकडाउन सेट करें।

सड़क के अंत में एक सेवा स्टेशन है जो पहले से निर्मित नए खेत और वहाँ पहले से ही बोई गई फसलों का प्रबंधन करता है। यहाँ हम पहले से बोई गई फसलों के डेटा और खेत की अनुमानित उपज का निरीक्षण और प्रसंस्करण करेंगे। इस अध्याय के अन्य स्तरों की तरह, हम डेटा को सीरियलाइज (serializing) और डिसीरियलाइज (deserializing) करने पर काम करेंगे, और एक अंतिम मॉड्यूल struct मॉड्यूल पेश करेंगे।

struct मॉड्यूल बाइनरी फॉर्मेट में डेटा पैक करने वाले कई सीरियलाइजेशन फंक्शन्स पेश करता है। अन्य मॉड्यूल्स की तुलना में इसमें आपको डेटा को सीरियलाइज और डिसीरियलाइज करते समय अधिक नियंत्रण मिलता है, जो इसे और अधिक बहुमुखी बनाता है। डेटा को प्रोसेस करने के लिए हम जिन फंक्शन्स का उपयोग करेंगे, उन्हें एक्सेस करने के लिए import struct का उपयोग करें:

• struct.calcsize(): यह निर्धारित करता है कि किसी दिए गए फॉर्मेट स्ट्रिंग को पैक करने में कितने बाइट्स लगेंगे; यह एक (1) आर्ग्युमेंट लेता है, जो उस फॉर्मेट का होता है जिसका आप बाइट साइज जांचना चाहते हैं। हम जो फॉर्मेट इस्तेमाल करेंगे, वे हैं:
  • integer: 'i' के रूप में निरूपित, यह पूर्णांकों (whole numbers) के लिए फॉर्मेट है
  • float: 'f' के रूप में निरूपित, यह दशमलव संख्याओं (decimal numbers) के लिए फॉर्मेट है
  • double: 'd' के रूप में निरूपित, यह उन जटिल दशमलव संख्याओं (complex decimal numbers) के लिए फॉर्मेट है जहां float फॉर्मेट पर्याप्त नहीं होता
• struct.pack(): बाइनरी में डेटा को सीरियलाइज करता है, आपके चुने हुए फॉर्मेट में पैक करता है। यह दो (2) या अधिक आर्ग्युमेंट्स लेता है: पहला वह फॉर्मेट है जिसका आप उपयोग करना चाहते हैं, और शेष वे मान हैं जिन्हें आप सीरियलाइज करना चाहते हैं। फॉर्मेट्स वही हैं जो पहले बताए गए हैं और आपको उन्हें आर्ग्युमेंट्स की संख्या के अनुरूप जोड़ना होगा।
• struct.unpack(): पैक्ड बाइनरी डेटा को डिसीरियलाइज करता है; यह दो (2) आर्ग्युमेंट्स लेता है: पहला वह फॉर्मेट है, जिसे यह उस फॉर्मेट से मेल खाना चाहिए जिसमें डेटा को सीरियलाइज किया गया था, और दूसरा वह डेटा है जिसे सीरियलाइज किया गया था।
• struct.iter_unpack(): पैक्ड बाइनरी डेटा को डिसीरियलाइज करता है; यह struct.unpack() की तरह ही काम करता है लेकिन लूप का उपयोग करके प्रत्येक डेटा ब्लॉक के माध्यम से इटेरेट करता है।
• struct.pack_into(): struct.pack() का उन्नत संस्करण है; यह चार (4) आर्ग्युमेंट्स लेता है: पहला फॉर्मेट है जिसे आप उपयोग करना चाहते हैं, दूसरा डेटा बफर है जिसमें आप डेटा डालना चाहते हैं, तीसरा बफर में वह स्थिति है जहां आप डेटा रखना चाहते हैं, और चौथा वह डेटा है जिसे आप पैक कर रहे हैं।
• struct.unpack_from(): struct.unpack() का उन्नत संस्करण है; यह तीन (3) आर्ग्युमेंट्स लेता है: पहला वह फॉर्मेट है जिसे आप उपयोग करना चाहते हैं, दूसरा डेटा बफर है जिसे आप अनपैक करना चाहते हैं, और तीसरा बफर में वह स्थान है जहां से आप अनपैक करना चाहते हैं। यह आपको डेटा के विशिष्ट हिस्सों को अनपैक करने की अनुमति देता है।

सेवा स्टेशन में लाइट X मार्क तक जाएँ और मेज की ओर मुड़ें, तीन (3) वेरिएबल्स बनाएँ जिनके नाम हों: integer, float और double। हम इनका उपयोग प्रत्येक फॉर्मेट के बाइट साइज को सत्यापित करने के लिए struct.calcsize() फ़ंक्शन के साथ करेंगे। integer वेरिएबल के लिए फ़ंक्शन को 'i' आर्ग्युमेंट के साथ उपयोग करें, float वेरिएबल के लिए 'f' और अंत में double वेरिएबल के लिए 'd' आर्ग्युमेंट के साथ। उदाहरण के लिए: integer = struct.calcsize('i')। इन तीनों (3) वेरिएबल्स को पहले से लिखी गई write() फ़ंक्शन में जोड़ें।

गोल्ड X मार्क तक जाएँ और नए खेत पर डेटा इकट्ठा करने के लिए read() फ़ंक्शन का उपयोग करें; भविष्य में उपयोग के लिए डेटा पॉइंट्स और फॉर्मेट नोट करें, अर्थात्: Resources, Size और Estimate। एक बार जब आपने इसे नोट कर लिया, तो नीले कार्पेट पर लाइट X मार्क तक जाएँ और blue_data नामक एक वेरिएबल बनाएँ।

blue_data वेरिएबल में struct.pack() फ़ंक्शन का रिटर्न वैल्यू स्टोर करें; इसमें आर्ग्युमेंट्स के रूप में वह फॉर्मेट और वो मान सेट करें जिन्हें आपने पहले नोट किया था। फॉर्मेट लिखते समय, आपको फॉर्मेट टाइप्स को एकเดียว यूनिट में 'pack' करना होगा। उदाहरण के लिए, जैसा कि पहले बताया गया है, integer फॉर्मेट को 'i' के रूप में लिखा जाता है; यदि आप तीन integer डेटा टाइप्स जोड़ रहे हैं, तो आप उन्हें 'iii' के रूप में लिखते हैं। इसी तरह, यदि आप एक integer, एक float और एक double जोड़ रहे हैं, तो इसे 'ifd' लिखते हैं। डेटा जोड़ते समय, आप उन्हें व्यक्तिगत रूप से आर्ग्युमेंट्स के रूप में पास करते हैं। यहाँ एक संपूर्ण उदाहरण है:

 data_1 = 8 # is an integer
 data_2 = 2.25 # is a float
 data_3 = 900.702938103 # is a double

 blue_data = struct.pack('ifd', data_1, data_2, data_3)

struct.pack() फ़ंक्शन काफी लचीलापन प्रदान करता है, जिससे आप डेटा को कैसे फॉर्मेट करना चाहते हैं और एक साथ कई डेटा पॉइंट्स को सीरियलाइज करना तय कर सकते हैं। ऊपर दिए गए उदाहरण को बेस मानते हुए पहले पढ़े गए डेटा को जोड़ें। पैक्ड डेटा देखने के लिए display() फ़ंक्शन में blue_data आर्ग्युमेंट के रूप में पास करें।

नीले कार्पेट पर डार्क X मार्क तक जाएँ और टर्मिनल की ओर मुड़ें, blue_unpack नामक एक वेरिएबल बनाएँ और उसमें struct.unpack() फ़ंक्शन का रिटर्न वैल्यू स्टोर करें, आर्ग्युमेंट्स के रूप में वही फॉर्मेट और blue_data वेरिएबल पास करें। फॉर्मेट उसी तरह लिखा जाता है जैसे struct.pack() में लिखा गया था, ताकि आप डेटा को उसी तरह डिसीरियलाइज कर सकें जैसे आपने उसे सीरियलाइज किया था। पहले पैक किए गए डेटा को सत्यापित करने के लिए write() फ़ंक्शन में blue_unpack पास करें।

वहीँ हम struct.iter_unpack() फ़ंक्शन का भी उपयोग करेंगे; यह struct.unpack() की तरह ही आर्ग्युमेंट्स लेता है, लेकिन अब इसे for लूप में फॉर्मेट किया जाता है, जिससे हम डेटा को एक-एक ब्लॉक करके इटरेट कर सकते हैं बजाय इसके कि सब कुछ एक साथ लिख दें। फ़ंक्शन का कोड इस प्रकार है:

 for values in struct.iter_unpack(-insert value-, -insert value-):
     player.speak(values)

हम मानों को दिखाने के लिए speak() फ़ंक्शन का उपयोग करेंगे; struct.iter_unpack() फ़ंक्शन में जो आर्ग्युमेंट्स छूटे हैं, उन्हें वही आर्ग्युमेंट्स जोड़ें जो आपने struct.unpack() में उपयोग किए थे, क्योंकि ये कार्यक्षमता में एक ही फ़ंक्शन के वेरिएशन्स हैं।

लाल कार्पेट पर गोल्ड X मार्क तक जाएँ और मेज की तरफ मुड़ें, read() फ़ंक्शन का उपयोग करके फसलों की मात्रा की समीक्षा करें। सभी मात्राओं और प्रत्येक फसल के फॉर्मेट को नोट करें। लाल कार्पेट पर लाइट X मार्क तक जाएँ और buffer नामक एक ऑब्जेक्ट बनाएं, और उसमें bytearray(16) का मान सेट करें। यह बाइट्स का एक कलेक्शन है जिसे हम भरने से पहले एड्रेस कर सकते हैं; हमारे उद्देश्यों के लिए यह डेटा बैंक की तरह काम करता है जहाँ आप मैन्युअली डेटा स्टोर कर सकते हैं। आर्ग्युमेंट के रूप में दिया गया संख्या 16 यह दर्शाता है कि आप buffer ऑब्जेक्ट में कितने बाइट्स स्टोर कर सकते हैं।

struct.pack_into() फ़ंक्शन का उपयोग करके आपने जो buffer ऑब्जेक्ट बनाया है, उसे भरें। फ़ंक्शन का रिटर्न वैल्यू स्टोर करने के लिए कोई वेरिएबल बनाने की आवश्यकता नहीं है, क्योंकि फ़ंक्शन स्वयं मानों को सीधे buffer ऑब्जेक्ट में डाल देगा। हम इस फ़ंक्शन का उपयोग उन सभी मानों के लिए करेंगे जिन्हें हमने पहले नोट किया था और उनके आर्ग्युमेंट्स को उसके अनुसार भरेंगे।

उदाहरण के लिए, पहले फसल के मान के लिए आपको उसका फॉर्मेट, बाइट्स में स्थिति और मात्रा दी जाएगी। पहले आर्ग्युमेंट में फॉर्मेट जोड़ें, दूसरा आर्ग्युमेंट वह लोकेशन होगी जहाँ आप बाइट्स को सीरियलाइज करना चाहते हैं, इस मामले में buffer। तीसरे आर्ग्युमेंट में buffer के भीतर वह पोजीशन सेट करें जहाँ आप मान डालना चाहते हैं; फॉर्मेट तय करता है कितने बाइट्स उपयोग होंगे, इसलिए पहले से भरे हुए हिस्सों पर ओवरलैप न करें। अंत में वह मान जोड़ें जिसे आप buffer ऑब्जेक्ट में सीरियलाइज और पैक करना चाहते हैं।

 struct.pack_into('i', buffer, 0, 82)

buffer ऑब्जेक्ट में पहले बताए अनुसार 16 बाइट्स हैं; ऊपर दिए गए कोड में, integer फॉर्मेट के लिए 4 बाइट्स उपयोग होते हैं और इसे पोजीशन 0 पर डाला गया है। इसका मतलब है कि डेटा डालने के बाद buffer में केवल 12 बाइट्स खाली रहेंगे, क्योंकि पोजीशन 0-3 उस मान (इस केस में 82) से भर चुके हैं। इसे उन सभी फसल डेटा पॉइंट्स के लिए करें जिन्हें आपने पहले पढ़ा और नोट किया था; कुल तीन (3) हैं। सीरियलाइज्ड डेटा दिखाने के लिए display() फ़ंक्शन में buffer पास करें।

लाल कार्पेट पर डार्क X मार्क तक जाएँ और टर्मिनल की ओर मुड़ें; यहाँ हम डेटा को डिसीरियलाइज करके उसकी सामग्री की जांच करेंगे ताकि सही स्टोरेज सुनिश्चित हो सके। तीन वेरिएबल्स बनाएँ: lettuce, carrots और melons; हम प्रत्येक डेटा पॉइंट को व्यक्तिगत रूप से अनपैक करेंगे। प्रत्येक वेरिएबल के लिए struct.unpack_from() फ़ंक्शन का रिटर्न वैल्यू स्टोर करें और पहले यूज़ किए गए उन ही डेटा के आधार पर आर्ग्युमेंट्स सेट करें जिन्हें आपने पैक किया था। पहले आर्ग्युमेंट में फॉर्मेट सेट करें, दूसरे में buffer ऑब्जेक्ट (जहाँ से अनपैक करना है) और अंत में buffer में वह पोजीशन जहाँ से अनपैक करना है। उदाहरण के लिए:

 lettuce = struct.unpack_from('i', buffer, 0)

यह डेटा पहले दिए गए पैकिंग उदाहरण से मेल खाता है; दो अन्य वेरिएबल्स के लिए भी यही प्रक्रिया दोहराएँ और स्तर (level) को पूरा करने के लिए lettuce, carrots और melons को पहले से लिखी गई write() फ़ंक्शन में पास करें।