Question

In the docs explaining properties, it is said:

Be sure to give the additional functions the same name as the original property (x in this case.)

I.e., the getter, setter and deleter methods must all have the same name.

Why? And also, Python forbids method overloading, doesn’t it?

EDIT:
Why does the following code fail when run in Python 2.6?

class Widget(object):
    def __init__(self, thing):
        self.thing = thing
        print self.thing

    @property
    def thing(self):
        return self._thing

    @thing.setter
    def set_thing(self, value):
        self._thing = value


if __name__ == '__main__':
    Widget('Some nonsense here')  

Its output is:

 Traceback (most recent call last):   
 File "widget.py", line 16, in <module>
     Widget('Some nonsense here')     
 File "widget.py", line 3, in __init__
     self.thing = thing 
 AttributeError: can't set attribute

The code works fine when set_thing() is renamed to thing().

Answer 1

Python does indeed not feature method overloading, but you’re correct that the docs encourage you to name the getters and setters identically, and demonstrates it to boot. What’s going on here?

The trick is to understand how method decorators work in Python. Whenever you see something like this:

@foo
def bar():
    frob()
    quux()

what Python actually does under the covers is to rewrite it this way:

def bar():
    frob()
    quux()
bar = foo(bar)

In other words: define a function bar, then replace it with the result of calling foo on the bar function.

While that’s all true, the order of evaluation is actually slightly different than the above when it comes to how names are resolved. It might be easier for you to pretend for a moment that what actually happens looks a bit closer to this:

def __secret_internal_function_name__():
    frob()
    quux()
bar = foo(__secret_internal_function_name__)

Why does this matter? Let’s look at the Python in that documentation link:

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Let’s rewrite this using what we now know to understand what Python is actually doing:

class C(object):
    def __init__(self):
        self._x = None

    def __secret_x_prop__(self):
        """I'm the 'x' property."""
        return self._x
    x = property(__secret_x_prop__)

    def __secret_x_setter__(self, value):
        self._x = value
    x = x.setter(__secret_x_setter__)

    def __secret_x_getter__(self):
        del self._x
    x = x.deleter(__secret_x_getter__)

Now, we can actually see what’s going on: we’re not overloading functions; we’re gradually building up a property object that references other functions.

It’s also worth noting that, depending on how you create the property, the names don’t need to match. Specifically, if you create the property explicitly with the property function, as is done in the first example in the documentation, the names can be whatever you want; the example has them called getx, setx, and delx, and it works fine. In what I assume is a safety precaution, property.setter, property.deleter, and the like do require the function passed have the same name, but they’re doing the same thing behind the scenes as the more explicit property example.