Question about extending a property in a sub class

I am working through the O Reilly Python Cookbook.

I have a question about the following code, to do with extending a property in a sub class:

class Person:
    def __init__(self, name):
        self.name = name

    # Getter function
    @property
    def name(self):
        return self._name

    # Setter function
    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError('Expected a string')
        self._name = value

    @name.deleter
    def name(self):
        raise AttributeError("Can't delete attribute")

class SubPerson(Person):
    @property
    def name(self):
        print('Getting name')
        return super().name

    @name.setter
    def name(self, value):
        print('Setting name to', value)
        super(SubPerson, SubPerson).name.__set__(self, value)

    @name.deleter
    def name(self):
        print('Deleting name')
        super(SubPerson, SubPerson).name.__delete__(self)

I'm confused about:

super(SubPerson, SubPerson).name.__set__(self, value)

With super(SubPerson,SubPerson) it seems to be accessing the method as a class variable, why cant it access the method as an instance variable instead?

Also, how does set and @name.setter relate to one another? Aren't they effectively the same thing?

Could the same line be written as:

super(SubPerson, SubPerson).name.settr(self,value)

There are two questions here.

First is about super(SubPerson, SubPerson). It is just a trick to access the actual property object which is an attribute of the class. What is wanted here is Person.name, because once we have it, we can use the setter and deleter functions of the property. The problem with super().name or with any instance type access is that super() does not return an object but a proxy. And the property name on the proxy will only give access to the getter.

The latter is about @name.setter. In fact property as the initial decorator defines name as a property object. The setter attribute of a property is also a decorator that sets the setter function on its object and returns the object. That means that it is only intented to be used at class definition time. In fact the @name.setter bloc is roughly equivalent to the following code after the class definition:

def foo(self, value):
    ...
SubPerson.name = SubPerson.name.setter(foo)

The method that you wanted to use is the fset attribute of the property. That means that the setter part could have been written as :

@name.setter
def name(self, value):
    print('Setting name to', value)
    super(SubPerson, SubPerson).name.fset(self, value)