Как работает декоратор @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 и строка doc.

В приведенном ниже коде 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? Я смущен.

691
задан ashim 26 июня '13 в 23:47
источник поделиться
11 ответов

Функция 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)

so foo функция заменяется на property(foo), что мы видели выше, это специальный объект. Затем, когда вы используете @foo.setter(), то, что вы делаете, это вызов метода property().setter, который я показал вам выше, который возвращает новую копию свойства, но на этот раз с заменой функции setter на декорированный метод.

Следующая последовательность также создает свойство full-on, используя эти методы декоратора.

Сначала мы создаем некоторые функции и объект 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() для добавления сеттера:

>>> 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(object): pass
... 
>>> prop.__get__(Foo(), Foo)
Get!
>>> prop.__set__(Foo(), 'bar')
Set to 'bar'!
>>> prop.__delete__(Foo())
Delete!

В дескрипторе Howto используется чистая реализация образца python типа property():

class Property(object):
    "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__)
762
ответ дан Martijn Pieters 26 июня '13 в 23:54
источник поделиться

Документация говорит, что это просто ярлык для создания свойств readonly. Так

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

эквивалентно

def getx(self):
    return self._x
x = property(getx)
108
ответ дан J0HN 26 июня '13 в 23:52
источник поделиться

Первая часть проста:

@property
def x(self): ...

совпадает с

def x(self): ...
x = property(x)
  • который, в свою очередь, является упрощенным синтаксисом для создания property только с помощью getter.

Следующим шагом будет расширение этого свойства с помощью setter и deleter. И это происходит с помощью соответствующих методов:

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

возвращает новое свойство, которое наследует все от старого x плюс заданный сеттер.

x.deleter работает одинаково.

64
ответ дан glglgl 26 июня '13 в 23:53
источник поделиться

Вот минимальный пример того, как @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'
55
ответ дан AlexG 15 февр. '17 в 3:46
источник поделиться

Это следующее:

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
25
ответ дан Bill Moore 24 мая '17 в 21:38
источник поделиться

Я прочитал все сообщения здесь и понял, что нам может понадобиться пример реальной жизни. Почему, собственно, у нас есть @property? Итак, рассмотрите приложение Flask, в котором вы используете систему аутентификации. Вы объявляете модель User в 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') (в случае, если вам интересно, но это разные темы, связанные с флягой).

Я надеюсь, что этот пример будет полезен

7
ответ дан Leo Skhrnkv 23 марта '18 в 17:47
источник поделиться

Начните с декораторов Python.

Декоратор 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()

Позвольте Заключить все, чем с ситуационным сценарием, но прежде, чем позволить, поговорим о некоторых проблемах.

Getters и seters используются во многих объектно-ориентированных языках программирования для обеспечения принципа инкапсуляции данных (рассматривается как совокупность данных с методами, которые работают с этими данными).

Этими методами, конечно же, являются getter для извлечения данных и установщика для изменения данных.

Согласно этому принципу атрибуты класса становятся закрытыми, чтобы скрыть и защитить их от другого кода.

Yup, @property - это в основном 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 свойство() является встроенной функцией, которая создает и возвращает объект свойства.

Объект свойства имеет три метода: 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, поскольку они не нужны и загрязняют пространство имен классов.

Питонический способ справиться с вышеуказанной проблемой - использовать @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)

Теперь давайте предположим, что наш класс стал популярным среди клиентов, и они начали использовать его в своих программах. Они выполняли всевозможные назначения объекту.

И один роковой день, доверенный клиент пришел к нам и предположил, что "х" должно быть значением от 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

Это здорово, не так ли? Вы можете начать с простейшей реализации, которую можно себе представить, и вы можете позже перейти к версии свойств без необходимости менять интерфейс! Таким образом, свойства - это не просто замена для геттеров и сеттеров!

Вы можете проверить эту реализацию здесь

1
ответ дан Divyanshu Rawat 17 сент. '18 в 3:01
источник поделиться

Ниже приведен еще один пример того, как @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 и 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.
0
ответ дан Cleb 23 сент. '18 в 14:58
источник поделиться

Свойство может быть объявлено двумя способами.

  • Создание методов getter, setter для атрибута, а затем передача их в качестве аргумента функции свойство
  • Использование декоратора @property.

Вы можете взглянуть на несколько примеров, которые я написал о свойствах в python.

0
ответ дан nvd 13 июля '17 в 12:20
источник поделиться

Вот еще один пример:

##
## 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

и если я прокомментирую self.x = 1234 в init, тогда вывод будет следующим:

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

и если я устанавливаю _default = None в _default = 0 в функции getter (поскольку все получатели должны иметь значение по умолчанию, но оно не передается значениями свойств из того, что я видел, поэтому вы можете определить его здесь и это на самом деле не плохо, потому что вы можете определить значение по умолчанию один раз и использовать его везде) ie: def x (self, _default = 0):

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

Примечание. Логика getter состоит только в том, чтобы управлять этим значением, чтобы гарантировать, что с ним манипулирует - то же самое для операторов печати...

Примечание. Я привык к Lua и могу динамически создавать помощники 10+, когда я вызываю одну функцию, и я сделал что-то подобное для Python без использования свойств, и это работает в определенной степени, но, несмотря на то, что функции создаются перед тем, как их использовать, по-прежнему возникают проблемы, когда они вызываются до создания, что странно, поскольку оно не кодируется таким образом... Я предпочитаю гибкость мета-таблиц Lua и факт, что я могу использовать фактические сеттеры /getters вместо того, чтобы напрямую обращаться к переменной... Мне нравится, как быстро некоторые вещи могут быть созданы с Python, хотя, например, в программах gui. хотя я проектирую, возможно, не удастся без большого количества дополнительных библиотек - если я его закодирую в AutoHotkey, я могу напрямую обращаться к вызовам DLL, которые мне нужны, и то же самое можно сделать в Java, С#, C++ и других - возможно, я еще не нашел нужную вещь, но для этого проекта я могу переключиться с Python..

Примечание: вывод кода на этом форуме нарушен - мне пришлось добавить пробелы в первую часть кода для его работы - когда копирование/вставка гарантируют, что вы конвертируете все пробелы в вкладки.... Я использую вкладки для Python, потому что в файл, который составляет 10 000 строк, размер файла может быть от 512 КБ до 1 МБ с пробелами и от 100 до 200 КБ с вкладками, которые приравниваются к огромной разнице в размере файла и сокращению времени обработки...

Вкладки можно также настраивать для каждого пользователя - поэтому, если вы предпочитаете ширину 2 пробела, 4, 8 или все, что вы можете это сделать, это задумывается для разработчиков с дефицитом зрения.

Примечание. Все функции, определенные в классе, не имеют отступов должным образом из-за ошибки в программном обеспечении форума - убедитесь, что вы отступали, если вы копируете/вставляете

0
ответ дан Acecool 07 авг. '18 в 14:08
источник поделиться

@property - это декоратор, который преобразует метод в свойство (также называемый атрибутом).

-1
ответ дан Yumi Tada 05 нояб. '17 в 7:45
источник поделиться

Другие вопросы по меткам