उद्देश्य

struct module का उपयोग करते हुए नए फार्मलैंड के लिए अंतिम डेटा ब्रेकडाउन सेटअप करें।

सड़क के अंत में एक सर्विस स्टेशन है जो पहले से निर्मित नए फार्मलैंड और पहले से रोपे गए फसलों का प्रबंधन करता है। यहाँ हम पहले से रोपे गए फसलों और फार्मलैंड के संभावित उत्पादन का निरीक्षण और प्रसंस्करण करेंगे। इस अध्याय के अन्य स्तरों की तरह, हम डेटा को सीरियलाइज़ और डी-सीरियलाइज़ करने के साथ काम करेंगे, और अंत में struct module नामक एक अंतिम मॉड्यूल को पेश करेंगे।

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

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

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

गोल्ड X मार्क की ओर जाएँ और नए फार्मलैंड पर डेटा एकत्र करने के लिए read() फंक्शन का उपयोग करें, तथा भविष्य के उपयोग के लिए डेटा बिंदुओं और उनके फॉर्मेट का नोट करें, जैसे कि: Resources, Size और Estimate. इस जानकारी को नोट करने के पश्चात, लाइट X मार्क की ओर जाएँ नीले कालीन पर और एक वेरिएबल बनाएँ जिसका नाम blue_data हो।

blue_data वेरिएबल में struct.pack() फंक्शन का परिणाम संग्रहित करें, जिसमें पहले आप द्वारा नोट किए गए फॉर्मेट और मानों को arguments के रूप में सेट करें। फॉर्मेट लिखते समय, आपको फॉर्मेट प्रकारों को एकल यूनिट में "pack" करना होगा। उदाहरण के लिए, पूर्णांक फॉर्मेट 'i' के रूप में दर्शाया गया है जैसा कि ऊपर बताया गया है, यदि आप तीन पूर्णांक डेटा प्रकार जोड़ रहे हैं, तो आप उन्हें 'iii' के रूप में जोड़ेंगे। इसी प्रकार, यदि आप एक पूर्णांक, एक फ्लोट और एक डबल जोड़ रहे हैं, तो इसे 'ifd' लिखा जाएगा। डेटा जोड़ते समय, उन्हें व्यक्तिगत arguments के रूप में रखें। यहाँ एक समग्र उदाहरण है:

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 को argument के रूप में प्रदान करें।

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

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

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

हम मान प्रदर्शित करने के लिए speak() फंक्शन का उपयोग करेंगे, तथा struct.iter_unpack() फंक्शन में गायब arguments के स्थान पर वे ही arguments जोड़ें जो पहले struct.unpack() में उपयोग किए गए थे, क्योंकि ये एक ही फंक्शन के विभिन्न रूप हैं, उपयोग में समान।

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

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

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

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

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

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

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

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