Понимание __get__ и __set___ дескрипторов Python
Переведено автоматически
Ответ 1
Ответ 2
Ответ 3
Ответ 4
Прежде чем углубляться в детали дескрипторов, может быть важно знать, как работает поиск атрибутов в Python. Это предполагает, что у класса нет метакласса и что он использует реализацию по умолчанию __getattribute__ (оба могут использоваться для "настройки" поведения).
Лучшая иллюстрация поиска атрибутов (в Python 3.x или для классов нового стиля в Python 2.x) в данном случае взята из Понимания метаклассов Python (codelog ionel). Изображение использует : вместо "поиска по не настраиваемым атрибутам".
Это представляет собой поиск атрибута foobar в instance из Class:
Здесь важны два условия:
- Если в классе
instanceесть запись для имени атрибута, и у него есть__get__и__set__. - Если у
instanceесть нет записи для имени атрибута, но у класса есть один , и он есть__get__.
Вот тут-то и пригодятся дескрипторы:
- Дескрипторы данных, которые содержат оба
__get__и__set__. - Дескрипторы, не содержащие данных, которые имеют только
__get__.
В обоих случаях возвращаемое значение проходит через __get__ вызывается с экземпляром в качестве первого аргумента и классом в качестве второго аргумента.
Поиск по атрибутам класса еще сложнее (см., Например, Поиск по атрибутам класса (в вышеупомянутом блоге)).
Давайте перейдем к вашим конкретным вопросам:
Зачем мне нужен класс descriptor?
В большинстве случаев вам не нужно писать классы дескрипторов! Однако вы, вероятно, самый обычный конечный пользователь. Например, функции. Функции являются дескрипторами, вот как функции могут использоваться в качестве методов с self неявно передаваемыми в качестве первого аргумента.
def test_function(self):
return self
class TestClass(object):
def test_method(self):
...
Если вы посмотрите test_method на экземпляр, вы получите обратно "связанный метод":
>>> instance = TestClass()
>>> instance.test_method
<bound method TestClass.test_method of <__main__.TestClass object at ...>>
Аналогичным образом вы также можете привязать функцию, вызвав ее __get__ метод вручную (на самом деле не рекомендуется, просто для иллюстрации):
>>> test_function.__get__(instance, TestClass)
<bound method test_function of <__main__.TestClass object at ...>>
Вы даже можете вызвать этот "самосвязывающийся метод":
>>> test_function.__get__(instance, TestClass)()
<__main__.TestClass at ...>
Обратите внимание, что я не предоставил никаких аргументов, и функция вернула экземпляр, который я привязал!
Функции - это не дескрипторы данных!
Некоторые встроенные примеры дескриптора данных были бы property. Пренебрегая getter, setter и deleter property дескриптором is (из руководства по дескриптору "Свойства"):
class Property(object):
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)
Поскольку это дескриптор данных, он вызывается всякий раз, когда вы ищете "имя" property и он просто делегирует функции, оформленные @property, @name.setter и @name.deleter (если они присутствуют).
В стандартной библиотеке есть несколько других дескрипторов, например staticmethod, classmethod.
Суть дескрипторов проста (хотя они вам редко нужны): абстрактный общий код для доступа к атрибутам. property это абстракция для доступа к переменной экземпляра, function предоставляет абстракцию для методов, staticmethod предоставляет абстракцию для методов, которым не нужен доступ к экземпляру, и classmethod предоставляет абстракцию для методов, которым нужен доступ к классу, а не к экземпляру (это немного упрощено).
Другим примером может быть свойство класса.
Одним забавным примером (с использованием __set_name__ из Python 3.6) также может быть свойство, допускающее только определенный тип:
class TypedProperty(object):
__slots__ = ('_name', '_type')
def __init__(self, typ):
self._type = typ
def __get__(self, instance, klass=None):
if instance is None:
return self
return instance.__dict__[self._name]
def __set__(self, instance, value):
if not isinstance(value, self._type):
raise TypeError(f"Expected class {self._type}, got {type(value)}")
instance.__dict__[self._name] = value
def __delete__(self, instance):
del instance.__dict__[self._name]
def __set_name__(self, klass, name):
self._name = name
Затем вы можете использовать дескриптор в классе:
class Test(object):
int_prop = TypedProperty(int)
И небольшая игра с этим:
>>> t = Test()
>>> t.int_prop = 10
>>> t.int_prop
10
>>> t.int_prop = 20.0
TypeError: Expected class <class 'int'>, got <class 'float'>
Или "ленивое свойство":
class LazyProperty(object):
__slots__ = ('_fget', '_name')
def __init__(self, fget):
self._fget = fget
def __get__(self, instance, klass=None):
if instance is None:
return self
try:
return instance.__dict__[self._name]
except KeyError:
value = self._fget(instance)
instance.__dict__[self._name] = value
return value
def __set_name__(self, klass, name):
self._name = name
class Test(object):
@LazyProperty
def lazy(self):
print('calculating')
return 10
>>> t = Test()
>>> t.lazy
calculating
10
>>> t.lazy
10
Это случаи, когда перенос логики в общий дескриптор может иметь смысл, однако их также можно решить (но, возможно, с повторением некоторого кода) другими средствами.
Что здесь
instanceиowner? (в__get__). Для чего нужны эти параметры?
Это зависит от того, как вы ищете атрибут. Если вы ищете атрибут в экземпляре, то:
- второй аргумент - это экземпляр, в котором вы ищете атрибут
- третий аргумент - это класс экземпляра
В случае, если вы ищете атрибут в классе (предполагая, что дескриптор определен в классе):
- второй аргумент
None - третий аргумент - это класс, в котором вы ищете атрибут
Итак, в основном третий аргумент необходим, если вы хотите настроить поведение при выполнении поиска на уровне класса (потому что instance есть None).
Как бы я вызвал / использовал этот пример?
Ваш пример в основном представляет собой свойство, которое допускает только значения, которые могут быть преобразованы в float и которое является общим для всех экземпляров класса (и в классе - хотя в классе можно использовать доступ только "на чтение", иначе вы заменили бы экземпляр дескриптора):
>>> t1 = Temperature()
>>> t2 = Temperature()
>>> t1.celsius = 20 # setting it on one instance
>>> t2.celsius # looking it up on another instance
20.0
>>> Temperature.celsius # looking it up on the class
20.0
Вот почему дескрипторы обычно используют второй аргумент (instance) для хранения значения, чтобы избежать его совместного использования. Однако в некоторых случаях может потребоваться совместное использование значения между экземплярами (хотя на данный момент я не могу придумать сценарий). Однако это практически не имеет смысла для свойства celsius в температурном классе... за исключением, может быть, чисто академического упражнения.