Python中的property介绍（修订）

Python中的property介绍（修订）

property是一种用于类的特殊属性，用于控制和保护属性的访问和修改。因此，在使用property之前，需要了解类和对象的基本概念和使用方法。property是通过装饰器（decorator）来定义的，因此需要了解Python中的装饰器的基本概念和使用方法。

Python中进行OOP（面向对象程序设计）时，获取、设置和删除对象属性（ attribute）的时候，常常需要限制对象属性的设置和获取，比如设置为只读、设置取值范围限制等，从而有助于类封装的灵活性，又可以使用“对象.属性”的方式操作操作类属性。为此，Python提供了两种实现机制，property() 函数和 @property 装饰器。有关这些称为Python的property（特性、特征属性）。类（class）技术本身就是一种封装手段，Python的property可以提升类封装的灵活性。

官网介绍：中文 https://docs.python.org/zh-cn/3/library/functions.html#property
英文 https://docs.python.org/3/library/functions.html#property  

关于Python面向对象程序设计可参见https://blog.csdn.net/cnds123/article/details/108354860

【python中的attribute和property有什么区别

提示：attribute一般译为属性，property译为特性，但也有相反的。

attribute 包括默认的 getter/setter/deleter，触发内置的 get/set/delete 方法。

property 是特殊的 attribute，可以自定义 getter/setter/deleter 等属性，自己控制 get/set/delete 时触发的方法，也可以不定义来禁止该操作。property主要解决两个事情，如何更好的封装和访问。

早期的python中是没有property这个概念的，是在python2.2中引入的，然后在2.4中才出现了@property这样的装饰器对象的样子。

装饰器（decorator）就是把原函数传给一个新的对象或函数，然后用这个新的对象来替换原来的函数。所以当我们看到类似如下的代码：

@property

def x(self):

    pass

头脑中要把它连成一个整体，它代表一个新的函数要替换原来的x(self)函数。这个新函数要干两件重要的事情：

一是执行原来的函数并返回其结果；

二是在函数执行的前后添加新的功能，这就是装饰器模式的本义。

关于python装饰器(Decorator) ，可参见 https://blog.csdn.net/cnds123/article/details/115588075

关于attribute和Property的异同，后面还将介绍】

一、property() 函数

语法：

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

返回 property 属性（attribute）

说明：

fget 是获取属性值的函数。

fset 是设置（修改）属性值的函数。

fdel 是删除属性值的函数。

doc 是属性描述信息。如果省略，会把 fget 方法的文档字符串（docstring）拿来用（如果有的话）。

可以使用property()函数来手动实现对类的成员变量进行访问、设置（修改）、删除操作。如果只需要获取属性值，可以省略设置（修改）和删除方法。

下面给出property() 函数示例

class Student:
    def __init__(self):
        self._age = None

    def get_age(self):
        print('获取属性时执行的代码')
        return self._age

    def set_age(self, age):
        print('设置属性时执行的代码')
        self._age = age

    def del_age(self):
        print('删除属性时执行的代码')
        del self._age

    age = property(get_age, set_age, del_age, '学生年龄')


student = Student()
# 注意要用 类名.属性.__doc__ 的形式查看属性的文档字符串
print('查看属性的文档字符串：' + Student.age.__doc__)
"""
查看属性的文档字符串：学生年龄
"""

# 设置属性
student.age = 18
"""
设置属性时执行的代码
"""

# 获取属性
print('学生年龄为：' + str(student.age))
"""
获取属性时执行的代码
学生年龄为：18
"""

# 删除属性
del student.age
"""
删除属性时执行的代码
"""

运行效果：

二、@property 装饰器

提供了比 property() 函数更简洁直观的写法。@property装饰器可以做到和内置函数property() 相同的事情。

被 @property 装饰的方法是获取属性值的方法，被装饰方法的名字会被用做 属性名。

被 @属性名.setter 装饰的方法是设置属性值的方法。

被 @属性名.deleter 装饰的方法是删除属性值的方法。

特别提示：

property的getter方法可以使用@property装饰器来定义，这种方式不需要指定属性名；也可以使用@属性名.getter的方式来定义。这两种方式本质上是等价的。

若省略设置属性值的方法，此时该属性变成只读属性。如果此时仍然设置属性，会抛出异常 AttributeError: can't set attribute。

如果报错 RecursionError: maximum recursion depth exceeded while calling a Python object，很可能是对象属性名和 @property 装饰的方法名重名了，一般会在对象属性名前加一个下划线 _ 避免重名，并且表明这是一个受保护的属性。

下面给出@property 装饰器示例

class Student:
    def __init__(self):
        self._age = None

    @property
    def age(self):
        print('获取属性时执行的代码')
        return self._age

    @age.setter
    def age(self, age):
        print('设置属性时执行的代码')
        self._age = age

    @age.deleter
    def age(self):
        print('删除属性时执行的代码')
        del self._age


student = Student()

# 设置属性
student.age = 18
"""
设置属性时执行的代码
"""

# 获取属性
print('学生年龄为：' + str(student.age))
"""
获取属性时执行的代码
学生年龄为：18
"""

# 删除属性
del student.age
"""
删除属性时执行的代码
"""

运行效果：

请注意，在使用property时，需要了解一些细节问题：
通常，getter方法名和属性名一致（上例中是age）；
setter方法名必须与getter方法名相同；
必须先定义getter方法，setter方法才能使用。

三、property的作用

先看一个例子，例子中不使用property，源码如下：

# 不使用property的情况
class Person:
    def __init__(self, first_name):
        self.first_name = first_name

a = Person('Jack')
print(a.first_name) # 

a.first_name = 42 # 
print(a.first_name)

del a.first_name  #

运行情况如下：

Python中使用property能给属性（attribute）增加类型检查验证 

修改上例，为其定义了property装饰器，用来增加对一个属性简单的类型检查，源码如下：

# 使用property装饰器，为实例的attribute 增加（除访问与修改之外的）其他处理逻辑
class Person:
    def __init__(self, first_name):
        self.first_name = first_name

    #定义相关联的函数（方法），这里是三个，名字都必须一样。 
    #定义Getter函数
    @property
    def first_name(self):
        return self._first_name

    # 定义Setter装饰器函数
    @first_name.setter
    def first_name(self, value):
        # isinstance() 函数，用来判断一个函数是否是一个已知的类型
        if not isinstance(value, str):
            raise TypeError('应为字符串')
        self._first_name = value

    # 定义Deleter装饰器函数——可选
    @first_name.deleter
    def first_name(self):
        raise AttributeError("不能删除")

a = Person('Jack')
print(a.first_name)  # 调用getter，输出：Jack

#a.first_name = 42  #【注1】不允许，否则报错 TypeError: 应为字符串
print(a.first_name)

#del a.first_name  #【注2】不允许，否则报错 AttributeError: 不能删除

你可以运行试试。再分别将【注1】处#a.first_name = 42改为a.first_name = 42，将【注2】处#del a.first_name改为del a.first_name，试试。

由此可知，Python中使用property能给属性（attribute）增加类型检查验证。

特别提示，上述代码中有三个相关联的方法，这三个方法的名字都必须一样。第一个方法是一个getter 函数，它使得first_name成为一个属性。其他两个方法给 first_name属性添加了setter和 deleter函数。需要强调的是只有在 first_name 属性被创建后，后面的两个装饰器@first_name.setter和@first_name.deleter才能被定义。 property 的一个关键特征是它看上去跟普通的 attribute没什么两样，但是访问它的时候会自动触发getter 、setter 和 deleter 方法。

在实现一个property的时候，底层数据 (如果有的话) 仍然需要存储在某个地方。 因此，在get 和 set 方法中，你会看到对_first_name属性的操作，这也是实际数据保存的地方。另外，为什么__init__()方法中设置了self.first_name 而不是self._first_name。在这个例子中，我们创建一个 property 的目的就是在设置 attribute 的时候进行检查。因此，你可能想在初始化的时候也进行这种类型检查。通过设置 self.first_name，自动调用setter方法，这个方法里面会进行参数的检查，否则就是直接访问 self._first_name 了。

Python中使用property还可以用于定义动态计算attribute，这种类型的 attributes 并不会被实际的存储，而是在需要的时候计算出来。示例代码如下：

import math
#property装饰器用于定义动态计算attribute的情况 
class Circle:
    def __init__(self, radius):
        self.radius = radius
 
    @property
    def area(self):
        return math.pi * self.radius ** 2
 
    @property
    def diameter(self):
        return self.radius * 2
  
    @property
    def perimeter(self):
        return 2 * math.pi * self.radius

c = Circle(4.0)
print(c.radius) #注意不要带()
print(c.area) #注意不要带() 
print(c.perimeter) #注意不要带()

运行情况如下：

使用 @property 装饰器可以将一个方法转化为只读属性，结合 @<attribute name>.setter 和 @<attribute name>.deleter 装饰器也可以将一个方法转化为可写和可删属性。这样做有助于隐藏底层实现细节，提高代码的封装性和安全性。

四、property()函数和@property装饰器的关系

property()函数和@property装饰器都可以用来创建Python中的属性（attribute），它们本质上是等价的，只是使用方式不同。

property()函数是一个内置函数，它接受四个参数，分别是getter方法、setter方法、deleter方法和docstring。其中，getter方法用于获取属性值，setter方法用于设置属性值，deleter方法用于删除属性，docstring则是该属性的文档说明。当我们需要定义一个复杂的属性时，可以使用property()函数来创建它。例如：

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height
    
    def get_width(self):
        return self._width
    
    def set_width(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError('Width must be a number')
        self._width = value
    
    def get_height(self):
        return self._height
    
    def set_height(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError('Height must be a number')
        self._height = value
    
    def area(self):
        return self._width * self._height
    
    # 定义一个名为width的属性，通过get_width()和set_width()方法进行操作
    width = property(get_width, set_width, doc='The width of the rectangle')
    
    # 定义一个名为height的属性，通过get_height()和set_height()方法进行操作
    height = property(get_height, set_height, doc='The height of the rectangle')

# 使用部分
rect = Rectangle(3, 4)
print(rect.width)   # 输出：3
print(rect.height)  # 输出：4

rect.width = 5      # 设置宽度为5
rect.height = 6     # 设置高度为6

print(rect.area())  # 输出：30

# 尝试设置非法参数
try:
    rect.width = 'hello'
except TypeError as e:
    print(e)        # 输出：Width must be a number

在上述代码中，我们使用property()函数分别定义了width和height两个属性，通过get_width()、set_width()、get_height()和set_height()方法来操作这两个属性。然后，建了一个Rectangle对象，并使用width和height两个属性来设置其宽度和高度。接着，我们通过rect.area()方法来计算该矩形的面积，并将结果输出。

同时，在设置宽度和高度时，如果传入的值不是数字类型，则会抛出一个TypeError异常。为了验证这一点，我们在代码中故意将宽度设置为一个字符串类型的值，从而触发该异常，并将其捕获并输出到控制台上。

而@property装饰器则是Python中的一种语法糖，它可以将一个类方法转换为一个属性，使得我们可以像访问普通属性一样调用该方法。在使用@property装饰器时，我们只需要在方法上添加该装饰器即可。例如：

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height
    
    @property
    def width(self):
        return self._width
    
    @width.setter
    def width(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError('Width must be a number')
        self._width = value
    
    @property
    def height(self):
        return self._height
    
    @height.setter
    def height(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError('Height must be a number')
        self._height = value
    
    @property
    def area(self):
        return self._width * self._height

# 使用部分
rect = Rectangle(3, 4)
print(rect.width)   # 输出：3
print(rect.height)  # 输出：4

rect.width = 5      # 设置宽度为5
rect.height = 6     # 设置高度为6

print(rect.area)    # 输出：30

# 尝试设置非法参数
try:
    rect.width = 'hello'
except TypeError as e:
    print(e)        # 输出：Width must be a number

在上述代码中，我们使用@property装饰器分别定义了width、height和area三个属性，通过getter和setter方法来操作这些属性。然后，创建了一个Rectangle对象，并使用width和height两个属性来设置其宽度和高度。接着，我们通过rect.area属性来计算该矩形的面积，并将结果输出。

同时，在设置宽度和高度时，如果传入的值不是数字类型，则会抛出一个TypeError异常。为了验证这一点，我们在代码中故意将宽度设置为一个字符串类型的值，从而触发该异常，并将其捕获并输出到控制台上。

与前面的例子相比，使用@property装饰器更加简洁和直观，同时也提高了代码的可读性和可维护性。

需要注意的是，当我们使用@property装饰器时，由于setter和deleter方法是可选的，因此如果不需要设置或删除属性，可以直接省略它们。同时，使用property()函数时，getter方法是必须指定的，而setter和deleter方法是可选的，可以传入None来表示不需要这些方法。

五、Python中的attribute和Property的异同

attribute 和 property 在表达对象状态和特征方面具有相似性，但在实现方式和使用场景方面存在较大的差异。attribute通常用于表示对象的简单状态，而 property 用于实现更复杂的计算和验证操作，或者对对象特征进行保护和隐藏。

Attribute是一个对象的数据成员，它通常被定义为对象的一个变量，可以通过对象来访问和修改。

“Property”是一种特殊的属性，它实际上是一对getter和setter方法，可以在访问属性时执行一些特定的操作，比如数据类型转换、计算、验证等。Property是一个特殊的attribute，它可以被定义为一个方法，当访问或修改它时，会自动调用相应的方法。Property通常用于控制对对象属性的访问和修改，以确保对象的状态始终处于有效的范围内。

当我们定义一个类的时候，可以使用 attribute 和 property 来描述对象的状态或特征，下面举例说明它们的异同。

attribute 示例源码：

class Person:
    def __init__(self, name, age):
        self.name = name   # 定义了一个名为 name 的 attribute
        self.age = age     # 定义了一个名为 age 的 attribute
        
person = Person("Alice", 30)

# 访问属性
print(person.name)       # 输出: Alice
print(person.age)        # 输出: 30

# 修改属性
person.name = "Bob"
person.age = 25

# 再次访问属性
print(person.name)       # 输出: Bob
print(person.age)        # 输出: 25

上面的示例中，我们定义了一个 Person 类，并定义了两个 attribute：name 和 age。我们可以直接通过 . 操作符来访问和修改这些 attribute 的值。

property 示例源码：

class Person:
    def __init__(self, name, age):
        self._name = name   # 定义了一个名为 _name 的属性
        self._age = age     # 定义了一个名为 _age 的属性
    
    # 定义一个名为 name 的 property
    @property
    def name(self):
        return self._name
    
    # 定义一个名为 age 的 property
    @property
    def age(self):
        return self._age
    
    # 定义一个名为 set_age 的方法，用于设置年龄在合适范围
    @age.setter
    def set_age(self, value):
        if 0 < value <= 120:
            self._age = value
        else:
            raise ValueError("Invalid age")
        
person = Person("Alice", 30)

# 访问属性
print(person.name)       # 输出: Alice
print(person.age)        # 输出: 30

# 修改属性
person._name = "Bob"
person.set_age = 25

# 再次访问属性
print(person.name)       # 输出: Bob
print(person.age)        # 输出: 25

# 修改属性，但不符合条件会抛出异常
person.set_age = -5      # 抛出异常: Invalid age

上面的示例中，我们同样定义了一个 Person 类，并定义了两个属性：_name 和 _age。但是这次我们使用 property 来实现对这些属性的访问和修改。

通过 @property 装饰器，我们定义了名为 name 和 age 的 property 方法，它们分别返回 _name 和 _age 的值。而通过 @age.setter 装饰器，我们定义了一个名为 set_age 的方法，用于设置 _age 属性的值，但是同时也对该值进行了范围检查。

与 attribute 不同的是，我们不能直接通过 . 操作符来访问和修改 property 的值，而是需要调用相应的方法。例如，我们使用 person.set_age = 25 来修改 person 对象的年龄值，并且会对该值进行范围检查。而如果我们尝试将年龄设置为负数，会触发 raise ValueError("Invalid age")，提示年龄无效。

【提示，以单个下划线开头的变量名，如 _age，表示这是一个私有变量，不应该被外部直接访问或修改。这只是一种约定，Python并没有像其他语言一样有严格的访问控制。】

附录、进一步了解学习

Python中property属性的用处详解https://www.jb51.net/article/243992.htm

Python特殊属性property原理及使用方法解析https://www.jb51.net/article/197106.htm

Python的特性(property) https://www.cnblogs.com/blackmatrix/p/5646778.html

Python 从attribute到property详解https://cloud.tencent.com/developer/article/1741854文章来源地址https://www.toymoban.com/news/detail-775736.html

到了这里，关于Python中的property介绍（修订）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！