la finale de " mot équivalent pour les variables en Python?

Avoir une variable en Java être final signifie qu'une fois que vous affecter à une variable, vous ne pouvez pas réaffecter cette variable à point à un autre objet. Il ne fait signifie pas que l'objet ne peut pas être modifié. Par exemple, le code Java suivant fonctionne parfaitement bien:

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

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

mais la suite ne serait même pas compiler:

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

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

Si votre question est de savoir si final existe en Python. Il ne le fait pas.

Cependant, Python n'ont immuable des structures de données. Par exemple, alors que vous pouvez muter un list, vous ne pouvez pas muter un tuple. Vous pouvez muter un set mais pas un frozenset, etc.

Mon conseil serait de ne pas m'en inquiéter respect des obligations de non-mutation au niveau du langage et de simplement se concentrer sur assurez-vous de ne pas écrire du code qui transforme ces objets une fois qu'ils sont affectés.

Un attribuez-une fois que la variable est un problème de conception. De la conception de votre application de sorte que la variable est définie une fois et une fois seulement.

Toutefois, si vous souhaitez au moment de l'exécution de la vérification de votre conception, vous pouvez le faire avec un wrapper autour de l'objet.

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

C'est maladroit, mais il permet de détecter les problèmes de conception au moment de l'exécution.

Python n'a pas d'équivalent de "finale". Il n'a pas de "public" et "protégée", sauf par convention de nommage. Ce n'est pas que "bondage et discipline".

vous pouvez simuler quelque chose comme ça à travers le descripteur de protocole, car il permet de définir la lecture et de définition d'une variable de la façon dont vous le souhaitez.

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

À compter de 2019 et PEP 591, Python est un Final type. Il ne sera pas disponible dans la bibliothèque standard jusqu'à la sortie de Python 3.8, mais jusqu'alors, vous pouvez l'utiliser via le la saisie des extensions de la bibliothèque. Il ne fonctionne pas comme final fonctionne en Java bien que Python est encore un typées dynamiquement de la langue. Mais si vous l'utilisez avec un type statique checker comme mypy il vous donnera de très prestations similaires.

Il y a aussi un final décorateur qui peuvent être appliquées pour marquer les méthodes de la classe comme définitive et de l'empêcher d'être remplacé. Là encore, c'est seulement vérifié à la "compilation", de sorte que vous devrez inclure un type statique pion dans votre flux de travail.

Python, en effet, ne dispose pas d'un type final, il n'ont immuable types, tels que les n-uplets, mais c'est autre chose.

Certains des autres Réponses ici les classes de plein de pseudo variables final et je préfère ma classe à seulement quelques types, donc je vous suggère d'utiliser un descripteur de créer la finale type:

from typing import TypeVar, Generic, Type

T = TypeVar('T')

class FinalProperty(Generic[T]):
    def __init__(self, value: T):
        self.__value = value
    def __get__(self, instance: Type, owner) -> T:
        return self.__value
    def __set__(self, instance: Type, value: T) -> None:
        raise ValueError("Final types can't be set")

Si vous utilisez cette classe comme ceci:

class SomeJob:
    FAILED = FinalProperty[str]("Failed")

Alors vous ne serez pas en mesure de définir cette variable dans toute instance de cette classe.
Malheureusement, comme avec le WriteOnceReadWhenever de réponse, vous pouvez toujours définir la variable de classe.

job = SomeJob()
job.FAILED = "Error, this will trigger the ValueError"
SomeJob.FAILED = "However this still works and breaks the protection afterwards"