क्या पायथन के पास कक्षाओं में "निजी" चर हैं?

Question

मैं जावा दुनिया से आ रहा हूं और ब्रूस एकल्स के पायथन 3 पैटर्न, व्यंजनों और मुहावरों को पढ़ रहा हूं ।

कक्षाओं के बारे में पढ़ते समय, यह कहा जाता है कि पायथन में उदाहरण चर घोषित करने की आवश्यकता नहीं है। आप उन्हें केवल कंस्ट्रक्टर में उपयोग करते हैं, और बूम करते हैं, वे वहां हैं।

उदाहरण के लिए:

class Simple:
    def __init__(self, s):
        print("inside the simple constructor")
        self.s = s

    def show(self):
        print(self.s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

यदि यह सच है, तो कक्षा की कोई भी वस्तु कक्षा के बाहर Simpleपरिवर्तनशील मूल्य को बदल सकती है s।

उदाहरण के लिए:

if __name__ == "__main__":
    x = Simple("constructor argument")
    x.s = "test15" # this changes the value
    x.show()
    x.showMsg("A message")

जावा में, हमें सार्वजनिक / निजी / संरक्षित चर के बारे में सिखाया गया है। वे कीवर्ड समझ में आते हैं क्योंकि कई बार आप एक ऐसी कक्षा में चर चाहते हैं, जिस पर कक्षा के बाहर कोई भी नहीं पहुँच पाता है।

अजगर में इसकी आवश्यकता क्यों नहीं है?

Comments

आप उदाहरण चर, वर्ग चर, सही नहीं था?

— पॉलएमसीजी

आपको गुणों की जांच करनी चाहिए: docs.python.org/library/functions.html#property । बस गेटटर का उपयोग करें और आपके चर की रक्षा की जाएगी।

— रुबिक

एक छोटा और कुरकुरा जवाब यहाँ है । मुझे उम्मीद है कि इससे सहायता मिलेगी।

— प्रेमकुमार चल्मेटी

Answer 1

यह सांस्कृतिक है। पायथन में, आप अन्य वर्गों के उदाहरण या वर्ग चर के लिए नहीं लिखते हैं। जावा में, कुछ भी आपको ऐसा करने से रोकता है यदि आप वास्तव में चाहते हैं - आखिरकार, आप हमेशा उसी प्रभाव को प्राप्त करने के लिए कक्षा के स्रोत को स्वयं संपादित कर सकते हैं। अजगर सुरक्षा का ढोंग करता है और प्रोग्रामरों को जिम्मेदार होने के लिए प्रोत्साहित करता है। व्यवहार में, यह बहुत अच्छी तरह से काम करता है।

यदि आप किसी कारण से निजी चर का अनुकरण करना चाहते हैं, तो आप हमेशा पीईपी 8__ से उपसर्ग का उपयोग कर सकते हैं । पायथन चर के नामों को इस तरह से व्यवस्थित करता है कि वे आसानी से उस वर्ग के बाहर कोड करने के लिए दिखाई नहीं देते हैं, जिसमें उन्हें शामिल किया गया है (हालांकि आप इसके चारों ओर प्राप्त कर सकते हैं यदि आप पर्याप्त रूप से निर्धारित हैं, जैसे आप जावा के सुरक्षा उपायों के आसपास हो सकते हैं यदि आप इस पर काम करते हैं )।__foo

उसी कन्वेंशन के द्वारा, _उपसर्ग का मतलब दूर रहना भले ही आप तकनीकी रूप से ऐसा करने से न रोकें । आप किसी अन्य वर्ग के चर के साथ नहीं खेलते हैं जो देखने में __fooया जैसा दिखता है _bar।

Comments

यह समझ आता है। हालांकि, मुझे नहीं लगता कि जावा में कक्षा के बाहर निजी चर तक पहुंचने का कोई तरीका है (वास्तव में वर्ग के स्रोत को बदलने के अलावा)। है?

— सर्वव्यापी

मैं अजगर रास्ता पसंद करते हैं, लेकिन मुझे नहीं लगता कि जावा रास्ता उतना ही व्यर्थ है जितना कि आप बनाते हैं। कुछ निजी घोषित करना किसी को जल्दी से कोड को पढ़ने से किसी को बहुत उपयोगी बताता है: यह फ़ील्ड केवल इस वर्ग के अंदर ही संशोधित है।

— नेड

@Onipresent, आप प्रतिबिंब का उपयोग कर सकते हैं।

— रैपादुरा

मुझे इसे सीधे करने दें, इसलिए पायथन सार्वजनिक और निजी विशेषताओं को लागू नहीं करता है क्योंकि "इसकी सुरक्षा का ढोंग और प्रोग्रामर को जिम्मेदार होने के लिए प्रोत्साहित करता है", हालांकि समुदाय निजी चर और तरीकों को निरूपित करने के लिए "_" के उपयोग को प्रोत्साहित करता है। शायद अजगर को निश्चित रूप से सार्वजनिक और निजी नहीं होना चाहिए? उनका मुख्य उद्देश्य आपको यह बताना है कि एक वर्ग के साथ बातचीत करने के लिए आपको किस एपीआई का उपयोग करना चाहिए। वे इन तरीकों का उपयोग करने के लिए एक दस्तावेज के रूप में कार्य करते हैं और उन का उपयोग नहीं करते हैं। वे "सुरक्षा का ढोंग" नहीं कर रहे हैं, वे एपीआई दस्तावेज़ीकरण हैं, जिनका उपयोग आईडीई द्वारा आपको मार्गदर्शन करने के लिए भी किया जा सकता है!

— पेडरोड

यह एक अच्छा जवाब है और आपका तर्क निश्चित रूप से मान्य है, लेकिन मैं एक पहलू से असहमत हूं। एक्सेस मॉडिफायर का उद्देश्य कभी सुरक्षा नहीं रहा । बल्कि, वे स्पष्ट रूप से सीमांकन (और एक बड़ी हद तक, लागू करने) का एक साधन हैं जो किसी वर्ग के उन हिस्सों को आंतरिक माना जाता है और जो उस वर्ग के बाहरी उपयोगकर्ताओं के संपर्क में होते हैं। कन्वेंशन (संस्कृति) निश्चित रूप से संशोधक का उपयोग करने के लिए एक वैध विकल्प है, और दोनों तरीकों में उनके पेशेवरों और विपक्ष हैं, लेकिन यह इस उद्देश्य के लिए भ्रामक है कि भाषा-स्तरीय एक्सेस संशोधक किसी भी तरह से "सुरक्षित" होने के लिए सामान्य अर्थ में हैं। शब्द।

— devios1

Answer 2

अजगर में निजी चर कम या ज्यादा हैक होते हैं: दुभाषिया जानबूझकर चर का नाम बदल देता है।

class A:
    def __init__(self):
        self.__var = 123
    def printVar(self):
        print self.__var

अब, यदि आप __varवर्ग परिभाषा के बाहर पहुँचने का प्रयास करते हैं, तो यह विफल हो जाएगा:

 >>>x = A()
 >>>x.__var # this will return error: "A has no attribute __var"

 >>>x.printVar() # this gives back 123

लेकिन आप आसानी से इससे दूर हो सकते हैं:

 >>>x.__dict__ # this will show everything that is contained in object x
               # which in this case is something like {'_A__var' : 123}

 >>>x._A__var = 456 # you now know the masked name of private variables
 >>>x.printVar() # this gives back 456

आप शायद जानते हैं कि ओओपी में विधियां इस तरह से लागू की जाती हैं: x.printVar() => A.printVar(x)यदि A.printVar()कुछ क्षेत्र में xप्रवेश किया जा सकता है, तो इस क्षेत्र को बाहर भी एक्सेस किया जा सकता है A.printVar()... आखिरकार, पुन: प्रयोज्य के लिए फ़ंक्शन बनाए जाते हैं, अंदर बयानों को कोई विशेष शक्ति नहीं दी जाती है।

जब संकलक शामिल होता है तो खेल अलग होता है ( गोपनीयता संकलक स्तर की अवधारणा है )। यह अभिगम नियंत्रण संशोधक के साथ वर्ग परिभाषा के बारे में जानता है, इसलिए यह निर्धारित करने में त्रुटि हो सकती है कि नियमों का संकलन समय पर नहीं किया जा रहा है

Comments

संक्षेप में, यह इनकैप्सुलेशन नहीं है

— वाटशीशुन

मुझे आश्चर्य है कि अगर PHP अपने नासमझ निजी चर के साथ कुछ समान है - क्योंकि निजी चर वास्तव में व्याख्या की गई भाषा में समझ में नहीं आते हैं - मेरा मतलब है कि x चर को जानने का क्या अनुकूलन हो सकता है, अगर यह संकलित नहीं है?

— NoBugs

हम निजी चर के पैटर्न को कैसे यादृच्छिक बना सकते हैं?

— क्रिट्रॉन

@ क्राइसन एक ही प्रश्न

— इयान

@watashiSHUN "संक्षेप में, यह इनकैप्सुलेशन नहीं है" => हाँ यह है। एनकैप्सुलेशन केवल सार्वजनिक एपीआई का उपयोग करने के बारे में है ताकि ग्राहक कोड कार्यान्वयन परिवर्तनों से सुरक्षित हो। एपीआई और क्या कार्यान्वयन है, यह बताने के लिए नामकरण सम्मेलनों को पूरी तरह से मान्य तरीका है, और मुद्दा यह है कि यह सिर्फ काम करता है।

— ब्रूनो डेथिलियर्स

Answer 3

जैसा कि ऊपर की कई टिप्पणियों द्वारा सही ढंग से उल्लेख किया गया है, आइए एक्सेस मॉडिफायर के मुख्य लक्ष्य को न भूलें: कोड के उपयोगकर्ताओं को यह समझने में मदद करने के लिए कि क्या बदलना है और क्या नहीं करना चाहिए। जब आप एक निजी क्षेत्र देखते हैं तो आप उसके साथ खिलवाड़ नहीं करते हैं। तो यह ज्यादातर सिंटैक्टिक शुगर है जो पायथन में _ और __ द्वारा आसानी से हासिल की जाती है।

Comments

मुझे लगता है कि यह किसी भी बिंदु के रूप में महत्वपूर्ण है। जब डिबगिंग कोड (मुझे पता है, मैं बग को लागू करने के लिए कमजोर हूं), तो यह जान लें कि कौन सा वर्ग बदल सकता है एक सदस्य चर डिबगिंग प्रक्रिया को सरल करता है। कम से कम, यदि चर कुछ दायरे द्वारा संरक्षित है। एक समान अवधारणा C ++ में कास्ट फ़ंक्शन है। मुझे पता है कि सदस्य चर वहां नहीं बदले गए थे और इसलिए मैं उस पद्धति को भी नहीं देखता क्योंकि खराब परिवर्तनीय सेटिंग का संभावित कारण। यद्यपि यह कक्षा के विस्तार / सुविधाओं को जोड़ने के बाद का विकास कर सकता है, लेकिन कोड की दृश्यता को सीमित करने से डिबग करना आसान हो जाता है।

— मि .मास

Answer 4

अंडरस्कोर सम्मेलन में निजी चर की भिन्नता है।

In [5]: class Test(object):
   ...:     def __private_method(self):
   ...:         return "Boo"
   ...:     def public_method(self):
   ...:         return self.__private_method()
   ...:     

In [6]: x = Test()

In [7]: x.public_method()
Out[7]: 'Boo'

In [8]: x.__private_method()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-8-fa17ce05d8bc> in <module>()
----> 1 x.__private_method()

AttributeError: 'Test' object has no attribute '__private_method'

कुछ सूक्ष्म अंतर हैं, लेकिन प्रोग्रामिंग पैटर्न वैचारिक पवित्रता के लिए, इसकी काफी अच्छी है।

वहाँ @ उदाहरण सज्जाकार के उदाहरण हैं जो अवधारणा को अधिक बारीकी से लागू करते हैं, लेकिन YMMV। संभवत: कोई भी क्लास डिफिनेशन लिख सकता है जो मेटा का उपयोग करता है

Comments

मुझे एहसास है कि यह पार्टी के लिए बहुत देर हो चुकी है, लेकिन इस लिंक को गूगल पर दिखाया जाता है जब इस मुद्दे को गुगली करता है। यह पूरी कहानी नहीं बताती है। __xके रूप में वर्ग के अंदर एक चर Aवास्तव में संकलक द्वारा फिर से लिखा गया है _A__x, यह अभी भी पूरी तरह से निजी नहीं है और अभी भी पहुँचा जा सकता है।

— जोर्फ

बेशक, अगर मुझे नाम का एक चर दिखाई देता है, तो मैं _A__xउसे छूने नहीं जा रहा हूं। यह संक्रामक हो सकता है। मैं नरक को इससे दूर भगाऊंगा।

— मतीन उलहाक

यकीन है कि यह एक असली निजी नहीं है । लेकिन C ++ और Java (आदि), कंपाइलर ऑप्टिमाइजेशन में कठिन लागू प्राइवेट के लिए तर्क सिद्धांत, वास्तव में पायथन में मौजूद नहीं है, इसलिए बाय-कन्वेंशन प्राइवेट काफी अच्छा है। पायथन सम्मेलन आम तौर पर यह है कि यह भरोसा करता है कि आप खुद को पर्यवेक्षण के बिना व्यवहार करेंगे। (और यह एक नौसिखिया जाल है, लेकिन आप जानते हैं, बस वर्ग डिजाइन और खपत के बारे में विचारशील हो)

— Shayne

Answer 5

"जावा में, हमें सार्वजनिक / निजी / संरक्षित चर के बारे में सिखाया गया है"

"अजगर में ऐसा क्यों नहीं है?"

उसी कारण से, जावा में इसकी आवश्यकता नहीं है ।

आप उपयोग करने के लिए स्वतंत्र हैं - या नहीं का उपयोग करें privateऔर protected।

पायथन और जावा प्रोग्रामर के रूप में, मैंने पाया है कि privateऔर protectedबहुत, बहुत महत्वपूर्ण डिजाइन अवधारणाएं हैं। लेकिन एक व्यावहारिक बात के रूप में, जावा और अजगर की लाइनों के हजारों में, मैं कभी नहीं किया है वास्तव में इस्तेमाल किया privateया protected।

क्यों नहीं?

यहाँ मेरा सवाल है "किससे संरक्षित?"

मेरी टीम के अन्य प्रोग्रामर? उनके पास स्रोत है। जब वे इसे बदल सकते हैं तो इसका क्या मतलब है?

अन्य टीमों पर अन्य प्रोग्रामर? वे एक ही कंपनी के लिए काम करते हैं। वे कर सकते हैं - एक फोन कॉल के साथ - स्रोत प्राप्त करें।

ग्राहकों को? यह काम के लिए (आमतौर पर) प्रोग्रामिंग है। ग्राहकों (आम तौर पर) कोड के मालिक हैं।

तो, कौन - ठीक - मैं इसे से बचा रहा हूँ?

Comments

-1: मैं पोर्कुलस से सहमत हूं। यह किसी चीज को एक्सेस करने या छिपाने से मना करने के बारे में नहीं है, यह अंतर्निहित एपीआई प्रलेखन के बारे में है । डेवलपर्स के साथ-साथ कंपाइलर / दुभाषिया / कोड-चेकर आसानी से देखते हैं कि कौन से सदस्यों का उपयोग करने की सिफारिश की जाती है और किन लोगों को स्पर्श नहीं किया जाना चाहिए (या कम से कम देखभाल के साथ)। ज्यादातर मामलों में यह एक भयानक गड़बड़ होगी अगर किसी वर्ग या मॉड्यूल के सभी सदस्य सार्वजनिक थे। एक सेवा के रूप में निजी / संरक्षित / सार्वजनिक सदस्यों के भेद पर विचार करें, यह कहते हुए: "अरे, ये सदस्य महत्वपूर्ण हैं, जबकि आंतरिक रूप से उपयोग किए जाते हैं और शायद आपके लिए उपयोगी नहीं हैं।"

— ओबेन सोन

@ S.Lott: मैं इस बात से सहमत हूं कि एपीआई डॉक्स की प्राथमिकता अधिक होती है और अक्सर एपीआई के इच्छित उपयोग को संप्रेषित करने का एकमात्र तरीका होता है। लेकिन कभी-कभी सदस्य के नाम और दृश्यता (निजी / सार्वजनिक के संदर्भ में) पर्याप्त रूप से अपने दम पर बोलते हैं। इसके अलावा, मैं आपकी बात देखता हूं कि निहित दस्तावेज का विचार संपादकों w / o एपीआई निरीक्षण में अच्छी तरह से काम नहीं करता है, लेकिन यह IDE के कोड पूरा होने के साथ वास्तव में सहायक है। यह मानकर कि आपने कुछ समय पहले ही एपीआई डॉक्स पढ़े हैं, यह आपको यह याद रखने में मदद करता है कि क्लास कैसे इस्तेमाल करें। निजी और सार्वजनिक सदस्यों के बीच कोई अंतर नहीं होने पर चीजें उस स्मार्ट काम नहीं करेंगी।

— ओबेन सोनाने

चर्चा में देर से, लेकिन पोर्कुलस और ओबेन के अनुरोध के अनुसार यहां "अंडरसिंक के साथ इसे उपसर्ग" कन्वेंशन द्वारा पूरी तरह से पर्याप्त रूप से संभाला जाता है (और नुकसान के बिना उस कन्वेंशन के कंपाइलर प्रवर्तन का कारण बन सकता है)

— nchhlan

@ S.Lott मैं एक अजगर आदमी नहीं हूं, इसलिए मैं उस दृष्टिकोण से टिप्पणी नहीं करूंगा। हालांकि एक जावा डेवलपर के रूप में यह वास्तव में भयानक सलाह है। -1

— डेबर्न

वाह। आप इस बिंदु को पूरी तरह से याद करते हैं, आप बहुत बुरी सलाह देते हैं, आप किसी का भी अपमान करते हैं जो इस बिंदु पर आपसे असहमत है, लेकिन आपको अभी भी इस "उत्तर" के लिए बैज और 1000 से अधिक प्रतिष्ठा अंक मिलते हैं।

— एरिक डुमिनील

Answer 6

जैसा कि पहले उल्लेख किया गया है, आप संकेत दे सकते हैं कि एक चर या विधि एक अंडरस्कोर के साथ उपसर्ग करके निजी है। यदि आपको ऐसा नहीं लगता है कि यह पर्याप्त है, तो आप हमेशा propertyडेकोरेटर का उपयोग कर सकते हैं । यहाँ एक उदाहरण है:

class Foo:

    def __init__(self, bar):
        self._bar = bar

    @property
    def bar(self):
        """Getter for '_bar'."""
        return self._bar

इस तरह, कोई व्यक्ति या कोई चीज़ जो संदर्भ barवास्तव barमें चर के बजाय फ़ंक्शन के रिटर्न मान को संदर्भित कर रहा है, और इसलिए इसे एक्सेस किया जा सकता है लेकिन इसे बदला नहीं जा सकता है। हालांकि, अगर कोई वास्तव में चाहता था, तो वे बस इसका उपयोग कर सकते हैं _barऔर इसे एक नया मान दे सकते हैं। चर और तरीकों को एक्सेस करने से रोकने का कोई निश्चित तरीका नहीं है जिसे आप छिपाना चाहते हैं, जैसा कि बार-बार कहा गया है। हालाँकि, उपयोग propertyस्पष्ट संदेश है जिसे आप भेज सकते हैं कि एक चर को संपादित नहीं किया जाना है। propertyअधिक जटिल गेट्टर / सेटर / डेलेटर एक्सेस पाथ के लिए भी इस्तेमाल किया जा सकता है, जैसा कि यहाँ बताया गया है: https://docs.python.org/3/library/functions.html#property

Comments

Django भी इस की सराहना करते हैं।

— babygame0ver

Answer 7

पायथन के पास निजी पहचानकर्ताओं के लिए सीमित समर्थन है, एक ऐसी सुविधा के माध्यम से जो दो अंडरस्कोर के साथ शुरू होने वाले किसी भी पहचानकर्ता के लिए स्वचालित रूप से वर्ग का नाम प्रस्तुत करता है। यह प्रोग्रामर के लिए पारदर्शी है, अधिकांश भाग के लिए, लेकिन शुद्ध प्रभाव यह है कि इस तरह नामित किसी भी चर को निजी चर के रूप में उपयोग किया जा सकता है।

उस पर और अधिक के लिए यहाँ देखें ।

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

Comments

हां। सौंदर्य है, अजगर की क्षमताओं का मतलब है कि आप वास्तव में फैंसी सामान को लागू कर सकते हैं यदि आप चाहते हैं (और वहाँ पुस्तकालय हैं जो @ निजी / @ संरक्षित / आदि सज्जाकार और सामान को लागू करते हैं। नर्क मैंने एक पुस्तकालय भी देखा है जो जेएस शैली के प्रोटोटाइप वर्गों की नकल करता है। बिना किसी गॉडडाउन सेंस के कारण), लेकिन व्यवहार में यह सिर्फ इतना ही आवश्यक नहीं है .. मैं "अजगर / जेएस / जो कुछ भी एक लिस्प" से नफरत करता हूं, क्योंकि इसकी लगभग कभी भी सच नहीं है, लेकिन अजगर साझा करता है 'मेट्रोग्रामग्रामिंग चॉप्स को सरल वाक्य रचना के साथ जोड़ा जाता है। 'उस भाषा के साथ

— Shayne

Answer 8

जब भी मैं कभी-कभी निजी चर का उपयोग करता हूं तो केवल वही होता है जब मुझे चर से लिखते या पढ़ते समय अन्य चीजों को करने की आवश्यकता होती है और जैसे कि मुझे एक सेटर और / या गेट्टर के उपयोग को मजबूर करने की आवश्यकता होती है।

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

जब आप किसी ऐसी परियोजना पर होते हैं जहां कोई भी एक एक्सटेंशन लिख सकता है, तो उपयोगकर्ताओं को कुछ रिलीज में गायब होने वाले तरीकों के बारे में सूचित करना इसलिए अपग्रेड पर कम से कम मॉड्यूल टूटना महत्वपूर्ण है।

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

Answer 9

निजी और संरक्षित अवधारणाएं बहुत महत्वपूर्ण हैं। लेकिन अजगर - विकास के लिए उपलब्ध सीमित संसाधनों के साथ प्रोटोटाइप और तेजी से विकास के लिए सिर्फ एक उपकरण है, यही वजह है कि अजगर में संरक्षण के कुछ स्तरों का इतना सख्त पालन नहीं किया जाता है। आप क्लास सदस्य में "__" का उपयोग कर सकते हैं, यह ठीक से काम करता है, लेकिन पर्याप्त अच्छा नहीं दिखता है - ऐसे क्षेत्र में प्रत्येक एक्सेस में ये वर्ण होते हैं।

इसके अलावा, आप देख सकते हैं कि अजगर ओओपी अवधारणा सही नहीं है, स्माल्टॉक या रूबी शुद्ध ओओपी अवधारणा के बहुत करीब है। यहां तक ​​कि C # या Java करीब हैं।

अजगर बहुत अच्छा उपकरण है। लेकिन यह ओओपी भाषा सरल है। सिंथेटिक और वैचारिक रूप से सरलीकृत। अजगर के अस्तित्व का मुख्य लक्ष्य बहुत तेजी से उच्च अमूर्त स्तर के साथ आसान पठनीय कोड लिखने के लिए डेवलपर्स की संभावना को लाने के लिए है।

Comments

रियरसन प्राइवेट एंड प्रोटेक्टेड यह महत्वपूर्ण है कि सांख्यिकीय रूप से संकलित भाषाओं में कंपाइलर निजी विधि से अप्रत्यक्ष कॉल कर सकते हैं, लेकिन सार्वजनिक तरीकों के लिए लुकअप टेबल पर भरोसा करना चाहिए। थीस बस गतिशील भाषाओं के साथ एक मुद्दा नहीं है। अंत में सी ++ जैसी भाषाएं विरासत और विधि संकल्प के निहितार्थ हैं। पायथन और रूबी में OO के समान कार्यान्वयन हैं, इसलिए तुलना अर्थहीन है। स्मॉलटाक वास्तव में सार्वजनिक / निजी संदेशों की कोई धारणा नहीं है। एक श्रेणी के रूप में निजी जोड़ने के लिए आपका मुफ्त है, लेकिन इसकी विशुद्ध रूप से सलाहकार है।

— शाइनी

मेरे दावे को आगे बढ़ाने के लिए। देखने का एक कोडिंग हाइजीन पॉइंट फ्रॉर्म, हां वे एनकैप्सुलेशन के लिए महत्वपूर्ण हैं, लेकिन इसके लिए यह आवश्यक नहीं है , और इसलिए @ पाइरेक्ट (आदि) डेकोरेटर किसी भी चीज़ से अधिक सलाहकार हैं, लेकिन निजी / सार्वजनिक के रूप में अनुकूलन के लिए उपयोगी कुछ भी नहीं जोड़ता है गैर-स्थिर भाषा, इसका किसी गहरे स्तर पर लागू नहीं किया जाता है जैसे यह संकलित भाषा में होगा जैसे जावा या सी

— Shayne

Answer 10

खेद है कि लोगों को "पुनरुत्थान" के लिए धागा, लेकिन, मुझे आशा है कि इससे किसी को मदद मिलेगी:

Python3 में, यदि आप जावा में क्लास विशेषताओं की तरह "एनकैप्सुलेट" करना चाहते हैं, तो आप बस उसी तरह कर सकते हैं जैसे:

class Simple:
    def __init__(self, str):
        print("inside the simple constructor")
        self.__s = str

    def show(self):
        print(self.__s)

    def showMsg(self, msg):
        print(msg + ':', self.show())

इसे तुरंत करने के लिए:

ss = Simple("lol")
ss.show()

ध्यान दें: print(ss.__s)एक त्रुटि फेंक देंगे।

व्यवहार में, Python3 वैश्विक विशेषता नाम को बाधित करेगा। जावा में "निजी" विशेषता की तरह इसे चालू करना। विशेषता का नाम अभी भी वैश्विक है, लेकिन एक दुर्गम तरीके से, अन्य भाषाओं में एक निजी विशेषता की तरह।

लेकिन इससे डरो मत। इससे कोई फर्क नहीं पड़ता। यह काम भी करता है। ;)

Comments

यह पाइथन 1.5.2 IIRC के बाद से अस्तित्व में है, और यह अभी भी अपने नाम के नाम के माध्यम से विशेषता तक पहुंचने से नहीं रोकता है।

— ब्रूनो डेथिलियर्स

Answer 11

अजगर के पास C ++ या Java does जैसे कोई भी निजी चर नहीं है। यदि आप चाहते हैं, तो आप किसी भी समय किसी भी सदस्य चर का उपयोग कर सकते हैं। हालाँकि, आपको पायथन में निजी चर की आवश्यकता नहीं है, क्योंकि पायथन में अपने वर्ग के सदस्य चर को उजागर करना बुरा नहीं है। यदि आपको किसी सदस्य चर को एनकोड करने की आवश्यकता है, तो आप मौजूदा क्लाइंट कोड को तोड़ने के बिना बाद में "@property" का उपयोग करके ऐसा कर सकते हैं।

अजगर में एकल अंडरस्कोर "_" का उपयोग यह इंगित करने के लिए किया जाता है, कि किसी विधि या चर को किसी वर्ग की सार्वजनिक एपीआई के हिस्से के रूप में नहीं माना जाता है और यह कि एपीआई का यह हिस्सा विभिन्न संस्करणों के बीच बदल सकता है। आप इन विधियों / चर का उपयोग कर सकते हैं, लेकिन आपका कोड टूट सकता है, यदि आप इस वर्ग के नए संस्करण का उपयोग करते हैं।

डबल अंडरस्कोर "__" का अर्थ "निजी चर" नहीं है। आप इसका उपयोग उन चर को परिभाषित करने के लिए करते हैं जो "क्लास लोकल" हैं और जिन्हें आसानी से उपवर्गों द्वारा ओवरले नहीं किया जा सकता है। यह चर नाम का प्रबंधन करता है।

उदाहरण के लिए:

class A(object):
    def __init__(self):
        self.__foobar = None # will be automatically mangled to self._A__foobar

class B(A):
    def __init__(self):
        self.__foobar = 1 # will be automatically mangled to self._B__foobar

स्व। फ़ोबोबर का नाम स्वचालित रूप से स्व ._A__foobar के वर्ग ए में रखा गया है। कक्षा बी में यह स्व। इसलिए प्रत्येक उपवर्ग अपने माता-पिता चर (ओं) को देखे बिना अपने स्वयं के चर __foobar को परिभाषित कर सकता है। लेकिन कुछ भी आपको डबल अंडरस्कोर के साथ शुरू होने वाले चर तक पहुंचने से रोकता है। हालाँकि, नाम-प्रबंध आपको इस चर / विधियों को संयोगवश कॉल करने से रोकता है।

मैं रेमंड हेटिंगर्स को पाइकॉन 2013 से "पायथन क्लास डेवलपमेंट टूलकिट" (यूट्यूब पर उपलब्ध होना चाहिए) पर बात करने की दृढ़ता से सलाह देता हूं, जो एक अच्छा उदाहरण देता है कि क्यों और कैसे आपको @property और "__" का उपयोग करना चाहिए - पूर्ववर्ती वर्ण।

Comments

मैं उस बात की जाँच करने जा रहा हूँ। क्या @propertyमानक पायथन का हिस्सा है, या यह एक आईडीई के लिए विशिष्ट है?

— bldldave025

अजगर 2.6 के बाद से मानक का हिस्सा है। यदि आपको एक पुराने संस्करण का उपयोग करना चाहिए, तो अभी भी property

— बिलिन

Answer 12

वास्तव में आप C#इस सरल चाल का उपयोग करके एक गेटटर और सेटर का अनुकरण कर सकते हैं :

class Screen(object):

    def getter_setter_y(self, y, get=True):
        if get is True:
            Screen.getter_setter_y.value = y
        else:
            return Screen.getter_setter_y.value

     def getter_setter_x(self, x, get=True):
         if get is True:
             Screen.getter_setter_x.value = x
         else:
             return Screen.getter_setter_x.value

फिर इसे इसी तरह उपयोग करें C#:

scr = Screen()
scr.getter_setter_x(100)
value =  scr.getter_setter_x(0, get=False)
print (value)

यह सिर्फ एक फ़ंक्शन में एक स्थिर स्थानीय चर घोषित कर रहा है जो एक गेट / सेट भूमिका निभाएगा, क्योंकि यह एक तरीका है कि गेट और सेट विधियों के माध्यम से एक चर साझा करने के लिए, बिना किसी वर्ग या फ़ाइल के वैश्विक बनाने के लिए।