@property装饰器如何工作？

我想了解内置函数的property工作原理。令我感到困惑的是，property它还可以用作装饰器，但是仅当用作内置函数时才接受参数，而不能用作装饰器。

这个例子来自文档：

class C(object):
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

property的论点是getx，setx，delx和文档字符串。

在下面的代码中property用作装饰器。它的对象是x函数，但是在上面的代码中，参数中没有对象函数的位置。

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

    @x.deleter
    def x(self):
        del self._x

并且，x.setter和x.deleter装饰器是如何创建的？我很困惑。

该property()函数返回一个特殊的描述符对象：

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

正是这种对象有额外的方法：

>>> property().getter
<built-in method getter of property object at 0x10ff07998>
>>> property().setter
<built-in method setter of property object at 0x10ff07940>
>>> property().deleter
<built-in method deleter of property object at 0x10ff07998>

这些充当装饰过。他们返回一个新的属性对象：

>>> property().getter(None)
<property object at 0x10ff079f0>

那是旧对象的副本，但是替换了其中一个功能。

请记住，@decorator语法只是语法糖。语法：

@property
def foo(self): return self._foo

确实与

def foo(self): return self._foo
foo = property(foo)

因此foo该函数被替换property(foo)，我们在上面看到的是一个特殊的对象。然后，当您使用时@foo.setter()，您正在做的就是调用property().setter上面显示的方法，该方法将返回该属性的新副本，但是这次将setter函数替换为装饰方法。

下面的序列还通过使用那些装饰器方法创建了一个全开属性。

首先，我们property仅使用getter 创建一些函数和一个对象：

>>> def getter(self): print('Get!')
... 
>>> def setter(self, value): print('Set to {!r}!'.format(value))
... 
>>> def deleter(self): print('Delete!')
... 
>>> prop = property(getter)
>>> prop.fget is getter
True
>>> prop.fset is None
True
>>> prop.fdel is None
True

接下来，我们使用该.setter()方法添加setter：

>>> prop = prop.setter(setter)
>>> prop.fget is getter
True
>>> prop.fset is setter
True
>>> prop.fdel is None
True

最后，我们使用以下.deleter()方法添加删除器：

>>> prop = prop.deleter(deleter)
>>> prop.fget is getter
True
>>> prop.fset is setter
True
>>> prop.fdel is deleter
True

最后但并非最不重要的一点是，该property对象充当描述符对象，因此它具有和.__get__()，可以.__set__()与.__delete__()实例属性的获取，设置和删除方法挂钩：

>>> class Foo: pass
... 
>>> prop.__get__(Foo(), Foo)
Get!
>>> prop.__set__(Foo(), 'bar')
Set to 'bar'!
>>> prop.__delete__(Foo())
Delete!

Descriptor Howto包括以下类型的纯Python示例实现property()：

class Property:
    "Emulate PyProperty_Type() in Objects/descrobject.c"

    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        self.fget = fget
        self.fset = fset
        self.fdel = fdel
        if doc is None and fget is not None:
            doc = fget.__doc__
        self.__doc__ = doc

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        if self.fget is None:
            raise AttributeError("unreadable attribute")
        return self.fget(obj)

    def __set__(self, obj, value):
        if self.fset is None:
            raise AttributeError("can't set attribute")
        self.fset(obj, value)

    def __delete__(self, obj):
        if self.fdel is None:
            raise AttributeError("can't delete attribute")
        self.fdel(obj)

    def getter(self, fget):
        return type(self)(fget, self.fset, self.fdel, self.__doc__)

    def setter(self, fset):
        return type(self)(self.fget, fset, self.fdel, self.__doc__)

    def deleter(self, fdel):
        return type(self)(self.fget, self.fset, fdel, self.__doc__)

文档说这只是创建只读属性的捷径。所以

@property
def x(self):
    return self._x

相当于

def getx(self):
    return self._x
x = property(getx)

这是如何@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
def x(self): ...

是相同的

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

• 反过来，这是property仅使用getter 创建a的简化语法。

下一步将使用设置器和删除器扩展此属性。并通过适当的方法来实现：

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

返回一个新属性，该属性继承了旧属性x以及给定的setter的所有内容。

x.deleter 以相同的方式工作。

以下内容：

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

    @x.deleter
    def x(self):
        del self._x

是相同的：

class C(object):
    def __init__(self):
        self._x = None

    def _x_get(self):
        return self._x

    def _x_set(self, value):
        self._x = value

    def _x_del(self):
        del self._x

    x = property(_x_get, _x_set, _x_del, 
                    "I'm the 'x' property.")

是相同的：

class C(object):
    def __init__(self):
        self._x = None

    def _x_get(self):
        return self._x

    def _x_set(self, value):
        self._x = value

    def _x_del(self):
        del self._x

    x = property(_x_get, doc="I'm the 'x' property.")
    x = x.setter(_x_set)
    x = x.deleter(_x_del)

是相同的：

class C(object):
    def __init__(self):
        self._x = None

    def _x_get(self):
        return self._x
    x = property(_x_get, doc="I'm the 'x' property.")

    def _x_set(self, value):
        self._x = value
    x = x.setter(_x_set)

    def _x_del(self):
        del self._x
    x = x.deleter(_x_del)

等同于：

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

    @x.deleter
    def x(self):
        del self._x

下面是另一个示例，该示例在@property需要重构代码的情况下如何提供帮助（从此处进行总结）：

假设您创建了一个Money这样的类：

class Money:
    def __init__(self, dollars, cents):
        self.dollars = dollars
        self.cents = cents

并且用户根据他/她使用的此类创建一个库

money = Money(27, 12)

print("I have {} dollar and {} cents.".format(money.dollars, money.cents))
# prints I have 27 dollar and 12 cents.

现在，让我们假设您决定更改您的Money类并摆脱dollars和cents属性，而是决定仅跟踪总分：

class Money:
    def __init__(self, dollars, cents):
        self.total_cents = dollars * 100 + cents

如果上述用户现在尝试像以前一样运行他/她的库

money = Money(27, 12)

print("I have {} dollar and {} cents.".format(money.dollars, money.cents))

这会导致错误

AttributeError：“ Money”对象没有属性“ dollars”

也就是说，现在大家谁依赖于原始的手段Money类将不得不改变所有代码行，其中dollars和cents使用可以是非常痛苦......那么，怎么会这样避免？通过使用@property！

就是那样：

class Money:
    def __init__(self, dollars, cents):
        self.total_cents = dollars * 100 + cents

    # Getter and setter for dollars...
    @property
    def dollars(self):
        return self.total_cents // 100

    @dollars.setter
    def dollars(self, new_dollars):
        self.total_cents = 100 * new_dollars + self.cents

    # And the getter and setter for cents.
    @property
    def cents(self):
        return self.total_cents % 100

    @cents.setter
    def cents(self, new_cents):
        self.total_cents = 100 * self.dollars + new_cents

现在我们从图书馆打电话时

money = Money(27, 12)

print("I have {} dollar and {} cents.".format(money.dollars, money.cents))
# prints I have 27 dollar and 12 cents.

它会按预期工作，我们不必在库中更改任何代码！实际上，我们甚至不必知道我们依赖的库已更改。

也setter可以正常工作：

money.dollars += 2
print("I have {} dollar and {} cents.".format(money.dollars, money.cents))
# prints I have 29 dollar and 12 cents.

money.cents += 10
print("I have {} dollar and {} cents.".format(money.dollars, money.cents))
# prints I have 29 dollar and 22 cents.

您也@property可以在抽象类中使用。我在这里举一个最小的例子。

我在这里阅读了所有文章，并意识到我们可能需要一个真实的例子。为什么实际上我们有@property？因此，考虑使用身份验证系统的Flask应用。您在中声明模型用户models.py：

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)

在这段代码中，我们password使用了“隐藏”属性，当您尝试直接访问它时@property，该属性会触发AttributeError断言，而我们使用@ property.setter来设置实际的实例变量password_hash。

现在，auth/views.py我们可以实例化一个用户：

...
@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()
...

password用户填写表单时，该属性来自注册表单。密码确认发生在前端EqualTo('password', message='Passwords must match')（如果您想知道，但这是与Flask表单相关的其他主题）。

我希望这个例子会有用

那里的很多人都清楚了这一点，但这是我一直在寻找的直接点。我觉得从@property装饰器开始很重要。例如：-

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

函数“ get_config（）”的调用将像这样工作。

util = UtilityMixin()
print(util.get_config)

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

让我们从Python装饰器开始。

Python装饰器是一个函数，可以帮助向已经定义的函数添加一些其他功能。

在Python中，一切都是对象。Python中的函数是一流的对象，这意味着它们可以被变量引用，添加到列表中，作为参数传递给另一个函数等。

考虑以下代码片段。

def decorator_func(fun):
    def wrapper_func():
        print("Wrapper function started")
        fun()
        print("Given function decorated")
        # Wrapper function add something to the passed function and decorator 
        # returns the wrapper function
    return wrapper_func

def say_bye():
    print("bye!!")

say_bye = decorator_func(say_bye)
say_bye()

# Output:
#  Wrapper function started
#  bye
#  Given function decorated

在这里，我们可以说装饰器函数修改了我们的say_hello函数，并在其中添加了一些额外的代码行。

装饰器的Python语法

def decorator_func(fun):
    def wrapper_func():
        print("Wrapper function started")
        fun()
        print("Given function decorated")
        # Wrapper function add something to the passed function and decorator 
        # returns the wrapper function
    return wrapper_func

@decorator_func
def say_bye():
    print("bye!!")

say_bye()

最后，让我们结束一个案例案例，但在此之前，让我们先讨论一些糟糕的原则。

在许多面向对象的编程语言中都使用getter和setter来确保数据封装的原理（被视为将数据与对这些数据进行操作的方法捆绑在一起）。

这些方法当然是用于获取数据的吸气剂和用于更改数据的设置器。

根据此原理，将一个类的属性设为私有，以隐藏它们并保护它们免受其他代码的侵害。

是的，@ property基本上是使用getter和setter的pythonic方法。

Python有一个伟大的概念，称为属性，它使面向对象的程序员的生活变得更加简单。

让我们假设您决定创建一个可以存储摄氏温度的课程。

class Celsius:
def __init__(self, temperature = 0):
    self.set_temperature(temperature)

def to_fahrenheit(self):
    return (self.get_temperature() * 1.8) + 32

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

重构代码，这是我们可以通过属性实现的方法。

在Python中，property（）是一个内置函数，可创建并返回属性对象。

属性对象具有三种方法，getter（），setter（）和delete（）。

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)

这里，

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)

注意事项：

• get_temperature仍然是属性而不是方法。

现在，您可以通过写入来获取温度值。

C = Celsius()
C.temperature
# instead of writing C.get_temperature()

我们可以进一步继续，不要定义名称get_temperature和set_temperature，因为它们是不必要的，并污染类名称空间。

解决上述问题的pythonic方法是使用@property。

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

注意事项-

1. 用于获取值的方法以“ @property”修饰。
2. 用作设置器的方法用“ @ temperature.setter”修饰，如果该函数被称为“ x”，则必须用“ @ x.setter”修饰。
3. 我们用相同的名称和不同数量的参数“ def temperature（self）”和“ def temperature（self，x）”编写了“两个”方法。

如您所见，该代码绝对不太优雅。

现在，让我们谈谈一个现实的实用场景。

假设您设计的类如下：

class OurClass:

    def __init__(self, a):
        self.x = a


y = OurClass(10)
print(y.x)

现在，让我们进一步假设我们的类在客户中很受欢迎，并且他们开始在程序中使用它。他们对对象进行了各种分配。

有朝一日，一个值得信赖的客户来找我们，建议“ x”的值必须在0到1000之间，这确实是一个可怕的情况！

由于属性，这很容易：我们创建属性版本“ x”。

class OurClass:

    def __init__(self,x):
        self.x = x

    @property
    def x(self):
        return self.__x

    @x.setter
    def x(self, x):
        if x < 0:
            self.__x = 0
        elif x > 1000:
            self.__x = 1000
        else:
            self.__x = x

很好，不是吗：您可以从可以想象到的最简单的实现开始，并且以后可以随意迁移到属性版本，而不必更改接口！因此，属性不仅仅是吸气剂和塞特剂的替代品！

您可以在此处检查此实现

property是@property装饰器背后的一类。

您可以随时检查以下内容：

print(property) #<class 'property'>

我改写了示例，help(property)以显示@property语法

class C:
    def __init__(self):
        self._x=None

    @property 
    def x(self):
        return self._x

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

    @x.deleter
    def x(self):
        del self._x

c = C()
c.x="a"
print(c.x)

在功能上与property()语法相同：

class C:
    def __init__(self):
        self._x=None

    def g(self):
        return self._x

    def s(self, v):
        self._x = v

    def d(self):
        del self._x

    prop = property(g,s,d)

c = C()
c.x="a"
print(c.x)

如您所见，我们使用该属性的方式没有什么不同。

为了回答这个问题，@property装饰器是通过property类实现的。

因此，问题是要对该property类进行一些解释。这行：

prop = property(g,s,d)

是初始化。我们可以这样重写它：

prop = property(fget=g,fset=s,fdel=d)

的含义fget，fset和fdel：

 |    fget
 |      function to be used for getting an attribute value
 |    fset
 |      function to be used for setting an attribute value
 |    fdel
 |      function to be used for del'ing an attribute
 |    doc
 |      docstring

下图显示了我们从类中获得的三胞胎property：

__get__，__set__和__delete__那里被覆盖。这是Python中描述符模式的实现。

通常，描述符是具有“绑定行为”的对象属性，其属性访问已被描述符协议中的方法所覆盖。

我们还可以使用属性setter，getter和deleter方法的功能绑定属性。检查下一个示例。s2该类的方法C会将属性设置为double。

class C:
    def __init__(self):
        self._x=None

    def g(self):
        return self._x

    def s(self, x):
        self._x = x

    def d(self):
        del self._x

    def s2(self,x):
        self._x=x+x


    x=property(g)
    x=x.setter(s)
    x=x.deleter(d)      


c = C()
c.x="a"
print(c.x) # outputs "a"

C.x=property(C.g, C.s2)
C.x=C.x.deleter(C.d)
c2 = C()
c2.x="a"
print(c2.x) # outputs "aa"

可以通过两种方式声明属性。

• 为属性创建getter，setter方法，然后将它们作为参数传递给属性函数
• 使用@property装饰器。

您可以看一下我编写的有关python属性的一些示例。

最好的解释可以在这里找到：Python @Property Explained –如何使用和何时使用？（完整示例）Selva Prabhakaran | 发表于十一月5，2018

它帮助我理解了为什么不仅如此。

https://www.machinelearningplus.com/python/python-property/

这是另一个示例：

##
## 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（object）示例相同，只是我改用x ...我也不在__init中初始化 -...很好..我可以，但是可以删除它，因为__x被定义为一部分班上的...

输出为：

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

如果我将init的self.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语句相同...

注意：我习惯了Lua，并且在调用单个函数时能够动态创建10个以上的助手，并且我在不使用属性的情况下为Python做了类似的事情，并且在一定程度上可以正常工作，但是，即使这些函数是在之前创建的被使用时，在创建它们之前有时仍会调用它们，这很奇怪，因为它不是以这种方式编码的。。。我更喜欢Lua元表的灵活性，而且我可以使用实际的setter / getters。而不是本质上直接访问变量...我确实喜欢用Python可以快速构建某些东西-例如gui程序。尽管没有大量其他库，虽然我正在设计的库可能无法实现-如果我在AutoHotkey中对其进行编码，则可以直接访问所需的dll调用，并且可以在Java，C＃，C ++，

注意：此论坛中的代码输出已损坏-我必须在代码的第一部分中添加空格才能使其正常工作-复制/粘贴时，请确保将所有空格都转换为制表符...。我在Python中使用制表符，因为在10,000行的文件大小可以为512KB至1MB（带空格）和100至200KB（带制表符），这在文件大小和减少处理时间方面存在巨大差异。

还可以按用户调整选项卡-因此，如果您希望使用2个空格宽度，4个，8个空格或您可以做的任何事情，这意味着它对于有视力缺陷的开发人员来说是体贴的。

注意：由于论坛软件中的错误，该类中定义的所有功能均未正确缩进-如果复制/粘贴，请确保将其缩进

一句话：对我来说，对于Python 2.x，@property当我不继承自object：

class A():
    pass

但在以下情况下有效：

class A(object):
    pass

对于Python 3，始终有效。