Aunque nunca he necesitado esto, me llamó la atención que hacer un objeto inmutable en Python podría ser un poco complicado. No puede anular simplemente __setattr__, porque entonces ni siquiera puede establecer atributos en el __init__. Subclasificar una tupla es un truco que funciona:

class Immutable(tuple):

    def __new__(cls, a, b):
        return tuple.__new__(cls, (a, b))

    @property
    def a(self):
        return self[0]

    @property
    def b(self):
        return self[1]

    def __str__(self):
        return "<Immutable {0}, {1}>".format(self.a, self.b)

    def __setattr__(self, *ignored):
        raise NotImplementedError

    def __delattr__(self, *ignored):
        raise NotImplementedError

Pero entonces usted tiene acceso a la ay blas variables a través self[0]y self[1], lo que es molesto.

¿Es esto posible en Pure Python? Si no, ¿cómo lo haría con una extensión C?

(Las respuestas que funcionan solo en Python 3 son aceptables).

Actualizar:

Entonces, subclasificar tuplas es la forma de hacerlo en Pure Python, que funciona bien, excepto por la posibilidad adicional de acceder a los datos [0], [1]etc. Entonces, para completar esta pregunta, todo lo que falta es cómo hacerlo "correctamente" en C, que Sospecho que sería bastante simple, simplemente no implementando ninguno geititemo setattributeetc. Pero en lugar de hacerlo yo mismo, ofrezco una recompensa por eso, porque soy flojo. :)

Otra solución más en la que acabo de pensar: la forma más simple de obtener el mismo comportamiento que su código original es

Immutable = collections.namedtuple("Immutable", ["a", "b"])

No resuelve el problema de que se puede acceder a los atributos a través de [0]etc., pero al menos es considerablemente más corto y proporciona la ventaja adicional de ser compatible con pickley copy.

namedtuplecrea un tipo similar al que describí en esta respuesta , es decir, derivado tupley utilizado __slots__. Está disponible en Python 2.6 o superior.

La forma más fácil de hacer esto es usar __slots__:

class A(object):
    __slots__ = []

Las instancias de Ason inmutables ahora, ya que no puede establecer ningún atributo en ellas.

Si desea que las instancias de clase contengan datos, puede combinar esto con derivar de tuple:

from operator import itemgetter
class Point(tuple):
    __slots__ = []
    def __new__(cls, x, y):
        return tuple.__new__(cls, (x, y))
    x = property(itemgetter(0))
    y = property(itemgetter(1))

p = Point(2, 3)
p.x
# 2
p.y
# 3

Editar : si desea deshacerse de la indexación, puede anular __getitem__():

class Point(tuple):
    __slots__ = []
    def __new__(cls, x, y):
        return tuple.__new__(cls, (x, y))
    @property
    def x(self):
        return tuple.__getitem__(self, 0)
    @property
    def y(self):
        return tuple.__getitem__(self, 1)
    def __getitem__(self, item):
        raise TypeError

Tenga en cuenta que no puede usar operator.itemgetterlas propiedades en este caso, ya que esto dependería en Point.__getitem__()lugar de tuple.__getitem__(). Además, esto no impedirá el uso de tuple.__getitem__(p, 0), pero apenas puedo imaginar cómo esto debería constituir un problema.

No creo que la forma "correcta" de crear un objeto inmutable sea escribir una extensión C. Python generalmente se basa en implementadores de bibliotecas y usuarios de bibliotecas que son adultos que dan consentimiento , y en lugar de imponer realmente una interfaz, la interfaz debe estar claramente indicada en la documentación. Es por eso que no considero la posibilidad de eludir una anulación __setattr__()llamando a object.__setattr__()un problema. Si alguien hace esto, es bajo su propio riesgo.

..cómo hacerlo "correctamente" en C ..

Puede usar Cython para crear un tipo de extensión para Python:

cdef class Immutable:
    cdef readonly object a, b
    cdef object __weakref__ # enable weak referencing support

    def __init__(self, a, b):
        self.a, self.b = a, b

Funciona tanto en Python 2.xy 3.

Pruebas

# compile on-the-fly
import pyximport; pyximport.install() # $ pip install cython
from immutable import Immutable

o = Immutable(1, 2)
assert o.a == 1, str(o.a)
assert o.b == 2

try: o.a = 3
except AttributeError:
    pass
else:
    assert 0, 'attribute must be readonly'

try: o[1]
except TypeError:
    pass
else:
    assert 0, 'indexing must not be supported'

try: o.c = 1
except AttributeError:
    pass
else:
    assert 0, 'no new attributes are allowed'

o = Immutable('a', [])
assert o.a == 'a'
assert o.b == []

o.b.append(3) # attribute may contain mutable object
assert o.b == [3]

try: o.c
except AttributeError:
    pass
else:
    assert 0, 'no c attribute'

o = Immutable(b=3,a=1)
assert o.a == 1 and o.b == 3

try: del o.b
except AttributeError:
    pass
else:
    assert 0, "can't delete attribute"

d = dict(b=3, a=1)
o = Immutable(**d)
assert o.a == d['a'] and o.b == d['b']

o = Immutable(1,b=3)
assert o.a == 1 and o.b == 3

try: object.__setattr__(o, 'a', 1)
except AttributeError:
    pass
else:
    assert 0, 'attributes are readonly'

try: object.__setattr__(o, 'c', 1)
except AttributeError:
    pass
else:
    assert 0, 'no new attributes'

try: Immutable(1,c=3)
except TypeError:
    pass
else:
    assert 0, 'accept only a,b keywords'

for kwd in [dict(a=1), dict(b=2)]:
    try: Immutable(**kwd)
    except TypeError:
        pass
    else:
        assert 0, 'Immutable requires exactly 2 arguments'

Si no le importa el soporte de indexación, entonces es preferible que collections.namedtuplesugiera @Sven Marnach

Immutable = collections.namedtuple("Immutable", "a b")

Otra idea sería no permitir __setattr__y usar por completo object.__setattr__en el constructor:

class Point(object):
    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

Por supuesto, podría usar object.__setattr__(p, "x", 3)para modificar una Pointinstancia p, pero su implementación original tiene el mismo problema (pruebe tuple.__setattr__(i, "x", 42)con unImmutable instancia).

Puede aplicar el mismo truco en su implementación original: deshacerse de él __getitem__()y utilizarlo tuple.__getitem__()en sus funciones de propiedad.

Puede crear un @immutabledecorador que anule __setattr__ o cambie el __slots__a una lista vacía, luego decore el __init__método con él.

Editar: como señaló el OP, cambiar el __slots__atributo solo impide la creación de nuevos atributos , no la modificación.

Edit2: Aquí hay una implementación:

Edit3: el uso __slots__rompe este código, porque si detiene la creación del objeto __dict__. Estoy buscando una alternativa.

Edit4: Bueno, eso es todo. Es un poco duro, pero funciona como un ejercicio :-)

class immutable(object):
    def __init__(self, immutable_params):
        self.immutable_params = immutable_params

    def __call__(self, new):
        params = self.immutable_params

        def __set_if_unset__(self, name, value):
            if name in self.__dict__:
                raise Exception("Attribute %s has already been set" % name)

            if not name in params:
                raise Exception("Cannot create atribute %s" % name)

            self.__dict__[name] = value;

        def __new__(cls, *args, **kws):
            cls.__setattr__ = __set_if_unset__

            return super(cls.__class__, cls).__new__(cls, *args, **kws)

        return __new__

class Point(object):
    @immutable(['x', 'y'])
    def __new__(): pass

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2) 
p.x = 3 # Exception: Attribute x has already been set
p.z = 4 # Exception: Cannot create atribute z

Usando una clase de datos congelada

Para Python 3.7+ puede usar una clase de datos con unfrozen=True opción , que es una forma muy pitónica y fácil de hacer para hacer lo que quieras.

Se vería algo así:

from dataclasses import dataclass

@dataclass(frozen=True)
class Immutable:
    a: Any
    b: Any

Como se requieren sugerencias de tipo para los campos de clases de datos, he utilizado Any del typingmódulo .

Razones para NO usar un Namedtuple

Antes de Python 3.7 era frecuente ver a las tuplas nombradas como objetos inmutables. Puede ser complicado de muchas maneras, una de ellas es que el __eq__método entre las tuplas nombradas no considera las clases de los objetos. Por ejemplo:

from collections import namedtuple

ImmutableTuple = namedtuple("ImmutableTuple", ["a", "b"])
ImmutableTuple2 = namedtuple("ImmutableTuple2", ["a", "c"])

obj1 = ImmutableTuple(a=1, b=2)
obj2 = ImmutableTuple2(a=1, c=2)

obj1 == obj2  # will be True

Como puede ver, incluso si los tipos de obj1y obj2son diferentes, incluso si los nombres de sus campos son diferentes, obj1 == obj2todavía da True. Esto se debe a que el __eq__método utilizado es el de la tupla, que compara solo los valores de los campos en función de sus posiciones. Esa puede ser una gran fuente de errores, especialmente si está subclasificando estas clases.

No creo que sea completamente posible, excepto mediante el uso de una tupla o una tupla con nombre. Pase lo que pase, si anula __setattr__()el usuario, siempre puede omitirlo llamando object.__setattr__()directamente. Cualquier solución que dependa de__setattr__ está garantizada para no funcionar.

Lo siguiente es sobre lo más cercano que puede llegar sin usar algún tipo de tupla:

class Immutable:
    __slots__ = ['a', 'b']
    def __init__(self, a, b):
        object.__setattr__(self, 'a', a)
        object.__setattr__(self, 'b', b)
    def __setattr__(self, *ignored):
        raise NotImplementedError
    __delattr__ = __setattr__

pero se rompe si te esfuerzas lo suficiente:

>>> t = Immutable(1, 2)
>>> t.a
1
>>> object.__setattr__(t, 'a', 2)
>>> t.a
2

pero el uso de Sven namedtuplees genuinamente inmutable.

Actualizar

Como la pregunta se ha actualizado para preguntar cómo hacerlo correctamente en C, aquí está mi respuesta sobre cómo hacerlo correctamente en Cython:

Primero immutable.pyx:

cdef class Immutable:
    cdef object _a, _b

    def __init__(self, a, b):
        self._a = a
        self._b = b

    property a:
        def __get__(self):
            return self._a

    property b:
        def __get__(self):
            return self._b

    def __repr__(self):
        return "<Immutable {0}, {1}>".format(self.a, self.b)

y a setup.pypara compilarlo (usando el comando setup.py build_ext --inplace:

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

ext_modules = [Extension("immutable", ["immutable.pyx"])]

setup(
  name = 'Immutable object',
  cmdclass = {'build_ext': build_ext},
  ext_modules = ext_modules
)

Luego para probarlo:

>>> from immutable import Immutable
>>> p = Immutable(2, 3)
>>> p
<Immutable 2, 3>
>>> p.a = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: attribute 'a' of 'immutable.Immutable' objects is not writable
>>> object.__setattr__(p, 'a', 1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: attribute 'a' of 'immutable.Immutable' objects is not writable
>>> p.a, p.b
(2, 3)
>>>      

Hice clases inmutables anulando __setattr__y permitiendo el conjunto si la persona que llama es __init__:

import inspect
class Immutable(object):
    def __setattr__(self, name, value):
        if inspect.stack()[2][3] != "__init__":
            raise Exception("Can't mutate an Immutable: self.%s = %r" % (name, value))
        object.__setattr__(self, name, value)

Esto aún no es suficiente, ya que permite que cualquiera ___init__pueda cambiar el objeto, pero se entiende la idea.

Además de las excelentes otras respuestas, me gusta agregar un método para Python 3.4 (o quizás 3.3). Esta respuesta se basa en varias respuestas previas a esta pregunta.

En python 3.4, puede usar propiedades sin setters para crear miembros de clase que no se puedan modificar. (En versiones anteriores era posible asignar propiedades sin un setter).

class A:
    __slots__=['_A__a']
    def __init__(self, aValue):
      self.__a=aValue
    @property
    def a(self):
        return self.__a

Puedes usarlo así:

instance=A("constant")
print (instance.a)

que imprimirá "constant"

Pero llamar instance.a=10causará:

AttributeError: can't set attribute

Explicación: las propiedades sin setters son una característica muy reciente de python 3.4 (y creo que 3.3). Si intenta asignar a dicha propiedad, se generará un error. Usando ranuras restrinjo las variables miembro a __A_a(que es __a).

Problema: Asignación a _A__a todavía es posible ( instance._A__a=2). Pero si asigna a una variable privada, es su culpa ...

Esta respuesta, entre otras, sin embargo, desalienta el uso de __slots__. Usar otras formas de prevenir la creación de atributos puede ser preferible.

Aquí hay una solución elegante :

class Immutable(object):
    def __setattr__(self, key, value):
        if not hasattr(self, key):
            super().__setattr__(key, value)
        else:
            raise RuntimeError("Can't modify immutable object's attribute: {}".format(key))

Herede de esta clase, inicialice sus campos en el constructor y estará listo.

Si está interesado en objetos con comportamiento, entonces namedtuple es casi su solución.

Como se describe al final de la documentación de namedtuple , puede derivar su propia clase de namedtuple; y luego, puede agregar el comportamiento que desee.

Por ejemplo (código tomado directamente de la documentación ):

class Point(namedtuple('Point', 'x y')):
    __slots__ = ()
    @property
    def hypot(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
    def __str__(self):
        return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

for p in Point(3, 4), Point(14, 5/7):
    print(p)

Esto resultará en:

Point: x= 3.000  y= 4.000  hypot= 5.000
Point: x=14.000  y= 0.714  hypot=14.018

Este enfoque funciona tanto para Python 3 como para Python 2.7 (también probado en IronPython).
El único inconveniente es que el árbol de herencia es un poco extraño; pero esto no es algo con lo que sueles jugar.

Las clases que heredan de la siguiente Immutableclase son inmutables, como son sus instancias, una vez que su __init__método termina de ejecutarse. Como se trata de Python puro, como han señalado otros, no hay nada que impida que alguien use los métodos especiales de mutación de la base objectytype , pero esto es suficiente para detener a nadie de la mutación de una clase / instancia por accidente.

Funciona secuestrando el proceso de creación de clases con una metaclase.

"""Subclasses of class Immutable are immutable after their __init__ has run, in
the sense that all special methods with mutation semantics (in-place operators,
setattr, etc.) are forbidden.

"""  

# Enumerate the mutating special methods
mutation_methods = set()
# Arithmetic methods with in-place operations
iarithmetic = '''add sub mul div mod divmod pow neg pos abs bool invert lshift
                 rshift and xor or floordiv truediv matmul'''.split()
for op in iarithmetic:
    mutation_methods.add('__i%s__' % op)
# Operations on instance components (attributes, items, slices)
for verb in ['set', 'del']:
    for component in '''attr item slice'''.split():
        mutation_methods.add('__%s%s__' % (verb, component))
# Operations on properties
mutation_methods.update(['__set__', '__delete__'])


def checked_call(_self, name, method, *args, **kwargs):
    """Calls special method method(*args, **kw) on self if mutable."""
    self = args[0] if isinstance(_self, object) else _self
    if not getattr(self, '__mutable__', True):
        # self told us it's immutable, so raise an error
        cname= (self if isinstance(self, type) else self.__class__).__name__
        raise TypeError('%s is immutable, %s disallowed' % (cname, name))
    return method(*args, **kwargs)


def method_wrapper(_self, name):
    "Wrap a special method to check for mutability."
    method = getattr(_self, name)
    def wrapper(*args, **kwargs):
        return checked_call(_self, name, method, *args, **kwargs)
    wrapper.__name__ = name
    wrapper.__doc__ = method.__doc__
    return wrapper


def wrap_mutating_methods(_self):
    "Place the wrapper methods on mutative special methods of _self"
    for name in mutation_methods:
        if hasattr(_self, name):
            method = method_wrapper(_self, name)
            type.__setattr__(_self, name, method)


def set_mutability(self, ismutable):
    "Set __mutable__ by using the unprotected __setattr__"
    b = _MetaImmutable if isinstance(self, type) else Immutable
    super(b, self).__setattr__('__mutable__', ismutable)


class _MetaImmutable(type):

    '''The metaclass of Immutable. Wraps __init__ methods via __call__.'''

    def __init__(cls, *args, **kwargs):
        # Make class mutable for wrapping special methods
        set_mutability(cls, True)
        wrap_mutating_methods(cls)
        # Disable mutability
        set_mutability(cls, False)

    def __call__(cls, *args, **kwargs):
        '''Make an immutable instance of cls'''
        self = cls.__new__(cls)
        # Make the instance mutable for initialization
        set_mutability(self, True)
        # Execute cls's custom initialization on this instance
        self.__init__(*args, **kwargs)
        # Disable mutability
        set_mutability(self, False)
        return self

    # Given a class T(metaclass=_MetaImmutable), mutative special methods which
    # already exist on _MetaImmutable (a basic type) cannot be over-ridden
    # programmatically during _MetaImmutable's instantiation of T, because the
    # first place python looks for a method on an object is on the object's
    # __class__, and T.__class__ is _MetaImmutable. The two extant special
    # methods on a basic type are __setattr__ and __delattr__, so those have to
    # be explicitly overridden here.

    def __setattr__(cls, name, value):
        checked_call(cls, '__setattr__', type.__setattr__, cls, name, value)

    def __delattr__(cls, name, value):
        checked_call(cls, '__delattr__', type.__delattr__, cls, name, value)


class Immutable(object):

    """Inherit from this class to make an immutable object.

    __init__ methods of subclasses are executed by _MetaImmutable.__call__,
    which enables mutability for the duration.

    """

    __metaclass__ = _MetaImmutable


class T(int, Immutable):  # Checks it works with multiple inheritance, too.

    "Class for testing immutability semantics"

    def __init__(self, b):
        self.b = b

    @classmethod
    def class_mutation(cls):
        cls.a = 5

    def instance_mutation(self):
        self.c = 1

    def __iadd__(self, o):
        pass

    def not_so_special_mutation(self):
        self +=1

def immutabilityTest(f, name):
    "Call f, which should try to mutate class T or T instance."
    try:
        f()
    except TypeError, e:
        assert 'T is immutable, %s disallowed' % name in e.args
    else:
        raise RuntimeError('Immutability failed!')

immutabilityTest(T.class_mutation, '__setattr__')
immutabilityTest(T(6).instance_mutation, '__setattr__')
immutabilityTest(T(6).not_so_special_mutation, '__iadd__')

Lo necesitaba hace un momento y decidí hacer un paquete de Python para él. La versión inicial está en PyPI ahora:

$ pip install immutable

Usar:

>>> from immutable import ImmutableFactory
>>> MyImmutable = ImmitableFactory.create(prop1=1, prop2=2, prop3=3)
>>> MyImmutable.prop1
1

Documentos completos aquí: https://github.com/theengineear/immutable

Espero que ayude, envuelve una tupla con nombre como se ha discutido, pero hace que la instanciación sea mucho más simple.

De esta manera no deja object.__setattr__de funcionar, pero aún lo encuentro útil:

class A(object):

    def __new__(cls, children, *args, **kwargs):
        self = super(A, cls).__new__(cls)
        self._frozen = False  # allow mutation from here to end of  __init__
        # other stuff you need to do in __new__ goes here
        return self

    def __init__(self, *args, **kwargs):
        super(A, self).__init__()
        self._frozen = True  # prevent future mutation

    def __setattr__(self, name, value):
        # need to special case setting _frozen.
        if name != '_frozen' and self._frozen:
            raise TypeError('Instances are immutable.')
        else:
            super(A, self).__setattr__(name, value)

    def __delattr__(self, name):
        if self._frozen:
            raise TypeError('Instances are immutable.')
        else:
            super(A, self).__delattr__(name)

Es posible que deba anular más cosas (como __setitem__) según el caso de uso.

¡A partir de Python 3.7, puede usar el @dataclassdecorador en su clase y será inmutable como una estructura! Sin embargo, puede o no agregar un __hash__()método a su clase. Citar:

hash () es usado por hash () incorporado, y cuando los objetos se agregan a colecciones hash como diccionarios y conjuntos. Tener un hash () implica que las instancias de la clase son inmutables. La mutabilidad es una propiedad complicada que depende de la intención del programador, la existencia y el comportamiento de eq (), y los valores de eq y banderas congeladas en el decorador dataclass ().

Por defecto, dataclass () no agregará implícitamente un método hash () a menos que sea seguro hacerlo. Tampoco agregará o cambiará un método hash () explícitamente definido . Establecer el atributo de clase hash = None tiene un significado específico para Python, como se describe en la documentación hash ().

Si hash () no está definido explícitamente, o si está establecido en Ninguno, entonces dataclass () puede agregar un método implícito hash (). Aunque no se recomienda, puede forzar dataclass () para crear un método hash () con unsafe_hash = True. Este podría ser el caso si su clase es lógicamente inmutable, pero puede ser mutada. Este es un caso de uso especializado y debe considerarse cuidadosamente.

Aquí el ejemplo de los documentos vinculados anteriormente:

@dataclass
class InventoryItem:
    '''Class for keeping track of an item in inventory.'''
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Puede anular setattr y seguir usando init para establecer la variable. Usarías super class setattr . Aquí está el código.

clase inmutable:
    __slots__ = ('a', 'b')
    def __init __ (self, a, b):
        super () .__ setattr __ ('a', a)
        super () .__ setattr __ ('b', b)

    def __str __ (self):
        return "" .format (self.a, self.b)

    def __setattr __ (self, * ignorado):
        raise NotImplementedError

    def __delattr __ (self, * ignorado):
        raise NotImplementedError

El attrmódulo de terceros proporciona esta funcionalidad. .

Editar: python 3.7 ha adoptado esta idea en stdlib con @dataclass.

$ pip install attrs
$ python
>>> @attr.s(frozen=True)
... class C(object):
...     x = attr.ib()
>>> i = C(1)
>>> i.x = 2
Traceback (most recent call last):
   ...
attr.exceptions.FrozenInstanceError: can't set attribute

attr implementa clases congeladas anulando __setattr__ y tiene un impacto menor en el rendimiento en cada tiempo de instanciación, de acuerdo con la documentación.

Si tiene la costumbre de usar clases como tipos de datos, attrpuede ser especialmente útil ya que se ocupa de la placa repetitiva por usted (pero no hace ninguna magia). En particular, escribe nueve métodos dunder (__X__) para usted (a menos que desactive alguno de ellos), incluidos repr, init, hash y todas las funciones de comparación.

attrTambién proporciona un ayudante para__slots__ .

Entonces, estoy escribiendo respectivo de python 3:

I) con la ayuda del decorador de clase de datos y establecer frozen = True. Podemos crear objetos inmutables en Python.

para esto es necesario importar la clase de datos de las clases de datos lib y necesita configurar frozen = True

ex.

desde clases de datos importar clase de datos

@dataclass(frozen=True)
class Location:
    name: str
    longitude: float = 0.0
    latitude: float = 0.0

o / p:

l = Ubicación ("Delhi", 112.345, 234.788) l.name 'Delhi' l.longitud 112.345 l.latitud 234.788 l.name = clases de datos "Kolkata". FrozenInstanceError: no se puede asignar al campo 'nombre'

Fuente: https://realpython.com/python-data-classes/

Un enfoque alternativo es crear un contenedor que haga que una instancia sea inmutable.

class Immutable(object):

    def __init__(self, wrapped):
        super(Immutable, self).__init__()
        object.__setattr__(self, '_wrapped', wrapped)

    def __getattribute__(self, item):
        return object.__getattribute__(self, '_wrapped').__getattribute__(item)

    def __setattr__(self, key, value):
        raise ImmutableError('Object {0} is immutable.'.format(self._wrapped))

    __delattr__ = __setattr__

    def __iter__(self):
        return object.__getattribute__(self, '_wrapped').__iter__()

    def next(self):
        return object.__getattribute__(self, '_wrapped').next()

    def __getitem__(self, item):
        return object.__getattribute__(self, '_wrapped').__getitem__(item)

immutable_instance = Immutable(my_instance)

Esto es útil en situaciones donde solo algunas instancias tienen que ser inmutables (como los argumentos predeterminados de las llamadas a funciones).

También se puede usar en fábricas inmutables como:

@classmethod
def immutable_factory(cls, *args, **kwargs):
    return Immutable(cls.__init__(*args, **kwargs))

También protege object.__setattr__, pero puede fallar a otros trucos debido a la naturaleza dinámica de Python.

Usé la misma idea que Alex: una metaclase y un "marcador de inicio", pero en combinación con sobreescribir __setattr__:

>>> from abc import ABCMeta
>>> _INIT_MARKER = '_@_in_init_@_'
>>> class _ImmutableMeta(ABCMeta):
... 
...     """Meta class to construct Immutable."""
... 
...     def __call__(cls, *args, **kwds):
...         obj = cls.__new__(cls, *args, **kwds)
...         object.__setattr__(obj, _INIT_MARKER, True)
...         cls.__init__(obj, *args, **kwds)
...         object.__delattr__(obj, _INIT_MARKER)
...         return obj
...
>>> def _setattr(self, name, value):
...     if hasattr(self, _INIT_MARKER):
...         object.__setattr__(self, name, value)
...     else:
...         raise AttributeError("Instance of '%s' is immutable."
...                              % self.__class__.__name__)
...
>>> def _delattr(self, name):
...     raise AttributeError("Instance of '%s' is immutable."
...                          % self.__class__.__name__)
...
>>> _im_dict = {
...     '__doc__': "Mix-in class for immutable objects.",
...     '__copy__': lambda self: self,   # self is immutable, so just return it
...     '__setattr__': _setattr,
...     '__delattr__': _delattr}
...
>>> Immutable = _ImmutableMeta('Immutable', (), _im_dict)

Nota: Llamo a la metaclase directamente para que funcione tanto para Python 2.xy 3.x.

>>> class T1(Immutable):
... 
...     def __init__(self, x=1, y=2):
...         self.x = x
...         self.y = y
...
>>> t1 = T1(y=8)
>>> t1.x, t1.y
(1, 8)
>>> t1.x = 7
AttributeError: Instance of 'T1' is immutable.

Funciona también con máquinas tragamonedas ...:

>>> class T2(Immutable):
... 
...     __slots__ = 's1', 's2'
... 
...     def __init__(self, s1, s2):
...         self.s1 = s1
...         self.s2 = s2
...
>>> t2 = T2('abc', 'xyz')
>>> t2.s1, t2.s2
('abc', 'xyz')
>>> t2.s1 += 'd'
AttributeError: Instance of 'T2' is immutable.

... y herencia múltiple:

>>> class T3(T1, T2):
... 
...     def __init__(self, x, y, s1, s2):
...         T1.__init__(self, x, y)
...         T2.__init__(self, s1, s2)
...
>>> t3 = T3(12, 4, 'a', 'b')
>>> t3.x, t3.y, t3.s1, t3.s2
(12, 4, 'a', 'b')
>>> t3.y -= 3
AttributeError: Instance of 'T3' is immutable.

Sin embargo, tenga en cuenta que los atributos mutables siguen siendo mutables:

>>> t3 = T3(12, [4, 7], 'a', 'b')
>>> t3.y.append(5)
>>> t3.y
[4, 7, 5]

Una cosa que realmente no se incluye aquí es la inmutabilidad total ... no solo el objeto padre, sino también todos los hijos. Las tuplas / congelados pueden ser inmutables, por ejemplo, pero los objetos de los que forma parte pueden no serlo. Aquí hay una versión pequeña (incompleta) que hace un trabajo decente de imponer la inmutabilidad hasta el final:

# Initialize lists
a = [1,2,3]
b = [4,5,6]
c = [7,8,9]

l = [a,b]

# We can reassign in a list 
l[0] = c

# But not a tuple
t = (a,b)
#t[0] = c -> Throws exception
# But elements can be modified
t[0][1] = 4
t
([1, 4, 3], [4, 5, 6])
# Fix it back
t[0][1] = 2

li = ImmutableObject(l)
li
[[1, 2, 3], [4, 5, 6]]
# Can't assign
#li[0] = c will fail
# Can reference
li[0]
[1, 2, 3]
# But immutability conferred on returned object too
#li[0][1] = 4 will throw an exception

# Full solution should wrap all the comparison e.g. decorators.
# Also, you'd usually want to add a hash function, i didn't put
# an interface for that.

class ImmutableObject(object):
    def __init__(self, inobj):
        self._inited = False
        self._inobj = inobj
        self._inited = True

    def __repr__(self):
        return self._inobj.__repr__()

    def __str__(self):
        return self._inobj.__str__()

    def __getitem__(self, key):
        return ImmutableObject(self._inobj.__getitem__(key))

    def __iter__(self):
        return self._inobj.__iter__()

    def __setitem__(self, key, value):
        raise AttributeError, 'Object is read-only'

    def __getattr__(self, key):
        x = getattr(self._inobj, key)
        if callable(x):
              return x
        else:
              return ImmutableObject(x)

    def __hash__(self):
        return self._inobj.__hash__()

    def __eq__(self, second):
        return self._inobj.__eq__(second)

    def __setattr__(self, attr, value):
        if attr not in  ['_inobj', '_inited'] and self._inited == True:
            raise AttributeError, 'Object is read-only'
        object.__setattr__(self, attr, value)

Puede anular setAttr en la declaración final de init. Entonces puedes construir pero no cambiar. Obviamente, aún puede anular por el objeto usint. setAttr pero en la práctica la mayoría de los idiomas tienen alguna forma de reflexión, por lo que la inmutabilidad siempre es una abstracción permeable. La inmutabilidad se trata más de evitar que los clientes violen accidentalmente el contrato de un objeto. Yo suelo:

=============================

La solución original ofrecida era incorrecta, esta se actualizó en función de los comentarios utilizando la solución de aquí

La solución original es incorrecta de una manera interesante, por lo que se incluye en la parte inferior.

===============================

class ImmutablePair(object):

    __initialised = False # a class level variable that should always stay false.
    def __init__(self, a, b):
        try :
            self.a = a
            self.b = b
        finally:
            self.__initialised = True #an instance level variable

    def __setattr__(self, key, value):
        if self.__initialised:
            self._raise_error()
        else :
            super(ImmutablePair, self).__setattr__(key, value)

    def _raise_error(self, *args, **kw):
        raise NotImplementedError("Attempted To Modify Immutable Object")

if __name__ == "__main__":

    immutable_object = ImmutablePair(1,2)

    print immutable_object.a
    print immutable_object.b

    try :
        immutable_object.a = 3
    except Exception as e:
        print e

    print immutable_object.a
    print immutable_object.b

Salida:

1
2
Attempted To Modify Immutable Object
1
2

======================================

Implementación original:

Se señaló en los comentarios, correctamente, que esto de hecho no funciona, ya que impide la creación de más de un objeto, ya que está anulando el método de clase setattr, lo que significa que no se puede crear un segundo como self.a = will fallar en la segunda inicialización.

class ImmutablePair(object):

    def __init__(self, a, b):
        self.a = a
        self.b = b
        ImmutablePair.__setattr__ = self._raise_error

    def _raise_error(self, *args, **kw):
        raise NotImplementedError("Attempted To Modify Immutable Object")

La solución básica a continuación aborda el siguiente escenario:

• __init__() se puede escribir accediendo a los atributos como de costumbre.
• DESPUÉS de que el OBJETO esté congelado solo para cambios de atributos :

La idea es anular el __setattr__método y reemplazar su implementación cada vez que se cambia el estado del objeto congelado.

Por lo tanto, necesitamos algún método ( _freeze) que almacene esas dos implementaciones y cambie entre ellas cuando se solicite.

Este mecanismo puede implementarse dentro de la clase de usuario o heredarse de una Freezerclase especial como se muestra a continuación:

class Freezer:
    def _freeze(self, do_freeze=True):
        def raise_sa(*args):            
            raise AttributeError("Attributes are frozen and can not be changed!")
        super().__setattr__('_active_setattr', (super().__setattr__, raise_sa)[do_freeze])

    def __setattr__(self, key, value):        
        return self._active_setattr(key, value)

class A(Freezer):    
    def __init__(self):
        self._freeze(False)
        self.x = 10
        self._freeze()

Como un dict

Tengo una biblioteca de código abierto donde hago las cosas de manera funcional , por lo que es útil mover los datos en un objeto inmutable. Sin embargo, no quiero tener que transformar mi objeto de datos para que el cliente interactúe con ellos. Entonces, se me ocurrió esto: te da un dict como objeto inmutable + algunos métodos auxiliares.

Gracias a Sven Marnach en su respuesta por la implementación básica de restringir la actualización y eliminación de propiedades.

import json 
# ^^ optional - If you don't care if it prints like a dict
# then rip this and __str__ and __repr__ out

class Immutable(object):

    def __init__(self, **kwargs):
        """Sets all values once given
        whatever is passed in kwargs
        """
        for k,v in kwargs.items():
            object.__setattr__(self, k, v)

    def __setattr__(self, *args):
        """Disables setting attributes via
        item.prop = val or item['prop'] = val
        """
        raise TypeError('Immutable objects cannot have properties set after init')

    def __delattr__(self, *args):
        """Disables deleting properties"""
        raise TypeError('Immutable objects cannot have properties deleted')

    def __getitem__(self, item):
        """Allows for dict like access of properties
        val = item['prop']
        """
        return self.__dict__[item]

    def __repr__(self):
        """Print to repl in a dict like fashion"""
        return self.pprint()

    def __str__(self):
        """Convert to a str in a dict like fashion"""
        return self.pprint()

    def __eq__(self, other):
        """Supports equality operator
        immutable({'a': 2}) == immutable({'a': 2})"""
        if other is None:
            return False
        return self.dict() == other.dict()

    def keys(self):
        """Paired with __getitem__ supports **unpacking
        new = { **item, **other }
        """
        return self.__dict__.keys()

    def get(self, *args, **kwargs):
        """Allows for dict like property access
        item.get('prop')
        """
        return self.__dict__.get(*args, **kwargs)

    def pprint(self):
        """Helper method used for printing that
        formats in a dict like way
        """
        return json.dumps(self,
            default=lambda o: o.__dict__,
            sort_keys=True,
            indent=4)

    def dict(self):
        """Helper method for getting the raw dict value
        of the immutable object"""
        return self.__dict__

Métodos de ayuda

def update(obj, **kwargs):
    """Returns a new instance of the given object with
    all key/val in kwargs set on it
    """
    return immutable({
        **obj,
        **kwargs
    })

def immutable(obj):
    return Immutable(**obj)

Ejemplos

obj = immutable({
    'alpha': 1,
    'beta': 2,
    'dalet': 4
})

obj.alpha # 1
obj['alpha'] # 1
obj.get('beta') # 2

del obj['alpha'] # TypeError
obj.alpha = 2 # TypeError

new_obj = update(obj, alpha=10)

new_obj is not obj # True
new_obj.get('alpha') == 10 # True