niezmienne obiekty w Pythonie, które mogą mieć słabe referencje

Question

Podklasowałem tuple lub używam namedtuple błogo na kilka lat, ale teraz mam przypadek użycia, gdzie potrzebuję klasy, która może być używana jako słaby referencyjny. A dzisiaj nauczyłem się tuples don't support weak references.

Czy istnieje inny sposób na stworzenie niezmiennego obiektu w Pythonie ze stałym zestawem atrybutów? Nie potrzebuję indeksowania numerycznego ani zmiennej szerokości krotki.

class SimpleThingWithMethods(object): 
    def __init__(self, n, x): 
     # I just need to store n and x as read-only attributes 
    ... ??? ... 

---

Chyba rodzi się oczywiste pytanie, dlaczego niezmienne; Kod "Pythoniczny" zazwyczaj zakłada po prostu, że wszyscy jesteśmy tutaj dorośli i nikt przy zdrowych zmysłach nie sięgnie do klasy i nie obrzuci jej wartościami, jeśli ryzykuje zrujnowanie niezmienników klasy. W moim przypadku mam zajęcia w bibliotece i martwię się przypadkową modyfikacją obiektów przez użytkowników końcowych. Ludzie, z którymi pracuję, czasami robią niepoprawne założenia dotyczące mojego kodu i zaczynają robić rzeczy, których się nie spodziewałem, więc jest o wiele czystsze, gdybym mógł podnieść błąd, gdyby przypadkowo zmodyfikował mój kod.

Nie martwię się o kuloodporną niezmienność; jeśli ktoś naprawdę nikczemny chce iść i modyfikować rzeczy, ok, w porządku, oni są sami. Po prostu chcę, aby trudno było przypadkowo zmodyfikować moje obiekty.

Answer 1

dobrze, to nie jest wielki odpowiedź, ale wygląda na to, mogę modyfikować odpowiedź w https://stackoverflow.com/a/4828492/44330 --- zasadniczo przesłaniając __setattr__ i __delattr__, aby spełnić moje potrzeby, przynajmniej wbrew przypadkowej modyfikacji. (Ale nie tak ładna jak podklasy tuple)

class Point(object): 
    __slots__ = ('x','y','__weakref__') 
    def __init__(self, x, y): 
     object.__setattr__(self, "x", x) 
     object.__setattr__(self, "y", y) 
    def __setattr__(self, *args): 
     raise TypeError 
    def __delattr__(self, *args): 
     raise TypeError 
    def __eq__(self, other): 
     return self.x == other.x and self.y == other.y 
    def __hash__(self): 
     return self.x.__hash__() * 31 + self.y.__hash__() 

Wdrażanie @ Elazar za pomysł:

class Point(object): 
    __slots__ = ('x','y','__weakref__') 
    def __new__(cls, x, y): 
     thing = object.__new__(cls) 
     object.__setattr__(thing, "x", x) 
     object.__setattr__(thing, "y", y) 
     return thing 
    def __setattr__(self, *args): 
     raise TypeError 
    def __delattr__(self, *args): 
     raise TypeError 
    def __eq__(self, other): 
     return self.x == other.x and self.y == other.y 
    def __hash__(self): 
     return self.x.__hash__() * 31 + self.y.__hash__()  

Answer 2

Co za pomocą enkapsulacji i abstrakcji od parametru (getter):

class SimpleThingWithMethods(object): 
    def __init__(self, n, x): 
     self._n = n 
     self._x = x 

    def x(self): 
     return self._x 

    def n(self): 
     return self._n 

    SimpleThingWithMethods(2,3).x() 

=> 3

Answer 3

Jeżeli nie martw się o isinstance kontrole można wzmocnić odpowiesz:

def Point(x, y): 
    class Point(object): 
     __slots__ = ('x','y','__weakref__') 
     def __setattr__(self, *args): 
      raise TypeError 
     def __delattr__(self, *args): 
      raise TypeError 
     def __eq__(self, other): 
      return x == other.x and y == other.y 
     def __hash__(self): 
      return x.__hash__() * 31 + y.__hash__() 
    p = Point() 
    object.__setattr__(p, "x", x) 
    object.__setattr__(p, "y", y) 
    return p 

Naprawdę nie polecam (każda inwokacja tworzy klasę!), Chciałem tylko zwrócić uwagę na możliwość.

Jest również możliwe, aby przejść javascript na całą drogę i dostarczyć __getattr__, który będzie mieć dostęp do zmiennych lokalnych. Ale to także spowolni dostęp, oprócz tworzenia. Teraz nie trzeba tych szczelin w ogóle:

class MetaImmutable: 
    def __setattr__(self, name, val): 
     raise TypeError 

def Point(x, y): 
    class Point(object): 
     __metaclass__ = MetaImmutable 
     __slots__ = ('__weakref__',) 
     def __getattr__(self, name): 
      if name == 'x': return x 
      if name == 'y': return y 
      raise TypeError 
     @property 
     def x(self): return x 
     @property 
     def y(self): return y 
     def __eq__(self, other): 
      return x == other.x and y == other.y 
     def __hash__(self): 
      return x.__hash__() * 31 + y.__hash__() 
    return Point() 

go przetestować:

>>> p = Point(1, 2) 
>>> p.y 
2 
>>> p.z 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "<stdin>", line 7, in __getattr__ 
TypeError 
>>> p.z = 5 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'Point' object has no attribute 'z' 
>>> object.__setattr__(p, 'z', 5) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
AttributeError: 'Point' object has no attribute 'z' 
>>> from weakref import ref 
>>> ref(p)().x 
1 
>>> type(p).x = property(lambda self: 3) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "<stdin>", line 4, in __setattr__ 
TypeError 

I wreszcie, nadal można złamać go:

>>> type.__setattr__(type(p), 'x', property(lambda self: 5)) 
>>> p.x 
5 

Ponownie zaleca nic tutaj . Użyj implementacji @Jasons.