为什么Class property.setter不是方法重载的情况？

Question

Method overloading is not possible in Python! Can you please explain why Properties.setter in Python is not a case of method overloading?

class newOne():
    def __init__(self):
            self.__x = 0
    @property
    def val(self):
            return self.__x
    @val.setter
    def val(self,value):
            self.__x = value

In the above code, I have two methods with the same name 'val' (but different set of args) and both behave differently.

Answer 1

First, the @property decorator creates a descriptor named val and sets it aside to add to the class once it is defined. Then, the @val.setter decorated takes its function and simply effectively adds a reference to it to the val descriptor.

Your code is roughly equivalent to

d = {}

def __init__(self):
    self.__x = 0

d['__init__'] = __init__

def val(self):
    return self.__x

d['val'] = property(val)

def val(self, value):
    self.__x = value

# Not d['val'].__set__ = val, as previously stated
d['val'] = property(fget=d['val'], fset=val)

newOne = type('newOne', (object,), d)

# These are all "local" to, or part of the implementation of,
# the class statement, so they don't stick around in the current
# namespace.
del __init__, val, d  # These are all "local" to or part of the imple

Answer 2

It's not method overloading because there aren't two methods with different signatures that can be called. If it was method overloading, you could do something like this:

obj = newOne()

print(obj.val())
obj.val(5)

But that doesn't work, because val is a property and not an overloaded method.

---

So what's going on there? Why are we defining two methods with the same name, and what happens to them, if not overloading?

The magic happens in the decorators. As a prerequisite, you have to know that

@deco
def func(...):
    ...

is equivalent to

def func(...):
    ...

func = deco(func)

So, the first thing that happens is that the @property decorator turns your getter function into a property with that function as its getter function:

class newOne:
    @property
    def val(self):
        return self.__x

print(newOne.val)
print(newOne.val.fget)
# output:
# <property object at 0x002B1F00>
# <function newOne.val at 0x0052EAE0>

After this, the @val.setter decorator creates a new property with a getter and setter function:

class newOne:
    @property
    def val(self):
        return self.__x

    @val.setter
    def val(self, value):
        self.__x = value

print(newOne.val)
print(newOne.val.fget)
print(newOne.val.fset)
# output:
# <property object at 0x0221B7B0>
# <function newOne.val at 0x0226EB70>
# <function newOne.val at 0x0226EAE0>

(The getter and setter functions have the same name because they were both defined as def val(...) , but they're still different functions. That's why they have different ids.)

So in the end you have a val property with a getter and a setter function. You do not have an overloaded method.

For details about how properties work and how the getter and setter functions are called, see the descriptor documentation .