37、Python之面向对象：通过property兼顾属性的动态保护与兼容性

引言

前面的文章中我们简要提及过关于Python中私有属性的使用与内部“名称混淆”的实现机制，所以，访问私有属性的方法至少有3种做法：

1、使用实例对象点操作符的方式，直接访问名称混淆后的真实属性名。

2、通过__dict__属性的字典式访问（前提是没有使用__slots__的特性）。

3、定义一个公有的方法来间接访问私有属性。

其中，第3种做法，跟Java、C#中定义POJO类时需要遵循的必须定义getter、setter方法比较相似，从其他语言转过来的同学，也更容易不自觉地使用这种方法来实现私有属性的访问控制。但是呢，这种做法不够Pythonic，也就是不那么地道……

本文，将介绍Python中的property特性，通过使用该特性，来实现更加灵活、强大的属性访问控制与代码的兼容性。

业务场景

仍然以简化的打工人的定义为例，首先看这样的打工人类型定义：

class DaGongRen:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def work(self):
        print(f"{self.age}岁的打工人{self.name}在努力工作")


if __name__ == '__main__':
    zs = DaGongRen('张三', 66)
    zs.work()
    # 获取age属性
    print(f"年龄为:{zs.age}")
    # 修改age属性
    zs.age = 80
    zs.work()

执行结果：

需要说明的是：

1）虽然这些代码放在了一个源码文件中，但是模拟了两个场景，分别是：打工人类型的定义、打工人类型的使用，这里只是为了演示方便才放到了一起。

2）从class定义开始到if __name__ == '__main__':这句之前，都是模块、类型定义的部分，从实际使用的场景会单独放到一个单独模块中。

3）从if __name__ == '__main__':开始是类型使用的部分，在这里其实是基于类型定义暴露的各种操作接口，来对类型进行实际使用了。

在实际应用场景中，这个代码的上下两部分大多数情况下会分别写在不同的模块中，并且可能不是同一个人来写。

由于age属性直接暴露给了使用方，所以，使用方可以随意修改age属性，甚至修改为负数或者一个极大的数字都是可以的，这样会导致很多垃圾数据的产生，这样很不安全。其实，这属于在类型设计上本身存在的缺陷，所以需要对类型定义进行优化。

getter/setter方式优化

通常能够立马想到的做法是将age切换为私有属性，通过公有方法进行访问和修改，代码如下：

class DaGongRen:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def get_age(self):
        return self.__age

    def set_age(self, new_age):
        if new_age <= 0 or new_age > 200:
            raise ValueError('异常的年龄，必须在(0, 200)之间')
        self.__age = new_age

    def work(self):
        print(f"{self.__age}岁的打工人{self.name}在努力工作")


if __name__ == '__main__':
    zs = DaGongRen('张三', 66)
    zs.work()
    # 获取age属性，之前的访问接口变了，使用的代码要改为通过get_age获取
    # print(f"年龄为:{zs.age}")
    print(f"年龄为:{zs.get_age()}")
    # 修改age属性，之前的访问接口变了，使用的代码要改为通过set_age修改
    # zs.age = 80
    zs.set_age(90)
    zs.work()
    # 尝试设置一个负数，会报错
    zs.set_age(-1)

执行结果：

确实实现了对属性age的安全访问（当然通过名称混淆后绕过保护机制也是可以的），但是这样做很不好！为什么不好，我们来分析一下：

1、实际项目中一般是团队合作开发，一个人负责定义实现一个公共的类型，可能会有多个人开发的模块中都会使用到这个公共的类型。

2、公共类型定义上的缺陷在优化的同时，对外暴露的使用该类型的接口发生了改变，zs.age的接口方式变成了zs.get_age()和zs.set_age()。这种做法，我们称之为兼容性太差。最直观的比喻就是，你将windows系统从xp直接升级到win11，结果很多软件都不能用了，你肯定要骂娘……

3、虽然示例代码中，我们修改了定义，同时把使用类型的部分代码自己进行了修改。但是，在实际项目中，首先，使用该类型的人可能有多个；其次，可能项目中有很多地方都通过之前的老的接口在使用该类型。很多人、项目的很多地方都要修改，漏改一处，可能都会导致线上事故。

这也是面向对象中“开闭原则（OCP）”中特别要求“对修改关闭”的原因，因为随意的修改可能导致代码兼容性的问题。

更加Pythonic的做法

当然，这里要说明的是，不是说getter/setter方式不好，如果公共模型一开始设计的时候，就考虑到数据的安全访问控制，使用了getter/setter形式的方式暴露操作接口，也是可以的。

只是这种做法在设计上不够Pythonic，而且进行代码重构时，不能保证兼容性。

更加Pythonic的做法，就是使用property的特性来进行代码的优化，直接看代码：

class DaGongRen:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

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

    @age.setter
    def age(self, new_age):
        if new_age <= 0 or new_age > 200:
            raise ValueError('异常的年龄，必须在(0, 200)之间')
        self.__age = new_age

    def work(self):
        print(f"{self.__age}岁的打工人{self.name}在努力工作")


if __name__ == '__main__':
    zs = DaGongRen('张三', 66)
    zs.work()
    # 获取age属性
    print(f"年龄为:{zs.age}")
    # 修改age属性
    zs.age = 80
    zs.work()

执行结果：

可以看到，通过这种方式，模块的定义部分使用property进行了优化，但是模块的使用部分没有发生任何修改，代码的此次优化做到了很好的兼容。可以说是用户无感知（用户可以是软件系统的终端用户，也可以是使用公共模块的开发人员）。

虽然property的使用很简单，这里还是简单介绍一下使用的注意事项：

1、@property装饰器提供了一种简洁的方法来定义类的属性，并提供了一种将方法转换为属性的机制，从而使得类的使用者能够像访问普通属性一样反问方法的返回值，实现更加干净、直观、兼容性更好的接口设计。

2、@property修饰的方法，其方法名可以等同与属性名，以属性的形式进行访问。

3、@方法名.setter修饰的同名方法，提供了以属性修改的方式进行方法的调用的机制。

总结

本文从一个有缺陷的设计的实际场景出发，引出了两种设计的优化方法，通过比较发现，使用property的方式能够实现一种兼容性更好的代码重构优化的方法。

其实，除了进行兼容性更好的代码重构，通过property还可以实现只读属性的设计（只定义@property，不定义xxx.setter）、延迟计算/动态计算的属性（比如只定义半径属性，通过property定义面积、周长的动态计算的属性）等。感兴趣的同学可以自行尝试。

感谢您的拨冗阅读，如果今天的内容对您学习Python有所帮助，欢迎点赞收藏。