Python में एन्कैप्सुलेशन: एक व्यापक मार्गदर्शिका

एन्कैप्सुलेशन Python में एक बुनियादी ऑब्जेक्ट-ओरिएंटेड सिद्धांत है। यह आपकी कक्षाओं को आकस्मिक बदलावों या हटाने से बचाता है और कोड के पुन: उपयोग तथा अनुरक्षण को बढ़ावा देता है। इस सरल क्लास परिभाषा पर विचार करें:

class Smartphone:
   def __init__(self, brand, os):
       self.brand = brand
       self.os = os

iphone = Smartphone("Apple", "iOS 17")
संचालित द्वारा

कई Python प्रोग्रामर इस तरह कक्षाएँ परिभाषित करते हैं। हालांकि, यह प्रो Pythonistas द्वारा अपनाई जाने वाली सर्वोत्तम प्रथाओं से काफी दूर है। इस क्लास की समस्या तब स्पष्ट होती है जब आप इसके डेटा को संशोधित करने की कोशिश करते हैं:

iphone.os = "Android"
print(iphone.os)
संचालित द्वारा

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

कल्पना कीजिए, Android पर चल रहा एक iPhone — क्या ही अजीब बात होगी! साफ है, हमें अपनी क्लास के भीतर कुछ सीमाएँ तय करने की ज़रूरत है ताकि उपयोगकर्ता इसकी विशेषताओं को मनमाने ढंग से न बदल सकें।

यदि वे बदलाव करना चाहें भी, तो वे हमारे नियमों के तहत, हमारी शर्तों पर हों। लेकिन हम फिर भी चाहते हैं कि सतह पर .os या .brand एट्रिब्यूट वैसे ही बने रहें।

इन सभी बातों को एन्कैप्सुलेशन के माध्यम से बढ़ावा दिया जा सकता है और इस ट्यूटोरियल में, हम इसके बारे में विस्तार से सीखेंगे। आइए शुरू करते हैं!

Python में एन्कैप्सुलेशन कैसे प्राप्त किया जाता है?

Python मजबूती से लागू किए गए एक्सेस मॉडिफ़ायर्स की बजाय परंपराओं और प्रोग्रामिंग प्रथाओं के माध्यम से एन्कैप्सुलेशन का समर्थन करता है। देखिए, Python कोड डिज़ाइन के पीछे का मूल सिद्धांत है, “हम सभी यहाँ वयस्क हैं।” हम एन्कैप्सुलेशन को केवल एक परंपरा के रूप में लागू कर सकते हैं और उम्मीद कर सकते हैं कि अन्य Python डेवलपर हमारे कोड पर भरोसा करेंगे और उसका सम्मान करेंगे।

Java और C++ जैसी अन्य OOP भाषाओं में, एन्कैप्सुलेशन को public, private या protected जैसे एक्सेस मॉडिफ़ायर्स से सख्ती से लागू किया जाता है, लेकिन Python में वे नहीं हैं:

तो, एन्कैप्सुलेशन की अधिकांश, यदि सभी नहीं, तकनीकें जिन्हें मैं आपको दिखाने जा रहा हूँ, Python की परंपराएँ हैं। यदि आप चाहें तो उन्हें आसानी से तोड़ा जा सकता है। लेकिन मुझे भरोसा है कि आप अपने विकास प्रोजेक्ट्स में उनका सम्मान करेंगे और उनका पालन करेंगे।

Python में एक्सेस मॉडिफ़ायर्स

मान लीजिए हमारे पास यह सरल क्लास है:

class Tree:
   def __init__(self, height):
       self.height = height

pine = Tree(20)
print(pine.height)
संचालित द्वारा

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

इसमें एकमात्र height एट्रिब्यूट है जिसे हम प्रिंट कर सकते हैं। समस्या यह है कि हम इसे किसी भी मान में बदल भी सकते हैं:

pine.height = 50
pine.height
संचालित द्वारा

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

pine.height = "Grandma"
pine.height
संचालित द्वारा

'Grandma'संचालित द्वारा

तो, हम उपयोगकर्ताओं को कैसे बताएँ कि height बदलना वर्जित है? खैर, हम इसे एक protected member में बदल सकते हैं एक अग्रवर्ती अंडरस्कोर जोड़कर:

class Tree:
   def __init__(self, height):
       self._height = height

pine = Tree(20)
pine._height
संचालित द्वारा

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

अब, जो लोग इस परंपरा से परिचित हैं, वे जानेंगे कि वे केवल एट्रिब्यूट का एक्सेस कर सकते हैं और हम इसे उपयोग करने व संशोधित करने से उन्हें कड़े तौर पर हतोत्साहित कर रहे हैं। पर अगर वे चाहें, तो वे इसे संशोधित कर सकते हैं, जी हाँ।

तो, हम इसे भी कैसे रोकें? एक और परंपरा का उपयोग करके — एट्रिब्यूट को डबल अग्रवर्ती अंडरस्कोर जोड़कर एक private member में बदल दें:

class Tree:
   def __init__(self, height):
       self.__height = height


pine = Tree(20)
pine.__height
संचालित द्वारा

AttributeError: 'Tree' object has no attribute '__height'
संचालित द्वारा

अब, यदि कोई एट्रिब्यूट तक पहुँचने की कोशिश करता है, तो Python त्रुटि उठाएगा, संशोधन की बात तो दूर रही।

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

तो, हम उपयोगकर्ताओं के लिए पेड़ की ऊँचाई कैसे उजागर करें लेकिन फिर भी नियंत्रित करें कि उन्हें कैसे एक्सेस और संशोधित किया जाए? उदाहरण के लिए, हम चाहते हैं कि पेड़ की ऊँचाई एक निश्चित सीमा के भीतर हो और केवल पूर्णांक मान हों। हम इसे कैसे लागू करें?

इस बिंदु पर, आपका Java-उपयोगकर्ता मित्र getter और setter मेथड्स का सुझाव दे सकता है। तो, पहले इसे आज़माते हैं:

class Tree:
   def __init__(self, height):
       self.__height = height

   def get_height(self):
       return self.__height

   def set_height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")


pine = Tree(20)
pine.get_height()
संचालित द्वारा

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

इस तरीके से, आप एक निजी एट्रिब्यूट __height बनाते हैं लेकिन उपयोगकर्ताओं को get_height और set_height मेथड्स के माध्यम से नियंत्रित तरीके से इसे एक्सेस और संशोधित करने देते हैं।

pine.set_height(25)

pine.get_height()
संचालित द्वारा

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

नया मान सेट करने से पहले, set_height सुनिश्चित करता है कि नई ऊँचाई एक निश्चित सीमा के भीतर और संख्यात्मक हो।

pine.set_height("Password")
संचालित द्वारा

TypeError: Tree height must be an integer
संचालित द्वारा

लेकिन ये मेथड्स एक सरल ऑपरेशन के लिए ज़रूरत से ज़्यादा लगते हैं। इसके अलावा, इस तरह का कोड लिखना भी भद्दा लगता है:

# Increase height by 5
pine.set_height(pine.get_height() + 5)
संचालित द्वारा

क्या यह और सुंदर और पठनीय नहीं होगा यदि हम यह कोड लिख सकें:

pine.height += 5संचालित द्वारा

और फिर भी ऊँचाई के लिए सही डेटा प्रकार और सीमा लागू कर सकें? जवाब है हाँ, और अगले अनुभाग में हम यही करना सीखेंगे।

Python क्लासेस में @property डेकोरेटर का उपयोग

हम एक नई तकनीक पेश करते हैं — एट्रिब्यूट्स के लिए प्रॉपर्टीज़ बनाना:

class Tree:
   def __init__(self, height):
       # First, create a private or protected attribute
       self.__height = height

   @property
   def height(self):
       return self.__height

pine = Tree(17)
pine.height
संचालित द्वारा

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

हम चाहते हैं कि उपयोगकर्ता छिपे हुए एट्रिब्यूट __height को ऐसे एक्सेस करें मानो वह एक सामान्य एट्रिब्यूट height हो। इसके लिए, हम height नामक एक मेथड परिभाषित करते हैं जो self.__height लौटाता है और उसे @property से डेकोरेट करते हैं।

अब, हम height कॉल कर सकते हैं और निजी एट्रिब्यूट तक पहुँच सकते हैं:

pine.heightसंचालित द्वारा

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

लेकिन सबसे अच्छी बात यह है कि उपयोगकर्ता इसे संशोधित नहीं कर सकते:

pine.height = 15संचालित द्वारा

AttributeError: can't set attribute 'height'
तो, हम height(self, new_height) नाम का एक और मेथड जोड़ते हैं जिसे height.setter डेकोरेटर से रैप किया जाता है। इस मेथड के अंदर, हम वह लॉजिक लागू करते हैं जो ऊँचाई के लिए वांछित डेटा प्रकार और सीमा को लागू करता है:
class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.setter
   def height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")
संचालित द्वारा
अब, जब कोई उपयोगकर्ता height एट्रिब्यूट को संशोधित करने की कोशिश करता है, तो @height.setter कॉल होता है, इस प्रकार यह सुनिश्चित करता है कि सही मान पारित किया जाए:
pine = Tree(10)

pine.height = 33  # Calling @height.setter
pine.height = 45  # An error is raised
संचालित द्वारा
ValueError: Invalid height for a pine tree
संचालित द्वारा
हम डॉट-नोटेशन के माध्यम से height एट्रिब्यूट को कैसे एक्सेस किया जाए, इसे @height.getter से कस्टमाइज़ भी कर सकते हैं:
class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.getter
   def height(self):
       # You can return a custom version of height
       return f"This tree is {self.__height} meters"


pine = Tree(33)

pine.height
संचालित द्वारा
'This tree is 33 meters'संचालित द्वारा
यद्यपि हमने pine को पूर्णांक ऊँचाई के साथ बनाया, हम @height.getter से उसके लौटाए गए मान को बदल सके।
ये उदाहरण दिखाते हैं कि हम Python क्लास में एन्कैप्सुलेशन को कैसे बढ़ावा दे सकते हैं। याद रखें, एन्कैप्सुलेशन अब भी एक परंपरा है क्योंकि हम आंतरिक निजी सदस्य __height को फिर भी तोड़ सकते हैं:
pine._Tree__height = "Gotcha!"

pine.height
संचालित द्वारा
'This tree is Gotcha! meters'संचालित द्वारा
Python क्लासेस में सब कुछ सार्वजनिक होता है, और निजी मेथड्स भी। यह कोई डिज़ाइन खामी नहीं, बल्कि “हम सभी यहाँ वयस्क हैं” दृष्टिकोण का उदाहरण है।
यहाँ उन Python एक्सेस मॉडिफ़ायर्स का सारांश है जिन्हें हमने अभी देखा:
मॉडिफ़ायर/परंपरा
विवरण
उदाहरण
Public
डिफ़ॉल्ट एक्सेस स्तर; एट्रिब्यूट्स और मेथड्स क्लास के बाहर से सुलभ
self.attribute
Protected
एकल अंडरस्कोर द्वारा सूचित; आंशिक रूप से प्रतिबंधित एक्सेस दर्शाने की परंपरा
self._attribute
Private
डबल अंडरस्कोर द्वारा सूचित; नेम-मैंगलिंग सीमित एक्सेस प्रतिबंध प्रदान करता है
self.__attribute
Properties
@property decorator का उपयोग करके निजी एट्रिब्यूट्स तक नियंत्रित एक्सेस प्रदान करता है
@property def attribute(self):
Read-only Properties
@attribute.setter नहीं; एट्रिब्यूट के लिए केवल-पढ़ने का एक्सेस देता है
@property def attribute(self):
एन्कैप्सुलेशन लागू करते समय सर्वोत्तम प्रथाएँ
कुछ सर्वोत्तम प्रथाएँ हैं जिनका पालन करके आप सुनिश्चित कर सकते हैं कि आपका कोड अन्य अनुभवी OOPistas द्वारा लिखे कोड के साथ अच्छी तरह तालमेल बिठाए:

प्रोटेक्टेड या प्राइवेट एट्रिब्यूट्स या मेथड्स बनाएँ यदि उनका उपयोग केवल आप करते हैं। प्रोटेक्टेड या प्राइवेट मेंबर्स प्रलेखन से बाहर रहते हैं और दूसरों को संकेत देते हैं कि आप, डेवलपर, बिना किसी सूचना के उन्हें बदल सकते हैं, इस प्रकार उनके उपयोग से हतोत्साहित करते हैं।
हर एक क्लास एट्रिब्यूट के लिए प्रॉपर्टी बनाना आवश्यक नहीं है। कई एट्रिब्यूट्स वाली बड़ी कक्षाओं में attr.getter और attr.setter मेथड्स लिखना सिरदर्द बन सकता है।
हर बार जब कोई उपयोगकर्ता प्रोटेक्टेड सदस्य (_) एक्सेस करे तो चेतावनी देने पर विचार करें।
प्राइवेट सदस्यों का संयम से उपयोग करें, क्योंकि वे इस परंपरा से अपरिचित लोगों के लिए कोड को अपठनीय बना सकते हैं।
अस्पष्टता पर स्पष्टता को प्राथमिकता दें। क्योंकि एन्कैप्सुलेशन का उद्देश्य कोड अनुरक्षण और डेटा सुरक्षा में सुधार करना है, अपनी क्लास के महत्वपूर्ण कार्यान्वयन विवरणों को पूरी तरह न छिपाएँ।
यदि आप केवल-पढ़ने वाली प्रॉपर्टीज़ बनाना चाहते हैं, तो @attr.setter मेथड लागू न करें। उपयोगकर्ता प्रॉपर्टी को एक्सेस कर पाएँगे पर संशोधित नहीं कर पाएँगे।
हमेशा याद रखें कि एन्कैप्सुलेशन एक परंपरा है, Python की सिंटैक्स द्वारा सख्ती से लागू पहलू नहीं।
सरल कक्षाओं के लिए, dataclasses का उपयोग करने पर विचार करें जो आपको एक ही पंक्ति के कोड से क्लास एन्कैप्सुलेशन सक्षम करने देते हैं। हालाँकि, dataclasses सरल कक्षाओं के लिए होती हैं जिनके एट्रिब्यूट्स और मेथड्स पूर्वानुमेय हों। अधिक जानने के लिए यह dataclasses ट्यूटोरियल देखें।

निष्कर्ष और अतिरिक्त संसाधन
इस ट्यूटोरियल में, हमने Python में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के मुख्य स्तंभों में से एक: एन्कैप्सुलेशन सीखा।
एन्कैप्सुलेशन आपको अपनी क्लास के ऑब्जेक्ट्स के अंदर संग्रहीत डेटा तक नियंत्रित एक्सेस परिभाषित करने देती है। इससे आप स्वच्छ, पठनीय और कुशल कोड लिख पाते हैं और अपनी क्लास डेटा में आकस्मिक बदलाव या हटाने से बचाव होता है।
OOP ज्ञान बढ़ाने के लिए यहाँ कुछ और संबंधित संसाधन हैं:

Python OOP ट्यूटोरियल
Object-oriented Programming in Python
How to Master Python — an Expert Guide
संचालित द्वारा