第一部分很简单:

@property
def x(self): ...

和

def x(self): ...
x = property(x)

反过来，这是用于仅使用getter创建属性的简化语法。

下一步是使用setter和delete扩展此属性。这需要适当的方法:

@x.setter
def x(self, value): ...

返回一个新属性，它继承了旧x加上给定setter的所有内容。

X.deleter的工作方式相同。

下面是另一个例子:

##
## Python Properties Example
##
class GetterSetterExample( object ):
    ## Set the default value for x ( we reference it using self.x, set a value using self.x = value )
    __x = None


##
## On Class Initialization - do something... if we want..
##
def __init__( self ):
    ## Set a value to __x through the getter / setter... Since __x is defined above, this doesn't need to be set...
    self.x = 1234

    return None


##
## Define x as a property, ie a getter - All getters should have a default value arg, so I added it - it will not be passed in when setting a value, so you need to set the default here so it will be used..
##
@property
def x( self, _default = None ):
    ## I added an optional default value argument as all getters should have this - set it to the default value you want to return...
    _value = ( self.__x, _default )[ self.__x == None ]

    ## Debugging - so you can see the order the calls are made...
    print( '[ Test Class ] Get x = ' + str( _value ) )

    ## Return the value - we are a getter afterall...
    return _value


##
## Define the setter function for x...
##
@x.setter
def x( self, _value = None ):
    ## Debugging - so you can see the order the calls are made...
    print( '[ Test Class ] Set x = ' + str( _value ) )

    ## This is to show the setter function works.... If the value is above 0, set it to a negative value... otherwise keep it as is ( 0 is the only non-negative number, it can't be negative or positive anyway )
    if ( _value > 0 ):
        self.__x = -_value
    else:
        self.__x = _value


##
## Define the deleter function for x...
##
@x.deleter
def x( self ):
    ## Unload the assignment / data for x
    if ( self.__x != None ):
        del self.__x


##
## To String / Output Function for the class - this will show the property value for each property we add...
##
def __str__( self ):
    ## Output the x property data...
    print( '[ x ] ' + str( self.x ) )


    ## Return a new line - technically we should return a string so it can be printed where we want it, instead of printed early if _data = str( C( ) ) is used....
    return '\n'

##
##
##
_test = GetterSetterExample( )
print( _test )

## For some reason the deleter isn't being called...
del _test.x

基本上，与C(对象)的例子相同，除了我使用x代替…我也没有在__init中初始化-…嗯. .我有，但它可以被删除，因为__x被定义为类....的一部分

输出结果为:

[ Test Class ] Set x = 1234
[ Test Class ] Get x = -1234
[ x ] -1234

如果我注释掉自我。在init中X = 1234，那么输出是:

[ Test Class ] Get x = None
[ x ] None

如果我在getter函数中设置_default = None为_default = 0(因为所有getter都应该有一个默认值，但它不是通过我所看到的属性值传递进来的，所以你可以在这里定义它，它实际上并不坏，因为你可以定义默认一次，并在任何地方使用它)，即:def x(self， _default = 0):

[ Test Class ] Get x = 0
[ x ] 0

注意:getter逻辑的存在只是为了让值被它操纵，以确保它被它操纵——对于print语句也是如此……

Note: I'm used to Lua and being able to dynamically create 10+ helpers when I call a single function and I made something similar for Python without using properties and it works to a degree, but, even though the functions are being created before being used, there are still issues at times with them being called prior to being created which is strange as it isn't coded that way... I prefer the flexibility of Lua meta-tables and the fact I can use actual setters / getters instead of essentially directly accessing a variable... I do like how quickly some things can be built with Python though - for instance gui programs. although one I am designing may not be possible without a lot of additional libraries - if I code it in AutoHotkey I can directly access the dll calls I need, and the same can be done in Java, C#, C++, and more - maybe I haven't found the right thing yet but for that project I may switch from Python..

注意:在这个论坛的代码输出是坏的-我必须在代码的第一部分添加空格，以使其工作-当复制/粘贴时，确保您将所有空格转换为制表符....我在Python中使用制表符，因为在一个10,000行的文件中，空格的文件大小可以是512KB到1MB，制表符的文件大小可以是100到200KB，这相当于文件大小的巨大差异，并减少了处理时间……

标签也可以调整每个用户-所以如果你喜欢2个空间宽度，4,8或任何你可以做的，这意味着它是周到的开发人员与视力缺陷。

注意:类中定义的所有函数都没有缩进，因为论坛软件中的一个bug -如果复制/粘贴，请确保缩进

这一点已经被很多人澄清了，但这是我一直在寻找的一个直接点。 这是我认为从@property装饰器开始很重要的一点。 如:-

class UtilityMixin():
    @property
    def get_config(self):
        return "This is property"

函数“get_config()”的调用将像这样工作。

util = UtilityMixin()
print(util.get_config)

如果您注意到，我没有使用“()”括号来调用函数。这是我搜索@property装饰器的基本内容。这样你就可以像使用变量一样使用函数。

下面是@property如何实现的一个最小示例:

class Thing:
    def __init__(self, my_word):
        self._word = my_word 
    @property
    def word(self):
        return self._word

>>> print( Thing('ok').word )
'ok'

否则，word仍然是一个方法而不是属性。

class Thing:
    def __init__(self, my_word):
        self._word = my_word
    def word(self):
        return self._word

>>> print( Thing('ok').word() )
'ok'

我读了这里所有的帖子，意识到我们可能需要一个现实生活中的例子。为什么要用@property? 因此，考虑一个使用身份验证系统的Flask应用程序。 在models.py中声明一个模型User:

class User(UserMixin, db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(64), unique=True, index=True)
    username = db.Column(db.String(64), unique=True, index=True)
    password_hash = db.Column(db.String(128))

    ...

    @property
    def password(self):
        raise AttributeError('password is not a readable attribute')

    @password.setter
    def password(self, password):
        self.password_hash = generate_password_hash(password)

    def verify_password(self, password):
        return check_password_hash(self.password_hash, password)

在这段代码中，我们通过使用@property来“隐藏”属性密码，当你试图直接访问它时，它会触发AttributeError断言，而我们使用@property。Setter设置实际的实例变量password_hash。

现在在auth/views.py中，我们可以实例化一个User:

...
@auth.route('/register', methods=['GET', 'POST'])
def register():
    form = RegisterForm()
    if form.validate_on_submit():
        user = User(email=form.email.data,
                    username=form.username.data,
                    password=form.password.data)
        db.session.add(user)
        db.session.commit()
...

注意用户填写注册表单时来自注册表单的属性密码。密码确认发生在EqualTo的前端(' Password '， message='密码必须匹配')(如果你想知道，但这是一个与Flask表单相关的不同主题)。

我希望这个例子对大家有用

在下面，我给出了一个例子来阐明@property

考虑一个名为Student的类，它有两个变量:name和class_number，并且希望class_number在1到5的范围内。

现在我将解释两个错误的解决方案，最后是正确的解决方案:

下面的代码是错误的，因为它没有验证class_number(在1到5的范围内)

class Student:
    def __init__(self, name, class_number):
        self.name = name
        self.class_number = class_number

尽管经过验证，但这个解决方案也是错误的:

def validate_class_number(number):
    if 1 <= number <= 5:
        return number
    else:
        raise Exception("class number should be in the range of 1 to 5")

class Student:
    def __init__(self, name, class_number):
        self.name = name
        self.class_number = validate_class_number(class_number)

因为class_number验证只在创建类实例时检查，在创建类实例后不检查(可以将class_number更改为1到5范围之外的数字):

student1 = Student("masoud",5)
student1.class_number = 7

正确的解决方法是:

class Student:
    def __init__(self, name, class_number):
        self.name = name
        self.class_number = class_number
        
    @property
    def class_number(self):
        return self._class_number

    @class_number.setter
    def class_number(self, class_number):
        if not (1 <= class_number <= 5): raise Exception("class number should be in the range of 1 to 5")
        self._class_number = class_number