Jak mogę utworzyć alias do atrybutu non-function member w klasie Pythona?

O ile nie źle zrozumiałem pytanie, można to rozwiązać w prawie dokładnie taki sam sposób jak w przypadku metod klasowych.

Na przykład,

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)

Obie wartości zawsze pozostaną zsynchronizowane. Piszesz rzeczywisty kod właściwości z preferowaną nazwą atrybutu, a następnie używasz pseudonimu z dowolną starszą nazwą(nazwami), której potrzebujesz.

Moim oczom ten kod jest o wiele łatwiejszy do odczytania i zrozumienia niż wszystkie __setattr__ i __getattr__ nadpisywanie.

Co zrobisz, gdy połowa użytkowników zdecyduje się użyć d.x, a druga połowa d.xValue? Co się dzieje, gdy próbują udostępnić kod? Pewnie, że zadziała, jeśli znasz wszystkie aliasy, ale czy będzie to oczywiste? Czy będzie to dla ciebie oczywiste, kiedy odłożysz swój kod na rok?

Głównie dlatego, że moje Skryptowe API jest używany w wielu podsystemach & domeny, więc domyślne słownictwo zmiany. Tzw. " X " w jednym domena jest znana jako "Y" w innym domena.

Możesz tworzyć aliasy z właściwościami w ten sposób:

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

Ale z powodów wymienionych powyżej, nie sądzę, że jest to dobry projekt. Informatyka utrudnia czytanie, rozumienie i używanie manekina. Dla każdego użytkownika podwoiłeś rozmiar API, który użytkownik musi znać, aby zrozumieć Dummy.

Lepszą alternatywą jest użyj wzorca projektowego adaptera . Pozwala to zachować smoczek miły, zwarty, zwięzły:

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

Podczas gdy ci użytkownicy w subdomenie, którzy chcą używać innego słownictwa, mogą to zrobić za pomocą klasy adaptera:

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    

Dla każdej metody i atrybutu w atrybucie, po prostu podłączasz podobne metody i właściwości które delegują podnoszenie ciężarów do instancji manekina.

Może to być więcej linii kodu, ale pozwoli Ci zachować czysty projekt dla atrapy, łatwiejsze w utrzymaniu, dokumentowaniu i testowaniu jednostkowym. Ludzie będą pisać kod, który ma sens, ponieważ Klasa ograniczy to, jakie API jest dostępne, i będzie tylko jedna nazwa dla każdej koncepcji, biorąc pod uwagę klasę, którą wybrali.

Możesz użyć niektórych pomysłów pokazanych w przepisie ActiveState Python zatytułowanym buforowanie i aliasowanie za pomocą deskryptorów. Oto zwięzła wersja kodu, która zapewnia funkcjonalność, której szukasz.

Edit: Klasa zawierająca atrybuty Alias może zostać wykonana w celu automatycznego usuwania wszelkich powiązanych atrybutów docelowych, gdy ty del jeden (i vice-versa). Kod do mojej odpowiedzi teraz ilustruje jeden prosty sposób można to zrobić za pomocą wygodnego dekorator klasy, który dodaje niestandardowe __delattr__() do wyspecjalizowanego zarządzania usuwaniem, gdy atrybut Alias's może być zaangażowany.

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'

Nadpisuje metodę __getattr__() i zwraca odpowiednią wartość.