क्या पायथन में स्थिर वर्ग चर या विधियां होना संभव है? ऐसा करने के लिए क्या वाक्यविन्यास आवश्यक है?
क्या पायथन में स्थिर वर्ग चर संभव हैं?
जवाबों:
वर्ग परिभाषा के अंदर घोषित चर, लेकिन एक विधि के अंदर वर्ग या स्थिर चर नहीं हैं:
>>> class MyClass:
... i = 3
...
>>> MyClass.i
3
जैसा कि @ मिलरदेव बताते हैं, यह एक वर्ग-स्तरीय iचर बनाता है , लेकिन यह किसी भी उदाहरण-स्तर iचर से अलग है , इसलिए आप ऐसा कर सकते हैं
>>> m = MyClass()
>>> m.i = 4
>>> MyClass.i, m.i
>>> (3, 4)
यह C ++ और Java से अलग है, लेकिन C # से इतना अलग नहीं है, जहां एक स्थिर सदस्य को उदाहरण के संदर्भ में उपयोग नहीं किया जा सकता है।
देखें कि कक्षाओं और कक्षा वस्तुओं के विषय पर पायथन ट्यूटोरियल का क्या कहना है ।
@ स्वेत जॉनसन ने पहले ही स्थैतिक तरीकों के बारे में जवाब दिया है , जिसे पायथन लाइब्रेरी संदर्भ में "बिल्ट-इन फंक्शन्स" के तहत भी प्रलेखित किया गया है ।
class C:
@staticmethod
def f(arg1, arg2, ...): ...
@beidy स्टेथमैथोड के ऊपर classmethod s की सिफारिश करता है , क्योंकि विधि तब वर्ग तर्क को पहले तर्क के रूप में प्राप्त करती है, लेकिन मैं अभी भी staticmethod पर इस दृष्टिकोण के फायदों पर थोड़ा फजी हूं। यदि आप भी हैं, तो यह शायद कोई फर्क नहीं पड़ता।
@TheJollySin स्थिरांक स्थिरांक के लिए स्थिरांक के लिए एक वर्ग विकसित नहीं है। बस कुछ के
—
गिज़्मो
const.pyसाथ है PI = 3.14और आप इसे हर जगह आयात कर सकते हैं। from const import PI
यह उत्तर स्थिर चर समस्या को भ्रमित करने की संभावना है। के साथ शुरू करने के लिए,
—
रिक
i = 3है न एक स्थिर चर, यह एक वर्ग विशेषता है, और के बाद से यह एक उदाहरण स्तरीय विशेषता से अलग है iयह करता है नहीं अन्य भाषाओं में एक स्थिर चर की तरह व्यवहार करते हैं। देखें millerdev का जवाब , यान का जवाब है, और मेरा उत्तर नीचे।
इसलिए
—
जूल
i(स्टैटिक वैरिएबल) की केवल एक प्रति इस श्रेणी के सैकड़ों उदाहरण बनाने पर भी स्मृति में होगी?
@ ब्लेयर कॉनराड ने कहा कि वर्ग परिभाषा के अंदर घोषित स्थिर चर, लेकिन एक विधि के अंदर वर्ग या "स्थिर" चर नहीं हैं:
>>> class Test(object):
... i = 3
...
>>> Test.i
3
यहाँ कुछ गोत्र हैं। ऊपर के उदाहरण से ले जाने पर:
>>> t = Test()
>>> t.i # "static" variable accessed via instance
3
>>> t.i = 5 # but if we assign to the instance ...
>>> Test.i # we have not changed the "static" variable
3
>>> t.i # we have overwritten Test.i on t by creating a new attribute t.i
5
>>> Test.i = 6 # to change the "static" variable we do it by assigning to the class
>>> t.i
5
>>> Test.i
6
>>> u = Test()
>>> u.i
6 # changes to t do not affect new instances of Test
# Namespaces are one honking great idea -- let's do more of those!
>>> Test.__dict__
{'i': 6, ...}
>>> t.__dict__
{'i': 5}
>>> u.__dict__
{}
ध्यान दें कि कैसे t.iविशेषता चर iसीधे "स्थिर" वर्ग चर के साथ सिंक से बाहर हो गया, जब विशेषता को सीधे सेट किया गया था t। ऐसा इसलिए है क्योंकि नामस्थान के iभीतर फिर से बँधा हुआ था t, जो Testनामस्थान से अलग है । यदि आप "स्थिर" चर के मूल्य को बदलना चाहते हैं, तो आपको इसे उस दायरे (या ऑब्जेक्ट) में बदलना होगा जहां यह मूल रूप से परिभाषित किया गया था। मैंने उद्धरण में "स्थैतिक" डाला क्योंकि पायथन वास्तव में इस अर्थ में स्थिर चर नहीं है कि सी ++ और जावा करते हैं।
यद्यपि यह स्थैतिक चर या विधियों के बारे में कुछ भी विशिष्ट नहीं कहता है, पायथन ट्यूटोरियल में कक्षाओं और कक्षा वस्तुओं पर कुछ प्रासंगिक जानकारी है ।
@ स्वेत जॉनसन ने पायथन लाइब्रेरी संदर्भ में "बिल्ट-इन फंक्शंस" के तहत प्रलेखित, स्टैटिक तरीकों के बारे में भी जवाब दिया।
class Test(object):
@staticmethod
def f(arg1, arg2, ...):
...
@beid ने classmethod का भी उल्लेख किया, जो staticmethod के समान है। एक क्लासमेथोड का पहला तर्क क्लास ऑब्जेक्ट है। उदाहरण:
class Test(object):
i = 3 # class (or static) variable
@classmethod
def g(cls, arg):
# here we can use 'cls' instead of the class name (Test)
if arg > cls.i:
cls.i = arg # would be the same as Test.i = arg1
मेरा सुझाव है कि आप उदाहरण को थोड़ा बढ़ाएँ: यदि, Test.i = 6 सेट करने के बाद, आप तब एक नई ऑब्जेक्ट (जैसे, u = टेस्ट ()) को इंस्टेंट करते हैं, तो नई ऑब्जेक्ट नए वर्ग मान (जैसे) को "इनहेरिट" करेगी। ui == 6)
—
मार्क
सिंक में स्थैतिक चर रखने के लिए एक तरह से उन्हें गुण बनाना है:
—
रिक
class Test(object):, _i = 3, @property, def i(self), return type(self)._i, @i.setter, def i(self,val):, type(self)._i = val। अब आप कर सकते हैं x = Test(), x.i = 12, assert x.i == Test.i।
इसलिए मैं कह सकता हूं कि सभी चर शुरुआत में स्थिर हैं और फिर इंस्टेंस को एक्सेस करना रनवे पर उदाहरण चर बनाता है?
—
अली
शायद यह दिलचस्प है: यदि आप टेस्ट में एक विधि को परिभाषित करते हैं जो Test.i को बदलता है, जो BOTH Test.i और ti मानों को प्रभावित करेगा।
—
पाब्लो
@millerdev, जैसे U उल्लेखित पायथन में स्थिर वैरिएबल नहीं हैं जैसे C ++ या JAVA है। क्या यह कहना ठीक होगा कि Test.i एक स्थिर वैरिएबल के बजाय एक वर्ग चर का अधिक है?
—
Tyto
स्टेटिक और क्लास मेथड्स
जैसा कि अन्य उत्तरों में उल्लेख किया गया है, अंतर्निहित सज्जाकारों का उपयोग करके स्थिर और वर्ग विधियां आसानी से पूरी होती हैं:
class Test(object):
# regular instance method:
def MyMethod(self):
pass
# class method:
@classmethod
def MyClassMethod(klass):
pass
# static method:
@staticmethod
def MyStaticMethod():
passहमेशा की तरह, पहला तर्क MyMethod()वर्ग उदाहरण ऑब्जेक्ट के लिए बाध्य है। इसके विपरीत, पहले तर्क को MyClassMethod()जाता है वर्ग वस्तु ही करने के लिए बाध्य (जैसे, इस मामले में, Test)। के लिए MyStaticMethod(), कोई भी तर्क बाध्य नहीं है, और सभी में तर्क देना वैकल्पिक है।
"स्टेटिक वेरिएबल्स"
हालाँकि, "स्टैटिक वैरिएबल" को लागू करना (ठीक है, म्यूटेबल स्टैटिक वैरिएबल, वैसे भी, अगर यह शब्दों में विरोधाभास नहीं है ...) उतना सीधा आगे नहीं है। जैसा कि मिलरदेव ने अपने जवाब में कहा , समस्या यह है कि पायथन की क्लास की विशेषताएं वास्तव में "स्थिर चर" नहीं हैं। विचार करें:
class Test(object):
i = 3 # This is a class attribute
x = Test()
x.i = 12 # Attempt to change the value of the class attribute using x instance
assert x.i == Test.i # ERROR
assert Test.i == 3 # Test.i was not affected
assert x.i == 12 # x.i is a different object than Test.iक्योंकि लाइन यह है x.i = 12एक नया उदाहरण विशेषता जोड़ा गया है iकरने के लिए xकी बजाय मान बदलने Testवर्ग iविशेषता।
आंशिक उम्मीद स्थिर चर व्यवहार, यानी, कई उदाहरण के बीच विशेषता का सिंक कर रहा है (लेकिन नहीं वर्ग के साथ ही, नीचे देखें "पकड़ लिया"), एक संपत्ति में वर्ग विशेषता बदल कर प्राप्त किया जा सकता:
class Test(object):
_i = 3
@property
def i(self):
return type(self)._i
@i.setter
def i(self,val):
type(self)._i = val
## ALTERNATIVE IMPLEMENTATION - FUNCTIONALLY EQUIVALENT TO ABOVE ##
## (except with separate methods for getting and setting i) ##
class Test(object):
_i = 3
def get_i(self):
return type(self)._i
def set_i(self,val):
type(self)._i = val
i = property(get_i, set_i)अब आप कर सकते हैं:
x1 = Test()
x2 = Test()
x1.i = 50
assert x2.i == x1.i # no error
assert x2.i == 50 # the property is syncedस्थिर चर अब सभी वर्ग उदाहरणों के बीच सिंक में रहेगा ।
(नोट: वह यह है कि, जब तक कि कोई वर्ग उदाहरण अपने स्वयं के संस्करण को परिभाषित करने का निर्णय नहीं लेता है _i! लेकिन यदि कोई ऐसा करने का निर्णय लेता है, तो वे इसके लायक हैं कि उन्हें क्या मिलता है, क्या नहीं ???)
ध्यान दें कि तकनीकी रूप से बोलना, iअभी भी 'स्थिर वैरिएबल' नहीं है; यह एक है property, जो एक विशेष प्रकार का विवरण है। हालाँकि, propertyव्यवहार अब सभी वर्ग उदाहरणों में समान (परस्पर) स्थिर चर के बराबर है।
अपरिवर्तनीय "स्टेटिक वेरिएबल्स"
अपरिवर्तनीय स्थिर चर व्यवहार के लिए, बस propertyसेटर को छोड़ें :
class Test(object):
_i = 3
@property
def i(self):
return type(self)._i
## ALTERNATIVE IMPLEMENTATION - FUNCTIONALLY EQUIVALENT TO ABOVE ##
## (except with separate methods for getting i) ##
class Test(object):
_i = 3
def get_i(self):
return type(self)._i
i = property(get_i)अब इंस्टेंस iविशेषता सेट करने का प्रयास AttributeError:
x = Test()
assert x.i == 3 # success
x.i = 12 # ERRORवन गॉच टू अवेयर
ध्यान दें कि उपरोक्त विधियां केवल आपकी कक्षा के उदाहरणों के साथ काम करती हैं - वे स्वयं कक्षा का उपयोग करते समय काम नहीं करेंगे । उदाहरण के लिए:
x = Test()
assert x.i == Test.i # ERROR
# x.i and Test.i are two different objects:
type(Test.i) # class 'property'
type(x.i) # class 'int'लाइन assert Test.i == x.iएक त्रुटि पैदा करती है, क्योंकि इसकी iविशेषता Testऔर xदो अलग-अलग ऑब्जेक्ट हैं।
कई लोगों को यह आश्चर्यजनक लगेगा। हालांकि, यह नहीं होना चाहिए। यदि हम वापस जाते हैं और अपनी Testकक्षा की परिभाषा (दूसरा संस्करण) का निरीक्षण करते हैं , तो हम इस पंक्ति पर ध्यान देते हैं:
i = property(get_i) स्पष्ट रूप से, सदस्य iको Testएक propertyऑब्जेक्ट होना चाहिए , जो कि propertyफ़ंक्शन से लौटाए गए ऑब्जेक्ट का प्रकार है ।
यदि आप उपरोक्त भ्रामक पाते हैं, तो आप अभी भी अन्य भाषाओं (जैसे जावा या c ++) के परिप्रेक्ष्य से इसके बारे में सोच रहे हैं। आपको propertyऑब्जेक्ट का अध्ययन करना चाहिए , उस क्रम के बारे में जिसमें पायथन विशेषताओं को लौटाया जाता है, डिस्क्रिप्टर प्रोटोकॉल, और विधि रिज़ॉल्यूशन ऑर्डर (एमआरओ)।
मैं नीचे दिए गए 'गोच' के लिए एक समाधान प्रस्तुत करता हूं; हालाँकि, मैं सुझाव दूंगा - ज़ोरदार तरीके से - कि आप कुछ ऐसा करने की कोशिश न करें, जब तक कि कम से कम - कम से कम - आप अच्छी तरह से समझ न लें कि assert Test.i = x.iत्रुटि क्यों होती है।
वास्तविक, वास्तविक स्थैतिक चर -Test.i == x.i
मैं केवल सूचना के उद्देश्यों के लिए (पायथन 3) समाधान प्रस्तुत करता हूं। मैं इसे "अच्छे समाधान" के रूप में समर्थन नहीं कर रहा हूं। मुझे इस बात पर संदेह है कि क्या पायथन में अन्य भाषाओं के स्थिर चर व्यवहार का अनुकरण करना वास्तव में आवश्यक है। हालांकि, इस बात पर ध्यान दिए बिना कि क्या यह वास्तव में उपयोगी है, नीचे पायथन को कैसे काम करना है, इसे समझने में मदद करनी चाहिए।
अद्यतन: यह प्रयास वास्तव में बहुत भयानक है ; यदि आप इस तरह से कुछ करने पर जोर देते हैं (संकेत: कृपया मत करो; पायथन एक बहुत ही सुंदर भाषा है और इसे अन्य भाषा की तरह व्यवहार करने में जूता-मार करना आवश्यक नहीं है), इसके बजाय ईथन फुरमान के उत्तर में कोड का उपयोग करें ।
मेटाक्लास का उपयोग करके अन्य भाषाओं के स्थिर चर व्यवहार का अनुकरण करना
एक मेटाक्लास एक वर्ग का वर्ग है। पायथन में सभी वर्गों के लिए डिफ़ॉल्ट मेटाक्लास (यानी, "नई शैली" कक्षाएं पायथन 2.3 मैं मानता है) है type। उदाहरण के लिए:
type(int) # class 'type'
type(str) # class 'type'
class Test(): pass
type(Test) # class 'type'हालाँकि, आप इस तरह से अपने स्वयं के मेटाक्लास को परिभाषित कर सकते हैं:
class MyMeta(type): passऔर इसे अपनी कक्षा में इस तरह लागू करें (केवल पायथन 3):
class MyClass(metaclass = MyMeta):
pass
type(MyClass) # class MyMetaनीचे एक मेटाक्लस है जो मैंने बनाया है जो अन्य भाषाओं के "स्थिर चर" व्यवहार का अनुकरण करने का प्रयास करता है। यह मूल रूप से डिफ़ॉल्ट गेट्टर, सेटर और डीलेटर को संस्करणों के साथ बदलकर काम करता है जो यह देखने के लिए जांचते हैं कि क्या विशेषता का अनुरोध "स्थिर चर" है।
"स्थिर चर" की एक सूची StaticVarMeta.staticsविशेषता में संग्रहीत है । सभी विशेषता अनुरोधों को शुरू में स्थानापन्न संकल्प क्रम का उपयोग करके हल करने का प्रयास किया जाता है। मैंने इसे "स्थिर संकल्प आदेश", या "एसआरओ" कहा है। यह किसी दिए गए वर्ग (या इसके मूल वर्गों) के लिए "स्थिर चर" के सेट में अनुरोधित विशेषता की तलाश में किया जाता है। यदि विशेषता "एसआरओ" में प्रकट नहीं होती है, तो कक्षा डिफ़ॉल्ट विशेषता प्राप्त / सेट / डिलीट व्यवहार (यानी, "एमआरओ") पर वापस आ जाएगी।
from functools import wraps
class StaticVarsMeta(type):
'''A metaclass for creating classes that emulate the "static variable" behavior
of other languages. I do not advise actually using this for anything!!!
Behavior is intended to be similar to classes that use __slots__. However, "normal"
attributes and __statics___ can coexist (unlike with __slots__).
Example usage:
class MyBaseClass(metaclass = StaticVarsMeta):
__statics__ = {'a','b','c'}
i = 0 # regular attribute
a = 1 # static var defined (optional)
class MyParentClass(MyBaseClass):
__statics__ = {'d','e','f'}
j = 2 # regular attribute
d, e, f = 3, 4, 5 # Static vars
a, b, c = 6, 7, 8 # Static vars (inherited from MyBaseClass, defined/re-defined here)
class MyChildClass(MyParentClass):
__statics__ = {'a','b','c'}
j = 2 # regular attribute (redefines j from MyParentClass)
d, e, f = 9, 10, 11 # Static vars (inherited from MyParentClass, redefined here)
a, b, c = 12, 13, 14 # Static vars (overriding previous definition in MyParentClass here)'''
statics = {}
def __new__(mcls, name, bases, namespace):
# Get the class object
cls = super().__new__(mcls, name, bases, namespace)
# Establish the "statics resolution order"
cls.__sro__ = tuple(c for c in cls.__mro__ if isinstance(c,mcls))
# Replace class getter, setter, and deleter for instance attributes
cls.__getattribute__ = StaticVarsMeta.__inst_getattribute__(cls, cls.__getattribute__)
cls.__setattr__ = StaticVarsMeta.__inst_setattr__(cls, cls.__setattr__)
cls.__delattr__ = StaticVarsMeta.__inst_delattr__(cls, cls.__delattr__)
# Store the list of static variables for the class object
# This list is permanent and cannot be changed, similar to __slots__
try:
mcls.statics[cls] = getattr(cls,'__statics__')
except AttributeError:
mcls.statics[cls] = namespace['__statics__'] = set() # No static vars provided
# Check and make sure the statics var names are strings
if any(not isinstance(static,str) for static in mcls.statics[cls]):
typ = dict(zip((not isinstance(static,str) for static in mcls.statics[cls]), map(type,mcls.statics[cls])))[True].__name__
raise TypeError('__statics__ items must be strings, not {0}'.format(typ))
# Move any previously existing, not overridden statics to the static var parent class(es)
if len(cls.__sro__) > 1:
for attr,value in namespace.items():
if attr not in StaticVarsMeta.statics[cls] and attr != ['__statics__']:
for c in cls.__sro__[1:]:
if attr in StaticVarsMeta.statics[c]:
setattr(c,attr,value)
delattr(cls,attr)
return cls
def __inst_getattribute__(self, orig_getattribute):
'''Replaces the class __getattribute__'''
@wraps(orig_getattribute)
def wrapper(self, attr):
if StaticVarsMeta.is_static(type(self),attr):
return StaticVarsMeta.__getstatic__(type(self),attr)
else:
return orig_getattribute(self, attr)
return wrapper
def __inst_setattr__(self, orig_setattribute):
'''Replaces the class __setattr__'''
@wraps(orig_setattribute)
def wrapper(self, attr, value):
if StaticVarsMeta.is_static(type(self),attr):
StaticVarsMeta.__setstatic__(type(self),attr, value)
else:
orig_setattribute(self, attr, value)
return wrapper
def __inst_delattr__(self, orig_delattribute):
'''Replaces the class __delattr__'''
@wraps(orig_delattribute)
def wrapper(self, attr):
if StaticVarsMeta.is_static(type(self),attr):
StaticVarsMeta.__delstatic__(type(self),attr)
else:
orig_delattribute(self, attr)
return wrapper
def __getstatic__(cls,attr):
'''Static variable getter'''
for c in cls.__sro__:
if attr in StaticVarsMeta.statics[c]:
try:
return getattr(c,attr)
except AttributeError:
pass
raise AttributeError(cls.__name__ + " object has no attribute '{0}'".format(attr))
def __setstatic__(cls,attr,value):
'''Static variable setter'''
for c in cls.__sro__:
if attr in StaticVarsMeta.statics[c]:
setattr(c,attr,value)
break
def __delstatic__(cls,attr):
'''Static variable deleter'''
for c in cls.__sro__:
if attr in StaticVarsMeta.statics[c]:
try:
delattr(c,attr)
break
except AttributeError:
pass
raise AttributeError(cls.__name__ + " object has no attribute '{0}'".format(attr))
def __delattr__(cls,attr):
'''Prevent __sro__ attribute from deletion'''
if attr == '__sro__':
raise AttributeError('readonly attribute')
super().__delattr__(attr)
def is_static(cls,attr):
'''Returns True if an attribute is a static variable of any class in the __sro__'''
if any(attr in StaticVarsMeta.statics[c] for c in cls.__sro__):
return True
return False
मैं अपने तरीके से उपयोग करने के लिए कोशिश की, लेकिन मैं एक समस्या का सामना करना पड़ा, कृपया मेरे सवाल पर एक नज़र यहाँ stackoverflow.com/questions/29329850/get-static-variable-value
—
मोहम्मद Refaat
@ रिकेटी: मुझे लगता है कि आपको
—
ओले थॉमसन ब्यूस
Testमेटा-प्रोग्रामिंग के क्षेत्र में होने के नाते क्लास इंस्टेंस पर ( इंस्टेंटिंग इंस्टेंस के लिए उपयोग करने से पहले) आम तौर पर आपको कुछ भी देखना चाहिए ? उदाहरण के लिए, आप वर्ग-व्यवहार में परिवर्तन करते हैं Test.i = 0(यहां आप केवल संपत्ति ऑब्जेक्ट को पूरी तरह से नष्ट कर देते हैं)। मुझे लगता है कि "संपत्ति-तंत्र" केवल एक वर्ग के उदाहरणों पर संपत्ति-पहुंच पर किक करता है (जब तक कि आप एक मध्यवर्ती के रूप में मेटा-क्लास का उपयोग करके अंतर्निहित व्यवहार को नहीं बदलते हैं, शायद)। Btw, कृपया इस उत्तर को समाप्त करें :-)
@RickTeachey धन्यवाद :-) अंत में आपका मेटाक्लस दिलचस्प है, लेकिन वास्तव में मेरी पसंद के लिए थोड़ा जटिल है। यह एक बड़े ढांचे / अनुप्रयोग में उपयोगी हो सकता है जहाँ इस तंत्र की आवश्यकता है। वैसे भी, यह उदाहरण देता है कि यदि नया (जटिल) गैर-डिफ़ॉल्ट मेटा-व्यवहार वास्तव में आवश्यक है, तो पायथन इसे संभव बनाता है :)
—
ओले थॉमसन ब्यूस
@OleThomsenBuus: एक सरल मेटाक्लास के लिए मेरे उत्तर की जाँच करें जो काम करता है।
—
एथन फुरमान
@ आप सही हैं; मैंने समस्या को ठीक करने के लिए उत्तर को संपादित किया है (विश्वास नहीं कर सकता कि यह इतने लंबे समय तक वहां बैठा है!)। गलतफहमी के लिए खेद है।
—
रिक
आप फ़्लाय पर कक्षाओं में कक्षा चर भी जोड़ सकते हैं
>>> class X:
... pass
...
>>> X.bar = 0
>>> x = X()
>>> x.bar
0
>>> x.foo
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
AttributeError: X instance has no attribute 'foo'
>>> X.foo = 1
>>> x.foo
1और वर्ग उदाहरण वर्ग चर बदल सकते हैं
class X:
l = []
def __init__(self):
self.l.append(1)
print X().l
print X().l
>python test.py
[1]
[1, 1]
क्या नया वर्ग चर तब भी छड़ी जाएगा जब वर्ग दूसरे मॉड्यूल में आयात किया जाता है?
—
zakdances
हाँ। कक्षाएं प्रभावी रूप से एकल हैं, भले ही आप जिन नामस्थानों से उन्हें बुलाते हैं।
—
पेड्रो
@Gregory आपने कहा "और वर्ग उदाहरण वर्ग चर को बदल सकते हैं" वास्तव में इस उदाहरण को एक्सेस नहीं संशोधन कहा जाता है। संशोधन स्वयं वस्तु द्वारा अपने स्वयं के परिशिष्ट () फ़ंक्शन के माध्यम से किया गया था।
—
अमृत एलशोरी
जब भी मुझे एक स्थिर विधि की आवश्यकता होती है, व्यक्तिगत रूप से मैं एक क्लासमेथोड का उपयोग करता हूं। मुख्य रूप से इसलिए कि मुझे एक तर्क के रूप में कक्षा मिलती है।
class myObj(object):
def myMethod(cls)
...
myMethod = classmethod(myMethod) या एक डेकोरेटर का उपयोग करें
class myObj(object):
@classmethod
def myMethod(cls)स्थिर गुणों के लिए .. इसका समय आप कुछ अजगर परिभाषा को देखते हैं .. चर हमेशा बदल सकते हैं। उनमें से दो प्रकार हैं उत्परिवर्तनीय और अपरिवर्तनीय .. इसके अलावा, वर्ग गुण और उदाहरण विशेषताएँ हैं .. कुछ भी वास्तव में जावा और सी ++ के अर्थ में स्थिर विशेषताओं की तरह नहीं हैं
पायथोनिक अर्थों में स्थैतिक पद्धति का उपयोग क्यों करें, यदि इसका कक्षा से कोई संबंध नहीं है! अगर मैं आप होते, तो मैं या तो क्लासमैथोड का उपयोग करता या फिर कक्षा से स्वतंत्र पद्धति को परिभाषित करता।
चर परस्पर भिन्न या अपरिवर्तनीय नहीं हैं; वस्तुएं हैं। (हालांकि, एक वस्तु सफलता की अलग-अलग डिग्री के साथ, इसके कुछ गुणों को असाइनमेंट को रोकने की कोशिश कर सकती है।)
—
डेविस हेरिंग
जावा और सी ++ का उपयोग स्थिर (शब्द का इल्म, इम्हो) ठीक उसी तरह से करते हैं, जैसे आप क्लास की विशेषता बनाम उदाहरण का उपयोग करते हैं। जावा और C ++ में एक क्लास विशेषता / विधि स्थिर है, कोई अंतर नहीं है, सिवाय इसके कि पायथन में एक क्लास मेथड कॉल का पहला पैरामीटर क्लास है।
—
एंजेल ओ स्फीयर
स्थिर गुणों और उदाहरण गुणों के बारे में ध्यान देने योग्य एक विशेष बात, नीचे दिए गए उदाहरण में दी गई है:
class my_cls:
my_prop = 0
#static property
print my_cls.my_prop #--> 0
#assign value to static property
my_cls.my_prop = 1
print my_cls.my_prop #--> 1
#access static property thru' instance
my_inst = my_cls()
print my_inst.my_prop #--> 1
#instance property is different from static property
#after being assigned a value
my_inst.my_prop = 2
print my_cls.my_prop #--> 1
print my_inst.my_prop #--> 2प्रॉपर्टी को इंसर्ट करने के लिए वैल्यू असाइन करने से पहले इसका मतलब है, अगर हम प्रॉपर्टी के माध्यम से एक्सेस करने की कोशिश करते हैं, तो स्टैटिक वैल्यू का उपयोग किया जाता है। अजगर वर्ग में घोषित प्रत्येक संपत्ति में हमेशा स्मृति में एक स्थिर स्लॉट होता है ।
अजगर में स्थैतिक तरीकों को क्लासमेथोड s कहा जाता है । निम्नलिखित कोड पर एक नज़र डालें
class MyClass:
def myInstanceMethod(self):
print 'output from an instance method'
@classmethod
def myStaticMethod(cls):
print 'output from a static method'
>>> MyClass.myInstanceMethod()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method myInstanceMethod() must be called [...]
>>> MyClass.myStaticMethod()
output from a static methodध्यान दें कि जब हम विधि को myInstanceMethod कहते हैं , तो हमें एक त्रुटि मिलती है। ऐसा इसलिए है क्योंकि यह आवश्यक है कि विधि को इस वर्ग के उदाहरण पर बुलाया जाए। विधि myStaticMethod एक classmethod का उपयोग कर के रूप में सेट कर दिया जाता डेकोरेटर @classmethod ।
सिर्फ किक्स और गिगल्स के लिए, हम myInstanceMethod को क्लास की एक आवृत्ति में पास करके कक्षा में बुला सकते हैं , जैसे:
>>> MyClass.myInstanceMethod(MyClass())
output from an instance method
उम्म ... स्थिर तरीके के साथ किए जाते हैं
—
शैडो रेंजर
@staticmethod; @classmethod(स्पष्ट रूप से) वर्ग के तरीकों के लिए (जो मुख्य रूप से वैकल्पिक निर्माणकर्ताओं के रूप में उपयोग के लिए अभिप्रेत है, लेकिन एक चुटकी में स्थिर तरीकों के रूप में सेवा कर सकते हैं जो उस वर्ग का संदर्भ प्राप्त करने के लिए होता है जिसे उन्हें कहा जाता था)।
किसी भी सदस्य विधि के बाहर कुछ सदस्य चर को परिभाषित करते समय, चर या तो स्थिर या गैर-स्थिर हो सकता है यह इस बात पर निर्भर करता है कि चर कैसे व्यक्त किया गया है।
- CLASSNAME.var स्थिर चर है
- INSTANCENAME.var स्थिर वैरिएबल नहीं है।
- self.var वर्ग के अंदर स्थिर चर नहीं है।
- वर्ग सदस्य फ़ंक्शन के अंदर var परिभाषित नहीं है।
उदाहरण के लिए:
#!/usr/bin/python
class A:
var=1
def printvar(self):
print "self.var is %d" % self.var
print "A.var is %d" % A.var
a = A()
a.var = 2
a.printvar()
A.var = 3
a.printvar()परिणाम हैं
self.var is 2
A.var is 1
self.var is 2
A.var is 3
इंडेंटेशन टूट गया है। यह निष्पादित नहीं करेगा
—
थॉमस वेलर
staticवर्ग चर का होना संभव है , लेकिन शायद प्रयास के लायक नहीं है।
यहाँ Python 3 में लिखा गया एक सबूत-अवधारणा है - यदि कोई सटीक विवरण गलत है, तो कोड को आपके द्वारा जो भी मतलब है, उसके बारे में मिलान करने के लिए ट्विक किया जा सकता है static variable:
class Static:
def __init__(self, value, doc=None):
self.deleted = False
self.value = value
self.__doc__ = doc
def __get__(self, inst, cls=None):
if self.deleted:
raise AttributeError('Attribute not set')
return self.value
def __set__(self, inst, value):
self.deleted = False
self.value = value
def __delete__(self, inst):
self.deleted = True
class StaticType(type):
def __delattr__(cls, name):
obj = cls.__dict__.get(name)
if isinstance(obj, Static):
obj.__delete__(name)
else:
super(StaticType, cls).__delattr__(name)
def __getattribute__(cls, *args):
obj = super(StaticType, cls).__getattribute__(*args)
if isinstance(obj, Static):
obj = obj.__get__(cls, cls.__class__)
return obj
def __setattr__(cls, name, val):
# check if object already exists
obj = cls.__dict__.get(name)
if isinstance(obj, Static):
obj.__set__(name, val)
else:
super(StaticType, cls).__setattr__(name, val)और उपयोग में:
class MyStatic(metaclass=StaticType):
"""
Testing static vars
"""
a = Static(9)
b = Static(12)
c = 3
class YourStatic(MyStatic):
d = Static('woo hoo')
e = Static('doo wop')और कुछ परीक्षण:
ms1 = MyStatic()
ms2 = MyStatic()
ms3 = MyStatic()
assert ms1.a == ms2.a == ms3.a == MyStatic.a
assert ms1.b == ms2.b == ms3.b == MyStatic.b
assert ms1.c == ms2.c == ms3.c == MyStatic.c
ms1.a = 77
assert ms1.a == ms2.a == ms3.a == MyStatic.a
ms2.b = 99
assert ms1.b == ms2.b == ms3.b == MyStatic.b
MyStatic.a = 101
assert ms1.a == ms2.a == ms3.a == MyStatic.a
MyStatic.b = 139
assert ms1.b == ms2.b == ms3.b == MyStatic.b
del MyStatic.b
for inst in (ms1, ms2, ms3):
try:
getattr(inst, 'b')
except AttributeError:
pass
else:
print('AttributeError not raised on %r' % attr)
ms1.c = 13
ms2.c = 17
ms3.c = 19
assert ms1.c == 13
assert ms2.c == 17
assert ms3.c == 19
MyStatic.c = 43
assert ms1.c == 13
assert ms2.c == 17
assert ms3.c == 19
ys1 = YourStatic()
ys2 = YourStatic()
ys3 = YourStatic()
MyStatic.b = 'burgler'
assert ys1.a == ys2.a == ys3.a == YourStatic.a == MyStatic.a
assert ys1.b == ys2.b == ys3.b == YourStatic.b == MyStatic.b
assert ys1.d == ys2.d == ys3.d == YourStatic.d
assert ys1.e == ys2.e == ys3.e == YourStatic.e
ys1.a = 'blah'
assert ys1.a == ys2.a == ys3.a == YourStatic.a == MyStatic.a
ys2.b = 'kelp'
assert ys1.b == ys2.b == ys3.b == YourStatic.b == MyStatic.b
ys1.d = 'fee'
assert ys1.d == ys2.d == ys3.d == YourStatic.d
ys2.e = 'fie'
assert ys1.e == ys2.e == ys3.e == YourStatic.e
MyStatic.a = 'aargh'
assert ys1.a == ys2.a == ys3.a == YourStatic.a == MyStatic.aआप मेटाक्लास का उपयोग करके एक वर्ग को स्थिर होने के लिए भी लागू कर सकते हैं।
class StaticClassError(Exception):
pass
class StaticClass:
__metaclass__ = abc.ABCMeta
def __new__(cls, *args, **kw):
raise StaticClassError("%s is a static class and cannot be initiated."
% cls)
class MyClass(StaticClass):
a = 1
b = 3
@staticmethod
def add(x, y):
return x+yफिर जब भी दुर्घटना से आप MyClass को इनिशियलाइज़ करने की कोशिश करेंगे तो आपको StaticClassError मिल जाएगी।
यदि आप इसे तत्काल नहीं जा रहे हैं तो यह एक वर्ग भी क्यों है? ऐसा लगता है कि इसे जावा में बदलने के लिए पायथन को
—
घुमाया जा रहा है
बोर्ग मुहावरा इस संभाल करने के लिए एक बेहतर तरीका है।
—
रिक
@NedBatchelder यह एक अमूर्त वर्ग है, जिसका उद्देश्य केवल उपवर्ग के लिए है (और उपवर्गों को
—
तात्कालिक बनाना
मुझे आशा है कि उपवर्ग
—
नेड बैचेल्ड
__new__अपने माता-पिता का आह्वान करने के लिए सुपर () का उपयोग नहीं करते ...
पायथन की विशेषता देखने के बारे में एक बहुत ही दिलचस्प बात यह है कि इसका उपयोग " आभासी चर" बनाने के लिए किया जा सकता है :
class A(object):
label="Amazing"
def __init__(self,d):
self.data=d
def say(self):
print("%s %s!"%(self.label,self.data))
class B(A):
label="Bold" # overrides A.label
A(5).say() # Amazing 5!
B(3).say() # Bold 3!आम तौर पर इन्हें बनाए जाने के बाद कोई असाइनमेंट नहीं होता है। ध्यान दें कि लुकअप का उपयोग करता है self, हालांकि, labelकिसी विशेष उदाहरण के साथ संबद्ध नहीं होने के अर्थ में स्थिर है , फिर भी मान (उदाहरण के) वर्ग पर निर्भर करता है।
इस उत्तर के संबंध में , स्थिर स्थिर चर के लिए, आप एक डिस्क्रिप्टर का उपयोग कर सकते हैं। यहाँ एक उदाहरण है:
class ConstantAttribute(object):
'''You can initialize my value but not change it.'''
def __init__(self, value):
self.value = value
def __get__(self, obj, type=None):
return self.value
def __set__(self, obj, val):
pass
class Demo(object):
x = ConstantAttribute(10)
class SubDemo(Demo):
x = 10
demo = Demo()
subdemo = SubDemo()
# should not change
demo.x = 100
# should change
subdemo.x = 100
print "small demo", demo.x
print "small subdemo", subdemo.x
print "big demo", Demo.x
print "big subdemo", SubDemo.xजिसके परिणामस्वरूप ...
small demo 10
small subdemo 100
big demo 10
big subdemo 10आप हमेशा एक अपवाद उठा सकते हैं यदि चुपचाप सेटिंग मान ( passऊपर) की अनदेखी करना आपकी बात नहीं है। यदि आप C ++ की खोज कर रहे हैं, तो जावा शैली स्थिर वर्ग चर:
class StaticAttribute(object):
def __init__(self, value):
self.value = value
def __get__(self, obj, type=None):
return self.value
def __set__(self, obj, val):
self.value = valइस उत्तर पर एक नज़र डालें और विवरणों के बारे में अधिक जानकारी के लिए आधिकारिक डॉक्स HOWTO ।
आप केवल उपयोग कर सकते हैं
—
रिक
@property, जो कि डिस्क्रिप्टर का उपयोग करने के समान है, लेकिन यह बहुत कम कोड है।
बिल्कुल हाँ, पायथन अपने आप में स्पष्ट रूप से किसी भी स्थिर डेटा सदस्य नहीं है, लेकिन हम ऐसा करके हो सकता है
class A:
counter =0
def callme (self):
A.counter +=1
def getcount (self):
return self.counter
>>> x=A()
>>> y=A()
>>> print(x.getcount())
>>> print(y.getcount())
>>> x.callme()
>>> print(x.getcount())
>>> print(y.getcount())उत्पादन
0
0
1
1व्याख्या
here object (x) alone increment the counter variable
from 0 to 1 by not object y. But result it as "static counter"हाँ, निश्चित रूप से अजगर में स्थिर चर और तरीके लिखना संभव है।
स्टैटिक वेरिएबल्स: क्लास लेवल पर घोषित किए गए वैरिएबल को स्टैटिक वेरिएबल कहा जाता है, जिसे सीधे क्लास नेम के जरिए एक्सेस किया जा सकता है।
>>> class A:
...my_var = "shagun"
>>> print(A.my_var)
shagunइंस्टेंस वेरिएबल्स: वेरायबल्स जो संबंधित हैं और एक वर्ग के उदाहरण से एक्सेस किए गए हैं, वे वेरिएबल हैं।
>>> a = A()
>>> a.my_var = "pruthi"
>>> print(A.my_var,a.my_var)
shagun pruthiस्टैटिक मेथड्स: वैरिएबल के समान, स्टैटिक मेथड्स को सीधे क्लास नेम के उपयोग से एक्सेस किया जा सकता है। कोई उदाहरण बनाने की जरूरत नहीं है।
लेकिन ध्यान रखें, एक स्थिर विधि अजगर में एक गैर-स्थिर विधि नहीं कह सकती।
>>> class A:
... @staticmethod
... def my_static_method():
... print("Yippey!!")
...
>>> A.my_static_method()
Yippey!!किसी भी संभावित भ्रम से बचने के लिए, मैं स्थैतिक चर और अपरिवर्तनीय वस्तुओं के विपरीत करना चाहूंगा।
कुछ आदिम वस्तु प्रकार जैसे पूर्णांक, फ्लोट्स, स्ट्रिंग्स और टौयन्स पायथन में अपरिवर्तनीय हैं। इसका मतलब यह है कि किसी दिए गए नाम से संदर्भित ऑब्जेक्ट बदल नहीं सकता है यदि यह उपरोक्त ऑब्जेक्ट प्रकारों में से एक है। नाम को किसी भिन्न ऑब्जेक्ट पर पुन: असाइन किया जा सकता है, लेकिन ऑब्जेक्ट स्वयं परिवर्तित नहीं किया जा सकता है।
किसी वस्तु को इंगित करने के लिए परिवर्तनशील नाम को हटाकर एक परिवर्तनशील स्थैतिक बनाना एक कदम आगे ले जाता है, लेकिन यह वर्तमान में इंगित करता है। (नोट: यह एक सामान्य सॉफ्टवेयर अवधारणा है और पायथन के लिए विशिष्ट नहीं है; कृपया पायथन में स्टैटिक्स को लागू करने के बारे में जानकारी के लिए दूसरों के पोस्ट देखें)।
सबसे अच्छा तरीका मुझे एक और वर्ग का उपयोग करना है। आप एक ऑब्जेक्ट बना सकते हैं और फिर अन्य वस्तुओं पर इसका उपयोग कर सकते हैं।
class staticFlag:
def __init__(self):
self.__success = False
def isSuccess(self):
return self.__success
def succeed(self):
self.__success = True
class tryIt:
def __init__(self, staticFlag):
self.isSuccess = staticFlag.isSuccess
self.succeed = staticFlag.succeed
tryArr = []
flag = staticFlag()
for i in range(10):
tryArr.append(tryIt(flag))
if i == 5:
tryArr[i].succeed()
print tryArr[i].isSuccess()ऊपर के उदाहरण के साथ, मैंने एक वर्ग बनाया जिसका नाम है staticFlag।
इस वर्ग को स्थिर संस्करण __success(निजी स्टेटिक वार) प्रस्तुत करना चाहिए ।
tryIt वर्ग को नियमित वर्ग का प्रतिनिधित्व करना चाहिए जिसका हमें उपयोग करना है।
अब मैंने एक झंडे के लिए एक वस्तु ( staticFlag) बनाई । यह ध्वज सभी नियमित वस्तुओं के संदर्भ के रूप में भेजा जाएगा।
इन सभी वस्तुओं को सूची में जोड़ा जा रहा है tryArr।
यह स्क्रिप्ट परिणाम:
False
False
False
False
False
True
True
True
True
Trueकक्षा कारखाने python3.6 में स्थैतिक चर
Python3.6 के साथ एक वर्ग के कारखाने का उपयोग करने वाले किसी भी व्यक्ति के लिए और nonlocalइसे बनाए जाने वाले वर्ग के दायरे / संदर्भ में जोड़ने के लिए कीवर्ड का उपयोग करें:
>>> def SomeFactory(some_var=None):
... class SomeClass(object):
... nonlocal some_var
... def print():
... print(some_var)
... return SomeClass
...
>>> SomeFactory(some_var="hello world").print()
hello world
हाँ, लेकिन इस मामले में
—
रिक
hasattr(SomeClass, 'x')है False। मुझे संदेह है कि किसी स्थिर चर से किसी का क्या मतलब है।
@RickTeachey योग्य, आपके स्थिर चर कोड, stackoverflow.com/a/27568860/2026508 +1 इंटरनेट का सर देखा, और मुझे लगा कि हैटट्रॉम उस तरह से काम नहीं करता है? इतना
—
jununsch
some_varअपरिवर्तनीय है, और सांख्यिकीय रूप से परिभाषित है, या यह नहीं है? बाहरी गेटटर एक्सेस का वैरिएबल स्थिर होने या न होने से क्या लेना-देना है? मेरे पास अब बहुत सारे सवाल हैं। समय मिलने पर कुछ जवाब सुनना पसंद करेंगे।
हाँ कि मेटाक्लास बहुत हास्यास्पद है। मैं निश्चित नहीं हूं कि मैं प्रश्नों को समझता हूं, लेकिन मेरे दिमाग में,
—
रिक
some_varऊपर एक वर्ग सदस्य नहीं है। पायथन में सभी वर्ग के सदस्यों को कक्षा के बाहर से पहुँचा जा सकता है।
की-
—
रिक
nonlocalवर्ड चर के दायरे को "समान" करता है। एक वर्ग निकाय परिभाषा का दायरा उस दायरे से स्वतंत्र होता है, जिसमें वह खुद को पाता है- जब आप कहते हैं nonlocal some_var, कि सिर्फ एक गैर-स्थानीय बना रहा है (पढ़ें: वर्ग परिभाषा के दायरे में नहीं) नाम की किसी अन्य वस्तु का संदर्भ। इसलिए यह क्लास की परिभाषा से जुड़ा नहीं है क्योंकि यह क्लास बॉडी स्कोप में नहीं है।
तो यह शायद एक हैक है, लेकिन मैं eval(str)एक स्थिर वस्तु, एक विरोधाभास की तरह, अजगर 3 में प्राप्त करने के लिए उपयोग कर रहा हूं ।
एक रिकॉर्डशो फ़ाइल है classजिसमें स्थिर विधियों और कंस्ट्रक्टरों के साथ परिभाषित कुछ भी नहीं है जो कुछ तर्कों को बचाते हैं। फिर किसी अन्य .py फ़ाइल से, import Recordsलेकिन मुझे प्रत्येक ऑब्जेक्ट को गतिशील रूप से चुनने की आवश्यकता है और फिर जिस प्रकार के डेटा में पढ़ा जा रहा है, उसके अनुसार इसे मांग पर तत्काल भेज दें।
इसलिए जहां object_name = 'RecordOne'या कक्षा का नाम, मैं कॉल करता हूं cur_type = eval(object_name)और फिर आप इसे तुरंत करने के लिए करते हैं। cur_inst = cur_type(args)
हालांकि इससे पहले कि आप त्वरित तरीके से cur_type.getName()उदाहरण के लिए स्थिर तरीकों को कॉल कर सकें , जैसे कि एब्सट्रैक्ट बेस क्लास कार्यान्वयन या लक्ष्य जो भी हो। हालांकि बैकएंड में, यह शायद अजगर में त्वरित है और वास्तव में स्थिर नहीं है, क्योंकि eval एक वस्तु लौटा रहा है .... जो कि तत्काल किया गया होगा .... जो व्यवहार की तरह स्थैतिक देता है।
आप उदाहरणों के बीच "स्थिर व्यवहार" प्राप्त करने के लिए एक सूची या शब्दकोश का उपयोग कर सकते हैं।
class Fud:
class_vars = {'origin_open':False}
def __init__(self, origin = True):
self.origin = origin
self.opened = True
if origin:
self.class_vars['origin_open'] = True
def make_another_fud(self):
''' Generating another Fud() from the origin instance '''
return Fud(False)
def close(self):
self.opened = False
if self.origin:
self.class_vars['origin_open'] = False
fud1 = Fud()
fud2 = fud1.make_another_fud()
print (f"is this the original fud: {fud2.origin}")
print (f"is the original fud open: {fud2.class_vars['origin_open']}")
# is this the original fud: False
# is the original fud open: True
fud1.close()
print (f"is the original fud open: {fud2.class_vars['origin_open']}")
# is the original fud open: Falseयदि आप उदाहरण के लिए, इसे अन्य उदाहरणों में बढ़ाकर, एक स्थिर चर साझा करने का प्रयास कर रहे हैं, तो यह स्क्रिप्ट ठीक काम करती है:
# -*- coding: utf-8 -*-
class Worker:
id = 1
def __init__(self):
self.name = ''
self.document = ''
self.id = Worker.id
Worker.id += 1
def __str__(self):
return u"{}.- {} {}".format(self.id, self.name, self.document).encode('utf8')
class Workers:
def __init__(self):
self.list = []
def add(self, name, doc):
worker = Worker()
worker.name = name
worker.document = doc
self.list.append(worker)
if __name__ == "__main__":
workers = Workers()
for item in (('Fiona', '0009898'), ('Maria', '66328191'), ("Sandra", '2342184'), ('Elvira', '425872')):
workers.add(item[0], item[1])
for worker in workers.list:
print(worker)
print("next id: %i" % Worker.id)
@classmethodअधिक का लाभ@staticmethodयह है कि आपको हमेशा उस कक्षा का नाम मिलता है जिस पर विधि उप-दायर की गई थी, भले ही वह उपवर्ग हो। एक स्थिर विधि में इस जानकारी का अभाव होता है, इसलिए यह एक ओवरराइड विधि नहीं कह सकता है, उदाहरण के लिए।