Как я могу сделать псевдоним для атрибута нефункционального члена в классе Python?

Если я не неправильно понимаю вопрос, это можно решить почти точно так же, как с методами класса.

например,

class Dummy(object):

    def __init__(self):
        self._x = 17

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

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

    # Alias
    xValue = x

d = Dummy()
print(d.x, d.xValue)
#=> (17, 17)
d.x = 0
print(d.x, d.xValue)
#=> (0, 0)
d.xValue = 100
print(d.x, d.xValue)
#=> (100, 100)

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

на мой взгляд, этот код намного легче читать и понимать, чем все __setattr__ и __getattr__ перезаписи.

что вы собираетесь делать, когда половина ваших пользователей решили использовать d.x а другая половина d.xValue? Что происходит, когда они пытаются поделиться кодом? Конечно, это сработает,если вы знаете все псевдонимы, но будет ли это очевидно? Будет ли это очевидно для вас, когда вы отложите свой код на год?

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

это в основном потому что мой API сценариев используется в нескольких подсистемах & Домены, поэтому словарь по умолчанию изменения. То, что известно как" X " в одном домен известен как "Y" в другом домен.

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

class Dummy(object):
   def __init__(self):
      self.x=1
   @property
   def xValue(self):
      return self.x
   @xValue.setter
   def xValue(self,value):
      self.x=value

d=Dummy()
print(d.x)
# 1
d.xValue=2
print(d.x)
# 2

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

лучше использовать шаблон дизайна адаптера. Это позволяет держать манекен красиво, компактно, лаконично:

class Dummy(object):
   def __init__(self):
      self.x=1

в то время как те пользователи в поддомене, которые хотят использовать другой словарь может сделать это используя класс адаптера:

class DummyAdaptor(object):
   def __init__(self):
      self.dummy=Dummy()
   @property
   def xValue(self):
      return self.dummy.x
   @xValue.setter
   def xValue(self,value):
      self.dummy.x=value    

для каждого метода и атрибута в Dummy вы просто подключаете аналогичные методы и свойства которые делегируют тяжелую работу экземпляру Манекен.

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

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

Edit: класс, содержащий Alias атрибуты могут быть сделаны для автоматического удаления любых связанных целевых атрибутов, когда вы del один (и наоборот). Код для моего ответа теперь иллюстрирует один простой способ: может быть сделано с помощью удобного декоратора класса, который добавляет пользовательский __delattr__() чтобы сделать Специализированное управление удалением, когда атрибут Alias's может быть вовлечен.

class Alias(object):
    """ Descriptor to give an attribute another name. """
    def __init__(self, name):
        self.name = name
    def __get__(self, inst, cls):
        if inst is None:
            return self  # a class attribute reference, return this descriptor
        return getattr(inst, self.name)
    def __set__(self, inst, value):
        setattr(inst, self.name, value)
    def __delete__(self, inst):
        delattr(inst, self.name)

def AliasDelManager(cls):
    """ Class decorator to auto-manage associated Aliases on deletion. """
    def __delattr__(self, name):
        """ Deletes any Aliases associated with a named attribute, or
            if attribute is itself an Alias, deletes the associated target.
        """
        super(cls, self).__delattr__(name) # use base class's method
        for attrname in dir(self):
            attr = getattr(Dummy, attrname)
            if isinstance(attr, Alias) and attr.name == name:
                delattr(Dummy, attrname)

    setattr(cls, '__delattr__', __delattr__)
    return cls

if __name__=='__main__':
    @AliasDelManager
    class Dummy(object):
        def __init__(self):
            self.x = 17
        xValue = Alias('x')  # create an Alias for attr 'x'

    d = Dummy()
    assert d.x == 17
    assert d.xValue == 17
    d.x = 23
    assert d.xValue == 23
    d.xValue = 1492
    assert d.x == 1492
    assert d.x is d.xValue
    del d.x  # should also remove any associated Aliases
    assert 'xValue' not in dir(d)
    print 'done - no exceptions were raised'

переопределить __getattr__() метод и возвращает соответствующее значение.