Python内置属性函数@property详解

在Python中，property()是一个内置函数，
用于创建和返回一个property对象。
Property对象有三个方法，getter(), setter()和delete()，
用来在对象创建后设置fget，fset和fdel。
装饰器（decorator）可以给函数动态加上功能,对于类的方法，装饰器一样起作用。
Python内置的@property装饰器就是负责把一个方法变成属性调用的。

python【概述】【环境安装】【IDE开发工具】

python函数装饰器(function decorator)提供了一种方式,替函数明确了特定的运算模式,也就是将函数包裹了另一层,在另一函数的逻辑内实现。

Python内置的@property装饰器就是负责把一个方法变成属性调用的, 属性是对事物某种特性的抽象，面向对象编程中一个重要概念；区别于字段，它通常表示为字段的扩展，加以访问与设置保护机制。

官方文档：https://docs.python.org/release/2.6/library/functions.html#property

property 是Python中很赞的概念，它使得面向对象的编程更加简单。在详细解释和深入了解Python中的property之前，让我们首先建立这样一个直觉：为什么我们需要用到property？

从一个实例开始

假设有天你决定创建一个类，用来存储摄氏温度。当然这个类也需要实现一个将摄氏温度转换为华氏温度的方法。一种实现的方式如下：

class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature
    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32

我们可以用这个类产生一个对象，然后按照我们期望的方式改变该对象的温度属性： 

>>> # create new object
>>> man = Celsius()
 
>>> # set temperature
>>> man.temperature = 37
 
>>> # get temperature
>>> man.temperature
37
 
>>> # get degrees Fahrenheit
>>> man.to_fahrenheit()
98.60000000000001

这里额外的小数部分是转换成华氏温度时由于浮点运算误差造成的（你可以在Python解释器中试试1.1 + 2.2）。每当我们赋值或获取任何对象的属性时，例如上面展示的温度，Python都会从对象的__dict__字典中搜索它。 

>>> man.__dict__
{'temperature': 37}

因此，man.temperature在其内部就变成了man.__dict__['temperature']

现在，让我们进一步假设我们的类在客户中很受欢迎，他们开始在其程序中使用这个类。他们对该类生成的对象做了各种操作。有一天，一个受信任的客户来找我们，建议温度不能低于-273摄氏度（热力学的同学可能会提出异议，它实际上是-273.15），也被称为绝对零。客户进一步要求我们实现这个值约束。作为一个以争取客户满意度为己任的公司，我们很高兴地听从了建议，发布了1.01版本，升级了我们现有的类。

使用Getters和Setters

对于上边的约束，一个很容易想到的解决方案是隐藏其温度属性（使其私有化），并且定义新的用于操作温度属性的getter和setter接口。可以这么实现：

class Celsius:
    def __init__(self, temperature = 0):
        self.set_temperature(temperature)
 
    def to_fahrenheit(self):
        return (self.get_temperature() * 1.8) + 32
 
    # new update
    def get_temperature(self):
        return self._temperature
 
    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        self._temperature = value

从上边可以看出，我们定义了两个新方法get_temperature()和set_temperature()，此外属性temperature也被替换为了_temperature。最前边的下划线（_）用于指示Python中的私有变量。 

>>> c = Celsius(-277)
Traceback (most recent call last):
...
ValueError: Temperature below -273 is not possible
 
>>> c = Celsius(37)
>>> c.get_temperature()
37
>>> c.set_temperature(10)
 
>>> c.set_temperature(-300)
Traceback (most recent call last):
...
ValueError: Temperature below -273 is not possible

这个更新成功地实现了新约束，我们不再允许设置温度低于-273度。

请注意，Python中实际上是没有私有变量的。有一些简单的被遵循的规范。Python本身不会应用任何限制。

>>> c._temperature = -300
>>> c.get_temperature()
-300

但这样并不会让人很放心。上述更新的最大问题是，所有在他们的程序中使用了我们先前类的客户都必须更改他们的代码：obj.temperature改为obj.get_temperature()，所有的赋值语句也必须更改，比如obj.temperature = val改为obj.set_temperature(val)。这样的重构会给那些拥有成千上万行代码的客户带来很大的麻烦。

总而言之，我们的更新是不向后兼容地。这就是需要property闪亮登场的地方。

Property的作用

对于上边的问题，Python式的解决方式是使用property。这里是我们已经实现了的一个版本：

class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature
 
    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32
 
    def get_temperature(self):
        print("Getting value")
        return self._temperature
 
    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value
 
    temperature = property(get_temperature,set_temperature)

我们在get_temperature()和set_temperature()的内部增加了一个print()函数，用来清楚地观察它们是否正在执行。代码的最后一行，创建了一个property对象temperature。简单地说，property将一些代码（get_temperature和set_temperature）附加到成员属性（temperature）的访问入口。任何获取temperature值的代码都会自动调用get_temperature()，而不是去字典表（__dict__）中进行查找。同样的，任何赋给temperature值的代码也会自动调用set_temperature()。这是Python中一个很酷的功能。我们实际演示一下。 

>>> c = Celsius()
Setting value

从上边的代码中我们可以看到，即使当我们创建一个对象时，set_temperature()也会被调用。你能猜到为什么吗？原因是，当一个对象被创建时，__init__()方法被调用。该方法有一行代码self.temperature = temperature。这个任务会自动调用set_temperature()方法。 

>>> c.temperature
Getting value
0

同样的，对于属性的任何访问，例如c.temperature，也会自动调用get_temperature()方法。这就是property所作的事情。这里有一些额外的实例。 

>>> c.temperature = 37
Setting value
 
>>> c.to_fahrenheit()
Getting value
98.60000000000001

我们可以看到，通过使用property，我们在不需要客户代码做任何修改的情况下，修改了我们的类，并实现了值约束。因此我们的实现是向后兼容的，这样的结果，大家都很高兴。

最后需要注意的是，实际温度值存储在私有变量_temperature中。属性temperature是一个property对象，是用来为这个私有变量提供接口的。

深入挖掘property

在Python中，property()是一个内置函数，用于创建和返回一个property对象。该函数的签名为：

property(fget=None, fset=None, fdel=None, doc=None)

这里，fget是一个获取属性值的函数，fset是一个设置属性值的函数，fdel是一个删除属性的函数，doc是一个字符串（类似于注释）。从函数实现上看，这些函数参数都是可选的。所以，可以按照如下的方式简单的创建一个property对象。

>>> property()
<property object at 0x0000000003239B38>

Property对象有三个方法，getter(), setter()和delete()，用来在对象创建后设置fget，fset和fdel。这就意味着，这行代码：temperature = property(get_temperature,set_temperature)可以被分解为：

# make empty property
temperature = property()
# assign fget
temperature = temperature.getter(get_temperature)
# assign fset
temperature = temperature.setter(set_temperature)

它们之间是相互等价的。

熟悉Python中装饰器decorator的程序员能够认识到上述结构可以作为decorator实现。我们可以更进一步，不去定义名字get_temperature和set_temperature，因为他们不是必须的，并且污染类的命名空间。为此，我们在定义getter函数和setter函数时重用名字temperature。下边的代码展示如何实现它。

class Celsius:
    def __init__(self, temperature = 0):
        self._temperature = temperature
 
    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32
 
    @property
    def temperature(self):
        print("Getting value")
        return self._temperature
 
    @temperature.setter
    def temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value

上边的两种生成property的实现方式，都很简单，推荐使用。在Python寻找property时，你很可能会遇到这种类似的代码结构。

【python深度学习】目录

使用@property

在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改：

s = Student()
s.score = 9999

这显然不合逻辑。为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

class Student(object):

    def get_score(self):
        return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

现在，对任意的Student实例进行操作，就不能随心所欲地设置score了：

>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score()
60
>>> s.set_score(9999)
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。

有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？对于追求完美的Python程序员来说，这是必须要做到的！

还记得装饰器（decorator）可以给函数动态加上功能吗？对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。

还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2014 - self._birth

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来。

小结

@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

装饰器（decorator）可以给函数动态加上功能,对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

下面写一个例子 

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__='byx54192@gmail.com'

class Student(object):

    @property #将birth 转换为属性，外部可是直接s.birth访问
    def birth(self):
        return self._birth

    @birth.setter #@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值
    def birth(self, value):
        if value>0 and value<100:
            self._birth = value
        else:
            raise ValueError('birth must between 0~100')

    @property #将age方法转换为属性，外部调用时，可以用s.age访问。
    def age(self):
        return 2015 - self._birth
s= Student()
s.birth=10
print(s.age)
print(s.birth)

练习

请利用@property给一个Screen对象加上width和height属性，以及一个只读属性resolution：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__='byx54192@gmail.com'

class Screen(object):
    @property
    def width(self):
        return self._width
    @width.setter
    def width(self,value):
        if value!=768:
            return 0
        self._width=value

    @property    
    def height(self):
        return self._height
    @height.setter
    def height(self,value):
        if value!=1024:
            return 0
        self._height=value

    @property
    def resolution(self):
        return self._width*self._height
s=Screen()
s.width=768
s.height=1024
print('resolution=',s.resolution)
if s.resolution == 786432:
    print('测试通过!')
else:
    print('测试失败!')

1. 什么是property属性

一种用起来像是使用的实例属性一样的特殊属性，可以对应于某个方法

# ############### 定义 ###############
class Foo:
    def func(self):
        pass

    # 定义property属性
    @property
    def prop(self):
        pass

# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()  # 调用实例方法
foo_obj.prop  # 调用property属性

2.为什么使用property属性

在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改：

s = Student()
s.score = 9999

这显然不合逻辑。为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

class Student(object):

    def get_score(self):
        return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

调用：
s = Student()
s.set_score(60) # ok!
s.get_score()
60
s.set_score(9999)
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。

有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？对于追求完美的Python程序员来说，这是必须要做到的！

还记得装饰器（decorator）可以给函数动态加上功能吗？对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

调用：
s = Student()
s.score = 60 # OK，实际转化为s.set_score(60)
s.score # OK，实际转化为s.get_score()
60
s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

3. property属性的有两种方式

  • 装饰器 即：在方法上应用装饰器
  • 类属性 即：在类中定义值为property对象的类属性

3.1 装饰器方式

在类的实例方法上应用@property装饰器

#coding=utf-8
# ############### 定义 ###############
class Goods:
    """python3中默认继承object类
        以python2、3执行此程序的结果不同，因为只有在python3中才有@xxx.setter  @xxx.deleter
    """
    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')

# ############### 调用 ###############
obj = Goods()
obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

3.2 类属性方式，创建值为property对象的类属性

property方法中有个四个参数

  • 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
  • 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
  • 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
  • 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息
#coding=utf-8
class Foo(object):
    def get_bar(self):
        print("getter...")
        return 'laowang'

    def set_bar(self, value): 
        """必须两个参数"""
        print("setter...")
        return 'set value' + value

    def del_bar(self):
        print("deleter...")
        return 'laowang'

    BAR = property(get_bar, set_bar, del_bar, "description...")

obj = Foo()

obj.BAR  # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = "alex"  # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
desc = Foo.BAR.__doc__  # 自动获取第四个参数中设置的值：description...
print(desc)
del obj.BAR  # 自动调用第三个参数中定义的方法：del_bar方法

作者：

喜欢围棋和编程。

 
作者 发布于 分类 编程标签

发表评论

邮箱地址不会被公开。