Python中的描述符类设计（带有继承）

Question

I'm trying to design a descriptor class which I can use through other class which is a subclass of a class which is a subclass of a class.

class MyDescriptorClass(object):
    def __init__(self, owner, name, activates = 0):
        self.value = None
        self.name = name
        self.owner = owner
        self.activates = 0
        self.connects = []

    def __set__(self, obj, val):
        self.set(val)
    def __get__(self, instance, owner):
        return self.value

    def set(self, value):
        if self.value  == value:
            return 0
        self.value = value
        if self.activates:
            self.owner.evaluate()

    def connect(self, inputs):
        if not isinstance(inputs, list): 
            inputs = list(inputs)
        for input in inputs: 
            self.connects.append(input)

class ParentClass(object):
    def __init__(self, name):
        self.states = {}
        self.name = name
        self.A = MyDescriptorClass(self, name, activates = 1)    
        self.B = MyDescriptorClass(self, name, activates = 1)
        self.states.setDefault('A', self.A)
        self.states.setDefault('B', self.B)

class ChildClass1(ParentClass):
    def __init__(self, name)
        super(ChildClass1, self).__init__(name)
        self.ans = None
    def evaluate(self):
        self.ans = self.A.value + self.B.value

class ChildClass2(ParentClass):
    def __init__(self, name)
        super(ChildClass1, self).__init__(name)
        self.ans = None
    def evaluate(self):
        self.ans = self.A.value * self.B.value

self.A = MyDescriptorClass() will not work according to the python docs

so the only way is that I declate A = MyDescriptorClass() in the ParentClass as

class ParentClass(object):
    A = MyDescriptorClass() # here I am unable to pass the owner

And since, I'm using a child class, super call skips this part and starts directly with __init__

Is there any way in which I can modify the design so as to set the value of ChildClass1.A instance directly?

  c = ChildClass1("c1")
  c.A = 10 # I directly want to set this value instead of using c.A.set(10)
  c.B = 20
  c.evaluate()
  print c.ans # 30
  c.B = 40
  print c.ans # 50

Answer 1

Try not to put information which is specific to instances in the descriptor. Keep information specific to instances in instance attributes, and keep information specific to the descriptor (like activates ) in the descriptor:

class MyDescriptorClass(object):
    def __init__(self, activates = 0):
        self.value = None
        self.activates = activates
        self.connects = []

    def __set__(self, instance, val):      # 1
        if self.value == val:
            return 0
        self.value = val
        if self.activates:
            instance.evaluate()
    def __get__(self, instance, instcls):  # 1 
        return self.value    

1. Note that the __set__ and __get__ methods are passed the instance which is accessing the descriptor. Therefore, you do not need to store the owner in MyDescriptor. The instance is the owner .

---

Given the clarification of the problem in the comments below, here is how I would implement the descriptor.

class GateInput(object):
    def __init__(self, index):
        self.index = index                    # 4

    def __get__(self, inst, instcls):
        return inst.inputs[self.index].ans    # 5

    def __set__(self, inst, val):
        if isinstance(val, (float, int)):
            inst.inputs[self.index] = Constant(val)
        else:
            inst.inputs[self.index] = val


class Constant(object):
    def __init__(self, val):
        self.ans = val


class Gate(object):
    A = GateInput(0)               # 1  
    B = GateInput(1)               # 1

    def __init__(self, name):
        self.name = name
        self.inputs = [Constant(0), Constant(0)]    # 2


class Adder(Gate):
    @property
    def ans(self):
        result = 0
        for gate in self.inputs:
            result += gate.ans                      # 3
        return result


class Multiplier(Gate):
    @property
    def ans(self):
        result = 1
        for gate in self.inputs:
            result *= gate.ans
        return result

b = Multiplier('b1')
b.A = 2
b.B = 3
print(b.A)
# 2
print(b.ans)
# 6

c = Adder('c1')
c.A = 10
print(c.ans)
# 10

# This connects output of b to an input of c
c.B = b
print(c.ans)
# 16

1. Descriptors have to be defined as class attributes, not instance attributes. Since the descriptor is accessed by all instances, you probably do not want the descriptor to change merely because an instance is being created. Therefore, do not instantiate the descriptor in __init__ .
2. Each instance of Gate has a list of inputs. The items self.inputs are instances of Constant or Gate.
3. Here we see the purpose of the Constant class. For every gate , gate.ans needs to return a value.
4. The index records which item in inst.inputs the GateInput is connected to.
5. inst is an instance of Gate. For example, cA causes Python to call GateInput.__get__(self, c, type(c)) . Thus, inst is c here.

Answer 2

As it is int he comments: descriptors must be class attributes, not instance attributes in order to work - so, to start with:

class ParentClass(object):
    A = MyDescriptorClass()
    B = MyDescriptorClass()
    def __init__(self, name):
        self.states = {}
        self.name = name
        self.A.configure(self, name, activates = 1)    
        self.B.configure(self, name, activates = 1)
        self.states.setDefault('A', self.A)
        self.states.setDefault('B', self.B)

And then you fix your Descriptor class accordingly: either have then keeping all data refering to an instance in the instance itself (that is why __get__ and __set__ receive the object itself) - or have each descriptor instance have a dictionary where they can annotate data related to the instances of the class they belong too, by, for example, object ID.

Your descriptor class could be more or less along these lines:

class MyDescriptorClass(object):
    def __init__(self): 
        self.data = defaultDict(dict)
    def configure(self, owner, name, activates = 0):
        container = self.data(id(owner))
        container["value"] = None
        container["name"] = name
        ...

    def __set__(self, owner, value):
        # implemnt your previous "set" method straight here
        ...  
        ...