How to implement this mechanism:

i want to implement a dynamic relation mechanism with python something like:

a:=10
b:=30
c:=a+b
print c
a+=20
print c

output:

40
60

c is always result of a+b.

so if a or b change, then c automatically updates value. i write a code in C# and do this by set and get mechanism. now want to translate it to python code for using in another program (FontLab Studio 5). I'm not so familiar with Python. does he have a get,set feature like C#? if not ho 开发者_StackOverflow中文版to implement one?

This is probably overkill, but it illustrates how you should create getters/setters in Python and achieve the functionality you want:

class Calc(object):
    def __init__(self, a = 0, b = 0):
        self._a = a
        self._b = b

    @property
    def a(self):
        return self._a

    @a.setter
    def a(self, value):
        self._a = value

    @property
    def b(self):
        return self._b

    @b.setter
    def b(self, value):
        self._b = value

    @property
    def c(self):
        return self._a + self._b

    def __str__(self):
        return str(self.c)

calc = Calc()
calc.a = 1
calc.b = 2
print calc.c
calc.a += 10
print calc.c

If you don't want to make a and b a property, the code can be simplified:

class Calc(object):
    def __init__(self, a = 0, b = 0):
        self.a = a
        self.b = b

    @property
    def c(self):
        return self.a + self.b

    def __str__(self):
        return str(self.c)

In your situation, c actually is a function which must be called. You could use something like this:

a = 10
b = 30
c = lambda: a + b

print c()
a += 20
print c()

If you dislike that the method call is made explicit for c, you could use a general Calc object, which hides this implementation:

class Calc(object):
    def __init__(self):
        object.__setattr__(self,  '_params', dict())

    def __getattr__(self, name):
        param = self._params[name]
        if callable(param):
            return param()
        else:
            return param

    def __setattr__(self, name, value):
        self._params[name] = value

    def __delattr__(self, name):
        del self._params[name]

And then you could do:

c = Calc()
c.a = 10
c.b = 30
c.c = lambda: c.a + c.b

print c.c
c.a += 20
print c.c

New-style Python classes support properties.

something like this:

class C:
  def __init__(self):
    self.x = 0
    self.y = 0

  def get(self):
    return self.x + self.y

  def __str__(self):
    return self.__unicode__()

  def __unicode__(self):
    return str(self.get())

c = C()
c.x = 1
print c
c.y =2
print c

With new style classes and annotations you can probably make it better.