Header Fields – Designator and Reference Counter

Header Fields – Designator and Reference Counter – तकनीकी रूप से समझें तो Python के Objects केवल Value को Represent करने वाले Reserved Memory Space ही नहीं होते बल्कि पूरा एक Structure होते हैं। Python के प्रत्‍येक Object के दो Standard Header Fields होते हैं। पहले Header Field को Type Designator कहते हैं जो कि Object के Type को Mark करने का काम करता है जबकि दूसरा Header Field Reference Counter कहलाता है जो कि इस बात को तय करता है कि Object को कब फिर से Reclaim कर लेना है।

यानी Reference Counter Field इस बात का निर्णय लेता है कि कब उस Object को कोई भी Variable Reference नहीं कर रहा है और जब उस Object को कोई भी Variable Reference नहीं कर रहा होता है, तब Python द्वारा उस Object की Memory को पूरी तरह से Release करके Garbage Collection कर लिया जाता है।

इन दोनों Fields की कार्यप्रणाली को ठीक से समझने के लिए हमें Objects, Variables व References को Python द्वारा Internally Handle करने की प्रक्रिया को विस्‍तार से समझना होगा और सबसे पहले ये समझना होगा कि जब Python के किसी एक ही Objects में Program के Different Statements में अलग-अलग Type के Data को Multiple बार Assign करते हैं, तब Python इन Different Data Types के Data को Handle करने का काम करता कैसे है।

[code]
pyObject = 12
pyObject = 'KRISHNA'
pyObject = 3.14
[/code]

इस Example के अनुसार जब Python Interpreter इन Statements को Execute करता है तो सबसे पहले एक Integer Object की तरह Behave करता है। फिर अगले Statement में एक String Object बन जाता है और अन्तिम Statement में एक Floating-Point Number Object की तरह व्‍यवहार करने लगता है। Python Program के Runtime में जैसे-जैसे Variable में Store होने वाला Data Change होता जाता है, Variable का Data Type भी Change होता जाता है।

लेकिन वास्‍तव में Internally ऐसा नहीं होता क्‍योंकि Python में किसी Identifier यानी नाम का कोई Data Type नहीं होता बल्कि Data Type, उस Data के Object के आधार पर तय होता है, जिसे Identifier Reference करता है और क्‍योंकि Python में किसी Identifier का कोई Type होता ही नहीं है, इसलिए जब हम एक ही Variable में अलग-अलग Python Statements द्वारा अलग-अलग प्रकार के Data Objects को Assign कर रहे होते हैं, तब वास्‍तव में Identifier में Stored Object के Reference या Link को ही Change कर रहे होते हैं, किसी Actual Variable के Data Type को नहीं।

अन्‍य शब्‍दों में कहें तो पूरे Python Program के दौरान किसी एक Particular Program Statement पर हम किसी Variable में किसी एक Specific Object का Reference ही Hold कर रहे होते हैं और इस Reference को हम Just अगले Statement में Change कर सकते हैं, जिसके परिणामस्‍वरूप वही Variable Just अगले Statement से ही किसी अन्‍य Object को Reference कर सकता है।

जबकि Objects को हमेंशा पता होता है कि वो किस Data Type का है। क्‍योंकि प्रत्‍येक Object में एक Header Field होता है, जिसमें उस Object का Data Type Tag रहता है। उदाहरण के लिए उपरोक्‍त Example Codes के अनुसार-

• Integer Object 12 के Designator Field में int Stored रहता है, जो Python Interpreter को ये Instruction देता है कि ये Object एक Integer Data Type का Object है।
• इसी तरह से String Object ‘KRISHNA’ के Designator Field में str Stored रहता है, जो Python Interpreter को ये Instruction देता है कि ये Object एक String Data Type का Object है।
• जबकि Floating-Point Object14 के Designator Field में float Stored रहता है, जो Python Interpreter को ये Instruction देता है कि ये Object एक Floating-Point Data Type का Object है।

इस प्रकार से Python में Data Types वास्‍तव में Object के साथ Associated रहते हैं, उस Variable के साथ नहीं, जिन्‍हें इन Objects को Reference करने के लिए Declare किया जाता है। इसीलिए Python के Codes इतने Flexible होते हैं और हम एक ही Variable के माध्‍यम से Different Data Types के Objects को Reference करते हुए Polymorphism की सुविधा प्राप्‍त करते हैं।

जैसाकि हमने पहले बताया कि Object के Header में दो Fields होते हैं और उपरोक्‍त Discussion से हमने Header Field Designator की कार्यप्रणाली को समझ भी लिया। अब हम Object के दूसरे Header Field Reference Counter के बारे में समझेंगे।

पिछले Code Segment में हमने एक ही Variable pyObject को तीन अलग तरह के Objects के Reference Assign किए हैं। लेकिन जब हम किसी Variable को किसी अन्‍य Object का Reference Reassign करते हैं, तो उसमें जो पहले Reference Stored था, वह नए Reference से Overwrite हो जाता है।

इस स्थिति में यदि उस पहले वाले Object को Current Variable के साथ ही कोई अन्‍य Variable भी Reference न कर रहा हो, तो Python उस पहले Object को Memory से Delete करके उसके द्वारा Reserved Memory Locations को Automatically Free कर देता है जिसके लिए एक Programmer के रूप में हमें कुछ भी नहीं करना होता। Memory को Automatically Release करने की इस प्रक्रिया को Garbage Collection के नाम से जाना जाता है।

[code]
pyObject = 12
pyObject = 'KRISHNA'    # Release 12 Now
pyObject = 3.14         # Release 'KRISHNA'
[/code]

इस Example के अनुसार जब pyObject Create होता है तब Integer Object 12 के Reference को Hold करता है। फिर जैसे ही अगले Statement में इसी pyObject में String Object ‘KRISHNA‘ को Assign किया जाता है, Integer Object 12 Free हो जाता है और इसे कोई अन्‍य Variable Reference भी नहीं कर रहा है, इसलिए Python इस Integer Object 12 द्वारा Reserved Memory को Free करके Garbage Collection कर लेता है।

फिर इसके Just अगले Statement में इसी pyObject में Floating-Point Object 3.14 को Assign किया जाता है, String Object ‘KRISHNA’ Free हो जाता है और इसे भी कोई अन्‍य Variable Reference नहीं कर रहा है, इसलिए Python इस String Object ‘KRISHNA’ द्वारा Reserved Memory को भी Free करके Garbage Collection कर लेता है।

Garbage Collection करने का ये सारा काम पूरी तरह से Automatically होता है, जिसके लिए एक Python Programmer के रूप में हमें कुछ भी नहीं करना होता। परिणामस्‍वरूप Garbage Collection करना भूल जाने की वजह से पैदा होने वाली समस्‍याओं से पूरी तरह से छुटकारा मिल जाता है।

Python में प्रत्‍येक Object के Header में Reference Counter नाम का जो दूसरा Field होता है, उसमें हमेंशा इस बात की जानकारी होती है कि उस Object को Currently कितने Variables Reference कर रहे हैं।

यानी जब भी कोई Variable Create होकर किसी Object को Reference करना शुरू करता है, उस Object के Reference Counter का मान Increment होकर 0 से 1 हो जाता है। फिर अगर एक और Variable Create किया जाए, और उसी Object को उस नए Variable में भी Assign कर दिया जाए, तो उस Object के Reference Counter का मान Increment होकर 1 से 2 हो जाता है और ये प्रक्रिया तब तक चलती रहती है, जब तक उस Specific Objects को नए-नए Variables Reference करते रहते हैं।

ठीक यही प्रक्रिया Reverse Side में भी समान प्रकार से काम करता है और जैसे ही Object को Reference करने वाले Variable किसी अन्‍य Object को Reference करने लगते हैं, Current Object के Reference Counter का मान Decrease होने लगता है।

यानी यदि किसी Object को 3 Variables Reference कर रहे हों, और अगले Statement में कोई एक Variable Current Variable के स्‍थान पर किसी अन्‍य Variable को Reference करने लगे, तो तुरन्‍त उस Object के Reference Counter का मान Decrease होकर 3 से 2 हो जाएगा और जब Reference Counter का मान Decrease होते-होते 0 हो जाएगा, Automatically Python का Garbage Collector Process Execute होगा और उस Object के लिए Reserved Memory को Release कर देगा।

इस प्रक्रिया को यदि हम पिछले Code Segment के आधार पर समझें तो जब pyObject सबसे पहले Create होता है, तब उसमें Integer Object 12 का Reference Store हो जाता है साथ ही इस Integer Object 12 के Reference Counter का मान Increase होकर 0 से 1 हो जाता है क्‍योंकि अब इस Integer Object 12 को pyObject नाम का एक Variable Reference कर रहा है।

लेकिन अगले Statement में जैसे ही ये pyObject, String Object ‘KRISHNA’ को Reference करने लगता है, String Object ‘KRISHNA’ में Exist Reference Counter का मान Increase होकर 0 से 1 हो जाता है लेकिन साथ ही Integer Object 12 के Reference Counter का मान Decrease होकर 1 से 0 हो जाता है क्‍योंकि अब इस Integer Object 12 को कोई भी Variable Reference नहीं कर रहा है और जैसे ही Integer Object 12 के Reference Counter का मान Decrease होकर 1 से 0 होता है, Python का Garbage Collector Execute होकर Integer Object 12 के लिए Reserved Memory को Release कर देता है।

Reference Counter के Increase व Decrease होने की ये प्रक्रिया पूरे Program के दौरान लगातार चलती रहती है और इस पूरी प्रक्रिया की एक Programmer के रूप में न तो हमें कोई जानकारी होती है न ही हमें कोई जानकारी रखने की जरूरत होती है क्‍योंकि Python इस प्रक्रिया को जरूरत के अनुसार स्‍वयं ही अपने स्‍तर पर Automatically Perform करता रहता है।