What you want is a property. This is a special type of attribute that calls a custom getter function when getting the value, so you can make it dynamically return the correct plot.

class Data(object):
    def __init__(self, n):
        self.n = n

    @property
    def plot(self):
        return Plot(self.n)

    def __sub__(self, x):
        return Data(self.n - x)

As a side note, look at the data model to override python operators.

data = Data(10)
data -= 2
answer = data.plot.double()  # Calls the `plot()` function to get a value for `data.plot`.
print(answer)  # 16

Another way would be to link the Plot to the data, so when the data changes, the plot does to. A way to do it would be just to have it as an attribute, so when it changes, the attribute does too.

class Plot(object):
    def __init__(self, data):
        self.data = data

    @property
    def n(self):
        return self.data.n

    @n.setter
    def n(self, x):
        self.data.n = x

    def double(self):
        return self.n * 2

data = Data(10)
plot = Plot(data)
data.minus(2)
answer = plot.double()  # 16

you should call the self method:

class updateMyNumber:
    def __init__(self, number):
        self.update_number(number)

    def update_number(self, number):
        self.number = number * 2

but better way to setting instance variables inside __init__, read the should-all-member-variables-be-initialized-in-init

so i recomend you, something:

class updateMyNumber:
    def __init__(self, number):
        self.number = self.update_number(number)

    def update_number(self, number):
        return number * 2

You need to recompute self.sheet after self.a through self.d are set. After self.sheet is assigned it just contains a simple string. That string isn't automatically updated when the fields are changed; you have to do it yourself.

Better yet, make sheet a method rather than a static variable.

class ScoreBoard(object):
    def __init__(self):
        self.a = "_____"
        self.b = "_____"
        self.c = "_____"
        self.d = "_____"

    def sheet(self):
        return f"""
            1. Number One:    {self.a}
            2. Number Two:    {self.b}
            3. Number Three:  {self.c}
            4. Number Four:   {self.d}
            """

class rotater:
    def __init__(self,store):
        self.store=store
    def evolve(self,n):
        shift=self.store[:int(n)]
        new_string=self.store[int(n):]+shift
        self.store = new_string
        return new_string

This way you redefine the store attribute (To define an attribute, you have to write it in the sintax self.attribute = value not attribute = value

if updating one property due to an update on another property is what you're looking for (instead of recomputing the value of the downstream property on access) use property setters:

class SomeClass(object):
    def __init__(self, n):
        self.list = range(0, n)

    @property
    def list(self):
        return self._list
    @list.setter
    def list(self, val):
        self._list = val
        self._listsquare = [x**2 for x in self._list ]

    @property
    def listsquare(self):
        return self._listsquare
    @listsquare.setter
    def listsquare(self, val):
        self.list = [int(pow(x, 0.5)) for x in val]

>>> c = SomeClass(5)
>>> c.listsquare
[0, 1, 4, 9, 16]
>>> c.list
[0, 1, 2, 3, 4]
>>> c.list = range(0,6)
>>> c.list
[0, 1, 2, 3, 4, 5]
>>> c.listsquare
[0, 1, 4, 9, 16, 25]
>>> c.listsquare = [x**2 for x in range(0,10)]
>>> c.list
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

You are confusing classes and instances.

class MyClass(object):
    pass

a = MyClass()

MyClass is a class, a is an instance of that class. Your error here is that update is an instance method. To call it from __init__, use either:

self.update(value)

or

MyClass.update(self, value)

Alternatively, make update a class method:

@classmethod
def update(cls, value):
    cls.var1 += value

You should drop the @property attribute. Then, you can set it by just doing x.test_var = 5. E.g.,

class Test: 
    def __init__(self, test_variable):
        self.test_var = test_variable

    def some_function(self): 
        if self.test_var < 0:
           self.test_var = 'New Output'   #this is the line that I can't get 
                                          #get to work and I was hoping to update it here
                                          #so I could use it in later functions
        return self.test_var

x = Test(-1)

print(x.some_function())
x.test_var = 5
print(x.some_function())

returns

New Output
5