मैं ऑब्जेक्ट की विशेषता का मान कैसे बदलूं जो किसी अन्य ऑब्जेक्ट की विशेषता का संदर्भ है? - अजगर, ओओपी, पायथन-3.x

class Bar:

def __init__(self, n):
self.n = n

class Foo:

def __init__(self, l):
self.l = l

x = Bar(2)

# we want x.n to change whenever y.l changes
y = Foo(x.n)

# I"d like x.n to become 3 as a result
y.l += 1

print(x.n)
>>> 2

मैं इसे कैसे बनाऊं ताकि मैं बदल सकूं x.n अंदर से y? क्या इसके लिए अधिक कार्यक्षमता जोड़े बिना ऐसा करने का कोई आसान तरीका नहीं है x?

उत्तर:

उत्तर № 1 के लिए 1

ठीक है, जैसा कि अन्य लोगों ने पहले ही बताया है, समस्या इस तथ्य से कम हो जाती है कि आप के साथ काम कर रहे हैं अपरिवर्तनीय वस्तुएँ। एहसास होने के बाद, आपको या तो एक का उपयोग करना चाहिएउत्परिवर्तनीय प्रकार, या अपडेट को प्रबंधित करने के लिए कॉलबैक का उपयोग करें। एड्रियानो एब्रान्ट्स ने परस्पर प्रकारों का उपयोग करके एक विकल्प का एक उदाहरण दिया, लेकिन यदि वह "नहीं है जो आप" की तलाश में हैं, तो यहां संभावित कॉलबैक सिस्टम का उदाहरण है:

# bad habit to be using the old style class definition (i.e. `class Foo:`)
# the `@property` decorator wont work if you use the old style

class Sync(object):

def __init__(self, name, value, *dependants):
"""Sync the attribute `name` on all `dependants` when `self.value` is updated"""
self._name = name
self._value = value
self._updating = False
self._dependants = list(dependants)
self._update_dependants()

@property
def value(self):
return self._value

@value.setter
def value(self, x):
if x != self._value:
self._value = x
self._update_dependants()

def _update_dependants(self):
self._updating = True
for d in self._dependants:
if getattr(d, self._name) != self.value:
if isinstance(d, Sync):
if not d._updating:
setattr(d, self._name, self.value)
else:
setattr(d, self._name, self.value)
self._updating = False

def add_dependant(self, other):
self._dependants.append(other)
self._update_dependants()

def del_dependnant(self, other):
self._dependants.remove(other)

def __repr__(self):
return "Sync(""+self._name+"": "+repr(self.value)+")"

def __eq__(self, other):
if isinstance(other, Sync):
return self.value == other.value
else:
return self.value == other

def __ne__(self, other):
return not self.__eq__(other)


s1 = Sync("value", 2)
s2 = Sync("value", 1)
print("setup the Sync objects:")
print(">>> " + repr(s1) + (" == " if s1 == s2 else " != ") + repr(s2))

s1.add_dependant(s2)
s2.add_dependant(s1)
print("add sync objects as dependants of each other:")
print(">>> " + repr(s1) + (" == " if s1 == s2 else " != ") + repr(s2))

s1.value += 1
print("check that value changes transfer from one to the other:")
print(">>> " + repr(s1) + (" == " if s1 == s2 else " != ") + repr(s2))

अगर यह अभी भी आपको संतुष्ट नहीं करता है, तो मुझे कुछ कहा जाता है Traitlets। यह Ipython का एक पैकेज है जो इसका हिस्सा हैप्रोजेक्ट जुपिटर जो टाइप चेकिंग को लागू करता है, कॉलबैक सिस्टम को सुव्यवस्थित करता है और ऐप कॉन्फ़िगरेशन को आसान बनाता है। मैं थोड़ी देर के लिए परियोजना में योगदान दे रहा हूं, इसलिए यदि आपके पास ट्रेटलेट्स के बारे में कोई प्रश्न हैं तो मुझे यहां पूछने या पोस्ट करने के लिए स्वतंत्र महसूस करें Gitter और देव दल उनका उत्तर देगा।


जवाब के लिए 0 № 2

मेरा मानना ​​है कि आप जो कर रहे हैं वह OOP की कई अवधारणाओं के खिलाफ है, लेकिन आप एक सूची का उपयोग कर सकते हैं:

class Bar:
def __init__(self,n):
self.n = [n]

class Foo:
def __init__(self,l):
self.l = l

x = Bar(2)
print(x.n)
>>>[2]

y = Foo(x.n)
y.l[0] += 1
print(x.n)
>>>[3]

संबंधित सवाल
सबसे लोकप्रिय