Что такое дескриптор python
Перейти к содержимому

Что такое дескриптор python

  • автор:

Руководство к дескрипторам

В этой статье я расскажу о том, что такое дескрипторы, о протоколе дескрипторов, покажу как вызываются дескрипторы. Опишу создание собственных и исследую несколько встроенных дескрипторов, включая функции, свойства, статические методы и методы класса. С помощью простого приложения покажу, как работает каждый из них, приведу эквиваленты внутренней реализации работы дескрипторов кодом на чистом питоне.

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

Введение и определения

Если говорить в общем, то дескриптор — это атрибут объекта со связанным поведением (англ. binding behavior), т.е. такой, чьё поведение при доступе переопределяется методами протокола дескриптора. Эти методы: __get__ , __set__ и __delete__ . Если хотя бы один из этих методов определён для объекта, то он становится дескриптором.

Стандартное поведение при доступе к атрибутам — это получение, установка и удаление атрибута из словаря объекта. Например, a.x имеет такую цепочку поиска атрибута: a.__dict__[‘x’] , затем в type(a).__dict__[‘x’] , и далее по базовым классам type(a) не включая метаклассы. Если же искомое значение — это объект, в котором есть хотя бы один из методов, определяющих дескриптор, то питон может изменить стандартную цепочку поиска и вызвать один из методов дескриптора. Как и когда это произойдёт зависит от того, какие методы дескриптора определены для объекта. Дескрипторы вызываются только для объектов или классов нового стиля (класс является таким, если наследует от object или type ).

Дескрипторы — это мощный протокол с широкой областью применения. Они являются тем механизмом, который стоит за свойствами, методами, статическими методами, методами класса и вызовом super() . Внутри самого питона с их помощью реализуются классы нового стиля, которые были представлены в версии 2.2. Дескрипторы упрощают понимание нижележащего кода на C, а также представляют гибкий набор новых инструментов для любых программ на питоне.

Протокол дескрипторов
descr.__get__(self, obj, type=None) --> значение descr.__set__(self, obj, value) --> None descr.__delete__(self, obj) --> None 

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

Если объект определяет сразу и __get__ , и __set__ , то он считается дескриптором данных (англ. data descriptor). Дескрипторы, которые определили только __get__ называются дескрипторами не данных (англ. non-data descriptors). Их называются так, потому что они используют для методов, но другие способы их применения также возможны.

Дескрипторы данных и не данных отличаются в том, как будет изменено поведение поиска, если в словаре объекта уже есть запись с таким же именем как у дескриптора. Если попадается дескриптор данных, то он вызывается раньше, чем запись из словаря объекта. Если в такой же ситуации окажется дескриптор не данных, то запись из словаря объекта имеет преимущество перед этим дескриптором.

Чтобы создать дескриптор данных только для чтения, определите и __get__ , и __set__ , и сделайте так, чтобы __set__ выбрасывал исключение AttributeError . Определения метода __set__ и выбрасывания исключения достаточно, чтобы этот дескриптор считался дескриптором данных.

Вызов дескрипторов

Дескриптор можно вызвать напрямую через его метод. Например, d.__get__(obj) .

Однако, наиболее частый вариант вызова дескриптора — это автоматический вызов во время доступа к атрибуту. Например, obj.d ищет d в словаре obj . Если d определяет метод __get__ , то будет вызван d.__get__(obj) . Вызов будет сделан согласно правилам, описанным ниже.

Детали вызова различаются от того, чем является obj — объектом или классом. В любом случае, дескрипторы работают только для объектов и классов нового стиля. Класс является классом нового стиля, если он является потомком object .

Для объектов алгоритм реализуется с помощью object.__getattribute__ , который преобразует запись b.x в type(b).__dict__[‘x’].__get__(b, type(b)) . Реализация работает через цепочку предшественников, в которой дескрипторы данных имеют приоритет перед переменными объекта, переменные объекта имеют приоритет перед дескрипторами не данных, и самый низкий приоритет у метода __getattr__ , если он определён. Полную реализацию на языке C можно найти в PyObject_GenericGetAttr() в файле Objects/object.c .

Для классов алгоритм реализуется с помощью type.__getattribute__ , который преобразует запись B.x в B.__dict__[‘x’].__get__(None, B) . На чистом питоне это выглядит так:

def __getattribute__(self, key): "Эмуляция type_getattro() в Objects/typeobject.c" v = object.__getattribute__(self, key) if hasattr(v, '__get__'): return v.__get__(None, self) return v 
  • дескрипторы вызываются с помощью метода __getattribute__
  • переопределение __getattribute__ прекратит автоматический вызов дескрипторов
  • __getattribute__ доступен только внутри классов и объектов нового стиля
  • object.__getattribute__ и type.__getattribute__ делают разные вызовы к __get__
  • дескрипторы данных всегда имеют преимущество перед переменными объекта
  • дескрипторы не данных могут потерять преимущество из-за переменных объекта

Примечание: в питоне 2.2, super(B, obj).m() вызывал __get__ только если m был дескриптором данных. В питоне 2.3, дескрипторы не данных тоже вызываются, за исключением тех случаев, когда используются классы старого стиля. Детали реализации можно найти в super_getattro() в файле Objects/typeobject.c , а эквивалент на чистом питоне можно найти в пособии от Guido.

Детали выше описывают, что алгоритм вызова дескрипторов реализуется с помощью метода __getattribute__() для object , type и super . Классы наследуют этот алгоритм, когда они наследуют от object или если у них есть метакласс, реализующий подобную функциональность. Таким образом, классы могут отключить вызов дескрипторов, если переопределят __getattribute__() .

Пример дескриптора

Следующий код создаёт класс, чьи объекты являются дескрипторам данных и всё, что они делают — это печатают сообщение на каждый вызов get или set . Переопределение __getattribute__ — это альтернативный подход, с помощью которого мы могли бы сделать это для каждого атрибута. Но если мы хотим наблюдать только за отдельными атрибутами, то это проще сделать с помощью дескриптора.

class RevealAccess(object): """Дескриптор данных, который устанавливает и возвращает значения, и печатает сообщение о том, что к атрибуту был доступ. """ def __init__(self, initval=None, name='var'): self.val = initval self.name = name def __get__(self, obj, objtype): print 'Получаю', self.name return self.val def __set__(self, obj, val): print 'Обновляю' , self.name self.val = val >>> class MyClass(object): x = RevealAccess(10, 'var "x"') y = 5 >>> m = MyClass() >>> m.x Получаю var "x" 10 >>> m.x = 20 Обновляю var "x" >>> m.x Получаю var "x" 20 >>> m.y 5 

Этот простой протокол предоставляет просто увлекательные возможности. Некоторые из них настолько часто используются, что были объединены в отдельные функции. Свойства, связанные и несвязанные методы, статические методы и методы класса — все они основаны на этом протоколе.

Свойства

Вызова property() достаточно, чтобы создать дескриптор данных, который вызывает нужные функции во время доступа к атрибуту. Вот его сигнатура:

property(fget=None, fset=None, fdel=None, doc=None) --> атрибут, реализующий свойства 

В документации показано типичное использование property() для создания управляемого атрибута x :

class C(object): def getx(self): return self.__x def setx(self, value): self.__x = value def delx(self): del self.__x x = property(getx, setx, delx, "Я свойство 'x'.") 

Вот эквивалент property на чистом питоне, чтобы было понятно как реализовано property() с помощью протокола дескрипторов:

class Property(object): "Эмуляция PyProperty_Type() в Objects/descrobject.c" def __init__(self, fget=None, fset=None, fdel=None, doc=None): self.fget = fget self.fset = fset self.fdel = fdel self.__doc__ = doc def __get__(self, obj, objtype=None): if obj is None: return self if self.fget is None: raise AttributeError, "нечитаемый атрибут" return self.fget(obj) def __set__(self, obj, value): if self.fset is None: raise AttributeError, "не могу установить атрибут" self.fset(obj, value) def __delete__(self, obj): if self.fdel is None: raise AttributeError, "не могу удалить атрибут" self.fdel(obj) 

Встроенная реализация property() может помочь, когда существовал интерфейс доступа к атрибуту и произошли какие-то изменения, в результате которых понадобилось вмешательство метода.

Например, класс электронной таблицы может давать доступ к значению ячейки через Cell(‘b10’).value . В результате последующих изменений в программе, понадобилось сделать так, чтобы это значение пересчитывалось при каждом доступе к ячейке, однако программист не хочет менять клиентский код, который обращается к атрибуту напрямую. Эту проблему можно решить, если обернуть атрибут value с помощью дескриптора данных, который будет создан с помощью property() :

class Cell(object): . . . def getvalue(self, obj): "Пересчитываем ячейку прежде чем вернуть значение" self.recalc() return obj._value value = property(getvalue) 
Функции и методы

В питоне все объектно-ориентированные возможности реализованы с помощью функционального подхода. Это сделано совсем незаметно с помощью дескрипторов не данных.

Словари классов хранят методы в виде функций. При определении класса, методы записываются с помощью def и lambda — стандартных инструментов для создания функций. Единственное отличие этих функций от обычных в том, что первый аргумент зарезервирован под экземпляр объекта. Этот аргумент обычно называется self , но может называться this или любым другим словом, которым можно называть переменные.

Для того, чтобы поддерживать вызов методов, функции включают в себя метод __get__ , который автоматически делает их дескрипторами не данных при поиске атрибутов. Функции возвращают связанные или не связанные методы, в зависимости от того, через что был вызван этот дескриптор.

class Function(object): . . . def __get__(self, obj, objtype=None): "Симуляция func_descr_get() в Objects/funcobject.c" return types.MethodType(self, obj, objtype) 

С помощью интерпретатора мы можем увидеть как на самом деле работает дескриптор функции:

>>> class D(object): def f(self, x): return x >>> d = D() >>> D.__dict__['f'] # Внутренне хранится как функция >>> D.f # Доступ через класс возвращает несвязанный метод >>> d.f # Доступ через экземпляр объекта возвращает связанный метод > 

Вывод интерпретатора подсказывает нам, что связанные и несвязанные методы — это два разных типа. Даже если они могли бы быть реализованы таким образом, на самом деле, реализация PyMethod_Type в файле Objects/classobject.c содержит единственный объект с двумя различными отображениями, которые зависят только от того, есть ли в поле im_self значение или там содержится NULL (C эквивалент значения None ).

Таким образом, эффект вызова метода зависит от поля im_self . Если оно установлено (т.е. метод связан), то оригинальная функция (хранится в поле im_func ) вызывается, как мы и ожидаем, с первым аргументом, установленным в значение экземпляра объекта. Если же она не связана, то все аргументы передаются без изменения оригинальной функции. Настоящая C реализация instancemethod_call() чуть более сложная, потому что включает в себя некоторые проверки типов и тому подобное.

Статические методы и методы класса

Дескрипторы не данных предоставляют простой механизм для различных вариантов привязки функций к методам.

Повторим ещё раз. Функции имеют метод __get__ , с помощью которых они становятся методами, во время поиска атрибутов и автоматического вызова дескрипторов. Дескрипторы не данных преобразуют вызов obj.f(*args) в вызов f(obj, *args) , а вызов klass.f(*args) становится f(*args) .

В этой таблице показано связывание и два наиболее популярных варианта:

Преобразование Вызвана через объект Вызвана через класс
Дескриптор функция f(obj, *args) f(*args)
staticmethod f(*args) f(*args)
classmethod f(type(obj), *args) f(klass, *args)

Статические методы возвращают функцию без изменений. Вызовы c.f или C.f эквиваленты вызовам object.__getattribute__(c, «f») или object.__getattribute__(C, «f») . Как результат, функция одинаково доступна как из объекта, так и из класса.

Хорошими кандидатами для статических методов являются методы, которым не нужна ссылка на переменную self .

Например, пакет для статистики может включать класс для экспериментальных данных. Класс предоставляет обычные методы для расчёта среднего, ожидания, медианы и другой статистики, которая зависит от данных. Однако, там могут быть и другие функции, которые концептуально связаны, но не зависят от данных. Например, erf(x) это простая функция для преобразования, которая нужна в статистике, но не зависит от конкретного набора данных в этом классе. Она может быть вызвана и из объекта, и из класса: s.erf(1.5) —> 0.9332 или Sample.erf(1.5) —> 0.9332 .

Так как staticmethod() возвращает функцию без изменений, то этот пример не удивляет:

>>> class E(object): def f(x): print x f = staticmethod(f) >>> print E.f(3) 3 >>> print E().f(3) 3 

Если использовать протокол дескриптора не данных, то на чистом питоне staticmethod() выглядел бы так:

class StaticMethod(object): "Эмуляция PyStaticMethod_Type() в Objects/funcobject.c" def __init__(self, f): self.f = f def __get__(self, obj, objtype=None): return self.f 

В отличие от статических методов, методы класса подставляют в начало вызова функции ссылку на класс. Формат вызова всегда один и тот же, и не зависит от того, вызываем мы метод через объект или через класс.

>>> class E(object): def f(klass, x): return klass.__name__, x f = classmethod(f) >>> print E.f(3) ('E', 3) >>> print E().f(3) ('E', 3) 

Это поведение удобно, когда нашей функции всегда нужна ссылка на класс и ей не нужны данные. Один из способов использования classmethod() — это создание альтернативных конструкторов класса. В питоне 2.3, метод класса dict.fromkeys() создаёт новый словарь из списка ключей. Эквивалент на чистом питоне будет таким:

class Dict: . . . def fromkeys(klass, iterable, value=None): "Эмуляция dict_fromkeys() в Objects/dictobject.c" d = klass() for key in iterable: d[key] = value return d fromkeys = classmethod(fromkeys) 

Теперь новый словарь уникальных ключей можно создать таким образом:

>>> Dict.fromkeys('abracadabra')

Если использовать протокол дескриптора не данных, то на чистом питоне classmethod() выглядел бы так:

class ClassMethod(object): "Эмуляция PyClassMethod_Type() в Objects/funcobject.c" def __init__(self, f): self.f = f def __get__(self, obj, klass=None): if klass is None: klass = type(obj) def newfunc(*args): return self.f(klass, *args) return newfunc 
  • python
  • descriptor
  • descriptor protocol
  • питон
  • дескриптор
  • дескрипторы
  • протокол дескрипторов

ООП. Дескрипторы

В этой лекции мы рассмотрим такой важный механизм как дескрипторы, а также разберемся с тем как же устроены методы класса.

Свойства

Перед тем как говорить о дескрипторах давайте еще раз поговорим о свойствах (property). Рассмотрим следующий пример: пусть у нас есть класс «Профиль пользователя», который включает следующие поля: имя, фамилия и дата рождения.

import typing as tp class UserProfile: def __init__(self, user: "User", first_name: str = "", sur_name: str = "", bdate: tp.Optional[datetime.date] = None) -> None: self._user = user self.first_name = first_name self.sur_name = sur_name self.bdate = bdate self._age = None self._age_last_recalculated = None self._recalculate_age() def _recalculate_age(self) -> None: if self.bdate is None: return today = datetime.date.today() age = today.year - self.bdate.year if today  datetime.date(today.year, self.bdate.month, self.bdate.day): age -= 1 self._age = age self._age_last_recalculated = today def age(self) -> tp.Optional[int]: if self._age is None: return None if datetime.date.today() > self._age_last_recalculated: self._recalculate_age() return self._age class User: def __init__(self, username: str, email: str, password: str) -> None: # . self.profile = UserProfile(self) # . >>> guido = User("guido", "guido@python.org", "python") >>> guido.profile.age() >>> guido.profile.bdate = datetime.date(1956, 1, 31) >>> guido.profile.age() 65 

Из примера видно, что, во-первых, возраст пользователя вычисляется при каждом обращении, во-вторых, мы только получаем значение и никогда его не изменяем. Было бы логично, чтобы клиентский код работал с возрастом как с обычным атрибутом (свойством) доступным только для чтения и python предоставляет нам для этого механизм свойств (propertes):

class UserProfile: # . @property def age(self) -> Optional[int]: if self._age is None: return None if datetime.date.today() > self._age_last_recalculated: self._recalculate_age() return self._age >>> guido = User("guido", "guido@python.org", "python") >>> guido.profile.age >>> guido.profile.bdate = datetime.date(1956, 1, 31) >>> guido.profile.age 65 >>> guido.profile.age = 66 # . AttributeError: can't set attribute 

Таким образом, свойства дают нам возможность создавать, аналогично другим языкам программирования (например, Java), сеттеры и геттеры, а также вычисляемые свойства (computed properties):

class UserProfile: # . @property def fullname(self) -> str: return f" ".title() @fullname.setter def fullname(self, value: str) -> None: name, surname = value.split(" ", maxsplit=1) self.first_name = name self.sur_name = surname @fullname.deleter def fullname(self) -> None: self.first_name = '' self.sur_name = '' >>> guido.profile.fullname = "Guido Van Rossum" >>> guido.profile.first_name 'Guido' >>> guido.profile.sur_name 'Van Rossum' >>> del guido.profile.fullname >>> guido.profile.first_name '' >>> guido.profile.sur_name '' 

Чтобы понять как работают свойства необходимо разобраться с дескрипторами.

Дескрипторы

В документации дано следующее определение дескрипторов:

Дескриптор это любой объект, у которого определены методы __get__() , __set__() или __delete__() . Если дескриптором является атрибут класса, то для него определено специальное поведение при разшенении имени атрибута.

descr.__get__(self, obj, owner=None) -> value descr.__set__(self, obj, value) -> None descr.__delete__(self, obj) -> None 

Дескрипторы, которые реализуют только __get__ называются дескрипторами не данных (non-data descriptors), а дескрипторы, которые реализуют __set__ и/или __delete__ называются дескрипторами данных (data descriptors). Рассмотрим следующий пример:

class D: def __get__(self, obj, owner=None): print(f"__get__ был вызван с аргументами obj= и owner=") def __set__(self, obj, value): print(f"__set__ был вызван с аргументами obj= и value=") class Klass: d1 = D() def __init__(self): self.d2 = D() >>> obj = Klass() >>> obj.d1 # == type(obj).__dict__['d1'].__get__(obj, type(obj)) __get__ был вызван с аргументами obj=__main__.Klass object at 0x1037d4c10> и owner=class '__main__.Klass'> >>> obj.d2 # == obj.__dict__['d2'] __main__.D at 0x1052521c0> >>> Klass.d1 # == Klass.__dict__['d1'].__get__(None, Klass) __get__ был вызван с аргументами obj=None и owner=class '__main__.Klass'> >>> obj.d1 = None # == type(obj).__dict__['d1'].__set__(obj, None) __set__ был вызван с аргументами obj=__main__.Klass object at 0x1037d4c10> и value=None >>> Klass.d1 = None # Klass.__dict__['d1'] = None 

Из примера видно, что при обращении к d1 автоматически был вызван метод __get__ определенный на дескрипторе:

Поведением по умолчанию при доступе к атрибуту является обращение к словарю экземпляра, например, при обращении к a.x поиск начинается с a.__dict__[‘x’] , затем type(a).__dict__[‘x’] и так далее в порядке разрешения методов (mro). Когда же атрибут (класса/метакласса) является дескриптором, то Python изменяет путь поиска, сначала вызывая методы определенные у дескриптора.

Поэтому теперь должно быть понятно, почему при обращении к d2 мы получили просто экземпляр класса. Порядка разрешения имен атрибутов и методов мы коснемся в следующих лекциях.

В Python дескрипторы используются достаточно часто, в том числе и в самом языке, например, функции это дескрипторы:

PyTypeObject PyFunction_Type =  PyVarObject_HEAD_INIT(&PyType_Type, 0) "function", sizeof(PyFunctionObject), 0, // . function_call, /* tp_call */ // . func_descr_get, /* tp_descr_get */ 0, /* tp_descr_set */ // . >; 

Это позволяет автоматически передавать экземпляр класса в качестве первого аргумента ( self ), давайте посмотрим на вызов func_descr_get :

/* Bind a function to an object */ static PyObject * func_descr_get(PyObject *func, PyObject *obj, PyObject *type)  if (obj == Py_None || obj == NULL)  Py_INCREF(func); return func; > return PyMethod_New(func, obj); > 

Если obj не был передан, то мы имеем дело с обычной функцией, в противном случае это метод и мы «биндим» объект в качестве первого аргумента. На python реализацию функций можно было бы записать так:

class Function: def __call__(self, *args, **kwargs): # тело функции def __get__(self, instance, owner): if instance is None: return self else: return functools.partial(self, instance) 

А вот примеры реализаций декораторов @staticmethod и @classmethod:

import functools class Classmethod: def __init__(self, func): self.func = func def __get__(self, instance, owner): return functools.partial(self.func, owner) class Staticmethod: def __init__(self, func): self.func = func def __get__(self, instance, owner): return self.func 

И наконец реализация @property:

class Property: def __init__(self, fget=None, fset=None, fdel=None): self.fget = fget self.fset = fset self.fdel = fdel def __get__(self, instance, owner): if instance is None: return self elif self.fget is None: raise AttributeError("Unreadable attribute") else: return self.fget(instance) def __set__(self, instance, value): if self.fset is None: raise AttributeError("Cant't set attribute") else: self.fset(instance, value) def __delete__(self, instance): if self.fdel is None: raise AttributeError("Can't delete attribute") else: self.fdel(instance) def getter(self, fget): return type(self)(fget, self.fset, self.fdel) def setter(self, fset): return type(self)(self.fget, fset, self.fdel) def deleter(self, fdel): return type(self)(self.fget, self.fset, fdel) 

Пример простой ORM можно найти в репозитории с лекциями.

Descriptor (дескриптор)

Для реализации дескриптора классу требуется определить один или несколько методов, входящих в протокол дескриптора:

  • __get__()
  • __set__()
  • __delete__()
  • +py3.6 __set_name__()

Существуют два вида дескрипторов:

Вид Признак Пример
дескрипторы не-данных наличие только __get__() staticmethod(), classmethod()
дескрипторы данных наличие __get__() и других методов протокола property()

Обращения к дескрипторам обрабатывает метод __getattribute__(), и его перекрытие препятствует автоматическим вызовам дескрипторов.

Пример определения протокола дескриптора и привязки дескриптора к классу:

 class MyDescriptor:

def __set__(self, instance, value):
.

def __get__(self, instance, owner):
.

def __delete__(self, instance):
.

def __set_name__(self, owner, name):
.


class MyClass:

field1 = MyDescriptor()
field2 = MyDescriptor()

Если в __dict__ владельца имеется запись с ключём, совпадающим с именем атрибута, указывающего на дескриптор, то в случае дескрипторов не-данных при обращении к атрибуту вернётся значение из __dict__ , а не из дескриптора. В случае дескрипторов данных наоборот — значение из дескриптора.

Дескрипторы в Python

Есть два разных типа дескрипторов. Дескрипторы данных определяются как объекты , которые определяют одновременно __get__() и __set__() метод, тогда как дескрипторы без данных определить только __get__() метод. Это различие важно при рассмотрении переопределений и пространства имен словаря экземпляра. Если дескриптор данных и запись в словаре экземпляра имеют одно и то же имя, дескриптор данных будет иметь приоритет. Однако если вместо дескриптора не данных и записи в словаре экземпляра используется одно и то же имя, запись словаря экземпляра будет иметь приоритет.

Для того, чтобы дескриптор данных только для чтения, определяют как получить () и установить () с множеством () поднимая AttributeError при вызове. Определение метода набора () с исключением повышающего заполнителем достаточно , чтобы сделать его дескриптор данных.

 descr.__get__(self, obj, type=None) --> value descr.__set__(self, obj, value) --> None descr.__delete__(self, obj) --> None 
 class DescPrinter(object): """A data descriptor that logs activity.""" _val = 7 def __get__(self, obj, objtype=None): print('Getting . ') return self._val def __set__(self, obj, val): print('Setting', val) self._val = val def __delete__(self, obj): print('Deleting . ') del self._val class Foo(): x = DescPrinter() i = Foo() i.x # Getting . # 7 i.x = 100 # Setting 100 i.x # Getting . # 100 del i.x # Deleting . i.x # Getting . # 7 

Двусторонние преобразования

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

Предположим, мы хотим смоделировать генератор с заданной частотой (в герцах) и периодом (в секундах). Когда мы обновляем частоту, мы хотим, чтобы период обновлялся, и когда мы обновляем период, мы хотим, чтобы частота обновлялась:

 >>> oscillator = Oscillator(freq=100.0) # Set frequency to 100.0 Hz >>> oscillator.period # Period is 1 / frequency, i.e. 0.01 seconds 0.01 >>> oscillator.period = 0.02 # Set period to 0.02 seconds >>> oscillator.freq # The frequency is automatically adjusted 50.0 >>> oscillator.freq = 200.0 # Set the frequency to 200.0 Hz >>> oscillator.period # The period is automatically adjusted 0.005 

Мы выбираем одно из значений (частота в герцах) в качестве «якоря», то есть того, которое можно установить без преобразования, и записываем для него класс дескриптора:

 class Hertz(object): def __get__(self, instance, owner): return self.value def __set__(self, instance, value): self.value = float(value) 

«Другое» значение (период в секундах) определяется в терминах привязки. Мы пишем класс дескриптора, который выполняет наши преобразования:

 class Second(object): def __get__(self, instance, owner): # When reading period, convert from frequency return 1 / instance.freq def __set__(self, instance, value): # When setting period, update the frequency instance.freq = 1 / float(value) 

Теперь мы можем написать класс Oscillator:

class Oscillator(object): period = Second() # Set the other value as a class attribute def __init__(self, freq): self.freq = Hertz() # Set the anchor value as an instance attribute self.freq = freq # Assign the passed value - self.period will be adjusted

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *