En Python, ¿cómo puedo crear atributos no asignables (como los marcados con `final` en Java)?

¿Hay algo en Python que funcione como el final palabra clave en Java, es decir, para no permitir la asignación a un atributo específico de las instancias de una clase, después de que se hayan creado esas instancias? No pude encontrar nada como esto en la documentación.

Estoy creando una instantánea de un objeto (utilizado para la restauración si algo falla); una vez que se asigna esta variable de respaldo, no debe modificarse; finalLa función similar en Python sería buena para esto.

No hay final equivalente en Python. Para crear campos de solo lectura de instancias de clase, puede usar el propiedad función, o podría hacer algo como esto:

class WriteOnceReadWhenever:
    def __setattr__(self, attr, value):
        if hasattr(self, attr):
            raise Exception("Attempting to alter read-only value")
    
        self.__dict__[attr] = value

También tenga en cuenta que mientras hay @typing.final a partir de Python 3.8 (como menciona Cerno), eso no en realidad hacer valores final en tiempo de ejecución.

Tener una variable en Java ser final básicamente significa que una vez que asigna una variable, no puede reasignar esa variable para que apunte a otro objeto. En realidad, no significa que el objeto no se pueda modificar. Por ejemplo, el siguiente código Java funciona perfectamente bien:

public final List<String> messages = new LinkedList<String>();

public void addMessage()
{
    messages.add("Hello World!");  // this mutates the messages list
}

pero lo siguiente ni siquiera compilaría:

public final List<String> messages = new LinkedList<String>();

public void changeMessages()
{
    messages = new ArrayList<String>();  // can't change a final variable
}

Entonces tu pregunta es sobre si final existe en Python. No es asi.

Sin embargo, Python tiene estructuras de datos inmutables. Por ejemplo, si bien puede mutar un listno puedes mutar un tuple. Puedes mutar un set pero no un frozensetetc.

Mi consejo sería simplemente no preocuparse por hacer cumplir la no mutación a nivel de idioma y simplemente concentrarse en asegurarse de no escribir ningún código que mute estos objetos después de que se asignen.

Pitón 3.8 (a través de PEP 591) agrega Final variables, funciones, métodos y clases. Aquí hay algunas formas de usarlo:

@final Decorador (clases, métodos)

from typing import final

@final
class Base:
    # Cannot inherit from Base

class Base:
    @final
    def foo(self):
        # Cannot override foo in subclass

Final anotación

from typing import Final

PI: Final[float] = 3.14159     # Cannot set PI to another value
KM_IN_MILES: Final = 0.621371  # Type annotation is optional

class Foo:
    def __init__(self):
        self.bar: Final = "baz"   # Final instance attributes only allowed in __init__

Tenga en cuenta que, al igual que otras sugerencias de escritura, no le impiden anular los tipos, pero ayudan a que los linters o IDE le adviertan sobre el uso incorrecto de tipos.

Una variable de asignación única es un problema de diseño. Usted diseña su aplicación de manera que la variable se establezca una vez y solo una vez.

Sin embargo, si desea verificar su diseño en tiempo de ejecución, puede hacerlo con un envoltorio alrededor del objeto.

class OnePingOnlyPleaseVassily(object):
    def __init__(self):
        self.value = None
    def set(self, value):
        if self.value is not None:
            raise Exception("Already set.")
        self.value = value

someStateMemo = OnePingOnlyPleaseVassily()
someStateMemo.set(aValue) # works
someStateMemo.set(aValue) # fails

Eso es torpe, pero detectará problemas de diseño en tiempo de ejecución.

No existe tal cosa. En general, la actitud de Python es “si no quieres que esto se modifique, simplemente no lo modifiques”. Es poco probable que los clientes de una API solo hurguen en sus partes internas no documentadas de todos modos.

Supongo que podría solucionar esto usando tuplas o tuplas con nombre para las partes relevantes de su modelo, que son intrínsecamente inmutables. Eso todavía no ayuda con ninguna parte de su modelo que tenga que ser mutable, por supuesto.

puedes simular algo así a través del protocolo descriptorya que permite definir la lectura y configuración de una variable de la forma que se desee.

class Foo(object):

  @property
  def myvar(self):
     # return value here

  @myvar.setter
  def myvar(self, newvalue):
     # do nothing if some condition is met

a = Foo()
print a.myvar
a.myvar = 5 # does nothing if you don't want to

A partir de 2019 y PEP 591Python tiene un Final tipo. No estará disponible en la biblioteca estándar hasta el lanzamiento de Python 3.8, pero hasta entonces puede usarlo a través de la extensiones de escritura biblioteca. no funcionará como final funciona en Java, ya que Python sigue siendo un lenguaje de tipo dinámico. Pero si lo usa junto con un verificador de tipo estático como mipy te dará beneficios muy similares.

También hay una final decorador que se puede aplicar para marcar métodos de clase como finales y evitar que se anulen. Nuevamente, esto solo se verifica en el “tiempo de compilación”, por lo que deberá incluir un verificador de tipo estático en su flujo de trabajo.