Python 面向对象 之 Property
初识 @property
Property 是 Python 类的一个内置的 装饰器. @property 的作用是 将一个方法, 变为属性来调用.
装饰器: 在不改变原函数的基础上, 动态给函数增加功能
之前已经讨论过很多装饰器的细节了, 本质就是利用Pyhton变量的引用(指针)特性 和 变量命名空间来实现的.
def out(func):
def inner(*args, **kwargs):
print(f"...{args[0]} is checking...")
return func(*args, **kwargs)
return inner
@out
def check_2019_nCov(name):
msg = f"okay, {name} is very healthy."
return msg
ret = check_2019_nCov("youge")
print(ret)
# output
...youge is checking...
okay, youge is very health
@property 这个装饰器, 我一般会用在代码优化上多一点, 将一个方法, 封装为属性, 在阅读体验会好一些. 具体咋实现的, 也没搞清楚, 暂时能应用就好了.
具体写法即在需要的方法上边用 @property 装饰, 参数只有self, 调用的时候不加括号.
@property 将方法装饰为属性
# 访问类的私有属性
class Foo:
def __init__(self, score):
self.__score = score
@property # 将方法装饰为属性
def show_score(self):
return self.__score
if __name__ == '__main__':
s = Foo(66)
# 在写法上更加优雅, 不用多写 "方法()" 没用的括号
print(s.show_score)
# output:
66
即在类自己的成员之间玩, (不需要传外部参数的情景下用, 表示 类的成员属性.), 初觉得比较 Pythonic 吧.
插一嘴, 上例中的 @property 所装饰的方法, 的功能是给 外部一个查看内部属性的接口. __ score 表示私有变量, 不能被直接访问, 期望上, 但 外部仍然是可以访问内部变量的, 感觉这算是 Pyhton不够严谨的地方吧, 没有绝对的安全哦.
s = Foo(66)
# 外部直接访问私有变量(方法) 是不可以的
print(s.__score)
# output
AttributeError: 'Foo' object has no attribute '__score'
but, 通过 实例对象.类名_ 私有属性 这样的方式是可以的 (为啥呢, 可以直接研究下Python类自身的构造原理)
s = Foo(66)
# 没有绝对的安全哦, 只要互相尊重
print(s._Foo__score)
# output
66
@property 相关属性
通过上面的写法, 感觉无非就是, 把方法变成了属性而已, 似乎.除了写法上比较简洁优雅一点, 具体的使用场景是什么呢?
绑定属性-校验-手动实现
class Foo:
def __init__(self, score):
self.score = score
# 绑定score属性
s = Foo(666)
更改 score 属性时, 我通常这样写.
s.score = 666
这样的无比粗暴 (直接将属性给暴露出去) 方式来 绑定属性 虽然写起来简单, 但是没有检验参数 导致可以随意被改.
这样粗暴的方法显然是不太合理的. 应该对 score进行一个校验, 值, 类型等都可以. 即我们在设置 score 属性的时候, 应该要实现两个 (自定义) 方法, get_score 用来查看值, 而 set_score 用来设置值.
class Foo:
def get_score(self):
"""获取属性值"""
print(self.score)
def set_score(self, value):
"""设置属性值"""
if not isinstance(value, int):
raise ValueError("score 必须为整数哦")
if value > 100 or value <= 0:
raise ValueError("score 必须在 0-100哦")
self.score = value
if __name__ == '__main__':
f = Foo()
# 校验通过是可以的
f.set_score(66)
f.get_score()
# output
66
# 随便设置 score 属性就不可以了.
if __name__ == '__main__':
f = Foo()
f.set_score('youge')
f.get_score()
# output
raise ValueError("score 必须为整数哦")
ValueError: score 必须为整数哦
# 继续 debug
if __name__ == '__main__':
f = Foo()
f.set_score('youge')
f.get_score()
# output
raise ValueError("score 必须在 0-100哦")
ValueError: score 必须在 0-100哦
case1 绑定属性-校验-@property 实现
- 默认是 只读
- setter
- deleter
class Foo:
@property # read only
def score(self):
"""获取属性值"""
return self.score
@score.setter
def score(self, value):
"""设置属性值"""
if not isinstance(value, int):
raise ValueError("score 必须为整数哦")
if value > 100 or value <= 0:
raise ValueError("score 必须在 0-100哦")
# 这里一定不能 self.socre = value 哦, 不然就递归了.
self._score = value
print(f"set score = {value} successfully.")
if __name__ == '__main__':
f = Foo()
f.score = 66
# print(f.score)
# output:
set score = 66 successfully
if __name__ == '__main__':
f = Foo()
f.score = 'youge'
# output
raise ValueError("score 必须为整数哦")
ValueError: score 必须为整数哦
case 2 - 封装类属性
再来一小栗子吧. 嗯, 封装一个Book的类, 主要用来描述书籍的名称, 价格和评论. 然后呢, 要求能用 property 装饰器实现对 Book 的实例属性 set 和 get 方法进行定义. 即让实例对象可以用属性的方式来操作方法/属性.
class Book:
def __init__(self, name, price, comment=None):
self.__name = name
self.__price = price
self.__comment = comment
# 传统方法对price属性进行 设置和访问
def get_price(self):
return self.__price
def set_price(self, value):
self.__price = value
# price = property(get_price, set_price)
# @property 装饰器对 comment 属性进行 设置和访问
@property
def my_comment(self):
# 默认是 getter, 需要return 或 yeild
return self.__comment
@my_comment.setter
def my_comment(self, value):
# 检验
if not isinstance(value, float):
raise ValueError("must be a decimal number")
if value < 0 or value > 1000:
raise ValueError("0 ~ 1000")
self.__comment = value
@my_comment.deleter
def my_comment(self):
print("delete this atrr...")
小结
- @property 装饰器的将方法变成属性来使用
- @property 默认是只读, 配合 setter, deleter ... 等一起使用
- 常用场景是对类实例属性赋值是, 进行一个 值的校验功能