Python的特性(property)

特性（property)

特性是对类的一个特定属性进行拦截，在操作这个属性时，执行特定的函数，对属性的操作进行拦截。

特性的实现

特性使用property类来实现，也可以使用property装饰器实现，二者本质是一样的。

property类的__init__函数接收4个参数，来实现属性的获取、赋值、删除及文档。

    def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__
        """
        property(fget=None, fset=None, fdel=None, doc=None) -> property attribute

        fget is a function to be used for getting an attribute value, and likewise
        fset is a function for setting, and fdel a function for del'ing, an
        attribute.  Typical use is to define a managed attribute x:

        class C(object):
            def getx(self): return self._x
            def setx(self, value): self._x = value
            def delx(self): del self._x
            x = property(getx, setx, delx, "I'm the 'x' property.")

        Decorators make defining new properties or modifying existing ones easy:

        class C(object):
            @property
            def x(self):
                "I am the 'x' property."
                return self._x
            @x.setter
            def x(self, value):
                self._x = value
            @x.deleter
            def x(self):
                del self._x

        # (copied from class doc)
        """
        pass

从代码上看，4个参数都不是必须的，如果没有传入对应的操作函数，则取默认值None，则对应的操作不受支持，试图调用默认值None时，会引发异常。

测试代码：

class Person(object):

    def __init__(self, age):
        self._age = age

    # @property 装饰器等同于 age = property(fget=age)
    @property
    def age(self):
        return self._age

if __name__ == '__main__':

    jack = Person(22)
    jack.age = 32

因为缺少setter的函数方法，所以试图给age赋值时，会引发异常。

AttributeError: can't set attribute

所以我们把setter方法补充完整，setter装饰器的写法是刚刚被property的装饰器所装饰的函数的名称，再加上setter属性。

比如下面例子中，装饰的是 def age(self): .... 这个方法，那么对应的setter装饰器，就应该是 @age.setter

class Person(object):

    def __init__(self, age):
        self._age = age
        self._name = 'lilei'

    # @property 装饰器等同于 age = property(fget=age)
    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        print('person property age setter')
        self._age = value * 2

一开始可能不太容易理解，age明明是一个实例方法，内部也没有setter这个属性，为什么就变成了一个装饰器，还有setter这个属性了？

实际上，age()方法上增加@property装饰器，等同于age = property(fget=age)，将age赋值为property的实例。

所以，被装饰后的age，已经不是这个实例方法age了，而是property的实例age。

可以将age的type打印出来看看，会得到<class 'property'>，说明age已经不是当初那个age了，他们只是同名而已。

可以再做个测试，把装饰器的写法修改下：

@property
def age(self):
    pass

修改为

age = property(fget=age)

不影响代码的执行，所以@age.setter装饰器就很好理解了，因为age是property类的实例，property类有setter的方法，age拥有property类的setter方法，所以可以使用@age.setter装饰器。其他的setter、getter、deleter也是同理。

特性的继承

类的实例和子类都会继承类的特性，测试代码：

class Person(object):
　　def __init__(self, age):
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        self._age = value * 2

class Man(Person):
    pass

if __name__ == '__main__':

    tom = Man(22)
    print(tom.age)
    tom.age = 23
    print(tom.age)

在age的setter方法中，将age的值乘以2，从运行结果上看，子类及其实例都是继承property的

22
46

特性只对实例方法有效，对于静态方法、类方法都无法使用

在子类中重写父类的property

如果想在子类中，重写父类的property，实际上要分为两种情况：一种是完全重写父类的property，一种是只想重写父类property的某些方法，比如说setter。

完全重写父类的property最为简单，在子类中重新定义一个同名的getter函数，再加上@propety装饰器即可。

class Student(Person):

    # 如果在子类重新定义一个property,会完全覆盖掉父类的同名的property,包括里面的方法
    # 所以没有定义setter方法,age变为只读,无法赋值
    # 实际上,这种方式是在子类重新创建了一个名为age的property对象,覆盖掉了父类名为age的property
    # age = property(fget=..., fset=None)
    @property
    def age(self):
        print('student property age getter')
        return self._age

可以这么理解，上面相当于在子类创建了一个property的同名实例：age，根据类继承的原则，子类的属性会覆盖掉父类的属性，所以这个时候调用子类实例的age，只会执行子类的getter方法，同时，因为setter和deleter方法没有定义，无法进行对应的操作。

如果只想修改父类propery的某个方法，会稍微麻烦点。

在使用propery装饰器的时候，需要先指定父类的名称，property实例的名称，最后指定需要修改的方法。

如下面示例代码的 @Person.age.getter。因为age本身是property的类实例，所以@Person.age.getter 这个装饰器，相当于找到父类Person的属性age，在找到age的getter方法，并用被装饰的函数，覆盖掉父类的getter方法函数。

同样，setter方法和deleter的方法也是同理。

class Teacher(Person):

    # 只有这种方式才能正确的覆盖掉父类的getter方法
    @Person.age.getter
    def age(self):
        print('teacher property age getter')
        return self._age

    # 同样, 这样才能正确的覆盖掉父类特性的setter方法
    # property是个类,@Person.age.setter,这个操作相当于找到Person下,这个age(property实例)的方法fset
    # 并用我们在子类的方法将其覆盖。
    @Person.age.setter
    def age(self, value):
        print('teacher property age setter')
        self._age = value

上面的方法,其实有个缺陷：我们必须清楚的知道,需要重写的propery所属的父类。

这对于单继承通常的是没有问题的,但是对于多继承就会存在问题：比如继承树中存在多个同名的property那么到底应该继承哪个property就会产生疑惑。

比较合理的解决办法是,如student这个类一样,彻底重写property的实例,再使用super()方法去调用父类的方法。

class Girl(Person):

    @property
    def age(self):
        print('girl property age getter')
        return super().age

    @age.setter
    def age(self, value):
        print('girl property age setter')
        super(Girl, Girl).age.__set__(self, value)