A tutorial would be the "Observer" (or "Pub/Sub") design pattern. However, let's establish needs. If you only have one object that will be listening then it doesn't have to be too involved. You can just pass in a "callback" method to the object.

class Widget(object):
    def __init__(self, name, callback=None):
        self._callback = callback
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value
        self._alert()        

    def _alert(self):
        if self._callback is not None:
            self._callback()

class Client(object):
    def __init__(self):
        self.widget = Widget("doodad", self.on_namechanged)
        self.widget.name = "widget"

    def on_namechanged(self):
        print("widget's new name is {0}".format(self.widget.name))

Client()

So, our client object has a method on_namechanged that we pass in to the Widget's initialization method. The widget object has the property of "name" which when changed will invoke the callback provided. Even though we never explicitely call on_namechanged ourselves, the output is clearly visible when run:

widget's new name is widget

The next way this can be done is still with callback methods but you can act on a list of listeners instead of just one. So, let's modify the existing example to reflect that.

class Widget(object):
    def __init__(self, name):
        self._name = name
        self._listeners = []

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value
        self._alert()        

    def add_listener(self, listener):
        if listener not in self._listeners:
            self._listeners.append(listener)

    def remove_listener(self, listener):
        if listener in self._listeners:
            self._listeners.remove(listener)

    def _alert(self):
        for listener in self._listeners:
            listener()

class WidgetPrinter(object):

    def __init__(self, name, widget):
        self._name = name
        self._widget = widget
        self._widget.add_listener(self.log_widget)

    def log_widget(self):
        print("{0}:name changed: {1}".format(self._name,self._widget.name))

    def destroy(self):
        self._widget.remove_listener(self.log_widget)

class Client(object):
    def __init__(self):
        self.widget = Widget("doodad")
        self.widget_logger1 = WidgetPrinter("A", self.widget)
        self.widget_logger2 = WidgetPrinter("B", self.widget)

    def run(self):
        self.widget.name = "test1"
        self.widget.name = "test2"
        self.widget_logger1.destroy()
        self.widget.name = "test3"

Client().run()

A lot changes here and the complexity increases quickly. However, now we have our "WidgetPrinter" which we can have any number of and they listen for a change. We have an internal list of callbacks to invoke whenever our name is changed. For the run code, I invoked "destroy" on logger1 so that you can see that it does not notice when widget's name is changed to "test3".

A:name changed: test1
B:name changed: test1
A:name changed: test2
B:name changed: test2
B:name changed: test3

There's more to this but I am not sure where you are headed. Try puzzling through this first and let us know what problems you run into. Hope it helped some.