function 如何像描述符一样工作？

Question

def typed_property(name, expected_type):
    storage_name = '_' + name

    @property
    def prop(self):
        return getattr(self, storage_name)

    @prop.setter
    def prop(self, value):
        if not isinstance(value, expected_type):
            raise TypeError('{} must be a {}'.format(name, expected_type))
        setattr(self, storage_name, value)
    return prop


class Person:
    name = typed_property('name', str)
    age = typed_property('age', int)
    def __init__(self, name, age):
        self.name = name
        self.age = age

Function typed_property() acts like a descriptor. Why prop() is called when executing this code line (name = typed_property('name', str))?

Answer 1

I don't know what you mean by "descriptor". typed_property allows a property to call a function for additional processing. prop() is not called when executing the line you mentioned. It is called when executing self.name = name . The @prop.setter makes it so the object can respond to property calls like that.

Answer 2

When you call typed_property to set the value of the class properties name and age , you are really defining those to be methods to use to access the instance values self.name and self.age . This is the same as below omitting age for simplicity:

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

    @property
    def name(self):
        print("=== ACESSING")
        return self.name

    @name.setter
    def name(self, name):
        print("=== MUTATING")
        self.name = name

This marks the name(self) method as the accessor for self.name , and name(self, val) as the mutator. The mutator is called whenever you try to change (mutate) the value of its assigned property, in this case self.name . This includes when you are calling it in the __init__ method. However, using the class as defined above will result in an infinite recursion because I am calling the mutator from inside the mutator. So "=== MUTATING" will be printed ending in a recursion error. So a small adjustment is needed:

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

    @property
    def name(self):
        print("=== ACCESSING")
        return self._name

    @name.setter
    def name(self, val):
        print("=== MUTATING")
        self._name = val

Now that underlying property is name _name rather than name the mutator will set the value of _name rather than setting it for name and recur into itself infinitely. For example, using the class as defined above:

>>> p = Person("joshmeranda")
>>> p.name
=== ACCESSING
"joshmeranda"