属性是创建常量的一种方法。你可以通过声明一个getter属性来做到这一点，但忽略setter。例如:

class MyFinalProperty(object):

    @property
    def name(self):
        return "John"

您可以看看我写的一篇文章，以找到更多使用Python属性的方法。

您可以使用namedtuple作为一种变通方法来有效地创建一个常量，其工作方式与Java中的静态final变量(Java“常量”)相同。作为一种变通方法，它是优雅的。(更优雅的方法是简单地改进Python语言——什么样的语言可以让您重新定义math.pi?——但我跑题了。)

(当我写这篇文章时，我意识到这个问题的另一个答案提到了namedtuple，但我将在这里继续，因为我将展示一种更接近于您在Java中所期望的语法，因为不需要像namedtuple那样创建命名类型。)

跟着你的例子，你会记得在Java中，我们必须在某个类中定义常量;因为你没有提到类名，我们称它为Foo。下面是Java类:

public class Foo {
  public static final String CONST_NAME = "Name";
}

这里是等效的Python。

from collections import namedtuple
Foo = namedtuple('_Foo', 'CONST_NAME')('Name')

我想在这里补充的关键点是，您不需要单独的Foo类型(“匿名命名元组”会很好，尽管这听起来有点矛盾)，所以我们将命名元组命名为_Foo，这样它就不会转义到导入模块中。

这里的第二点是，我们立即创建了nametuple的一个实例，称其为Foo;没有必要在单独的步骤中执行此操作(除非您想这样做)。现在你可以做你在Java中可以做的事情:

>>> Foo.CONST_NAME
'Name'

但你不能给它赋值:

>>> Foo.CONST_NAME = 'bar'
…
AttributeError: can't set attribute

确认:我认为我发明了命名元组方法，但后来我看到其他人给出了类似的答案(尽管不那么紧凑)。然后我还注意到Python中的“命名元组”是什么?，这就指出了sys。version_info现在是一个命名元组，所以可能Python标准库早就提出了这个想法。

注意，不幸的是(这仍然是Python)，你可以完全删除整个Foo赋值:

>>> Foo = 'bar'

(facepalm)

但至少我们阻止了福星。CONST_NAME值，这比什么都没有好。祝你好运。

在Python中，不能将变量或值声明为常量。

为了让程序员知道变量是常量，通常用大写:

CONST_NAME = "Name"

要在常量发生变化时引发异常，请参阅Alex Martelli的《Python中的常量》。注意，这在实践中并不常用。

从Python 3.8开始，有一个类型。最后一个变量注释，它将告诉静态类型检查器(如myypy)您的变量不应该被重新分配。这是最接近于Java的final。然而，它实际上并不能阻止重新分配:

from typing import Final

a: Final[int] = 1

# Executes fine, but mypy will report an error if you run mypy on this:
a = 2

你可以通过collections.namedtuple和itertools来实现:

import collections
import itertools
def Constants(Name, *Args, **Kwargs):
  t = collections.namedtuple(Name, itertools.chain(Args, Kwargs.keys()))
  return t(*itertools.chain(Args, Kwargs.values()))

>>> myConstants = Constants('MyConstants', 'One', 'Two', Three = 'Four')
>>> print myConstants.One
One
>>> print myConstants.Two
Two
>>> print myConstants.Three
Four
>>> myConstants.One = 'Two'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

注意:这是一个糟糕的想法和糟糕的实现。此外，它只适用于最后的小例子，一个完整的实现将意味着大量的工作，这是我太懒了。而且，在Python 3.8之前，审计钩子可能是不可用的。

我基本上回答了另一个问题，结果和这个问题有关。它的思想是，你可以利用审计钩子来捕捉每一行的执行，解析代码对象，如果它满足某些条件(例如某个前缀并且已经定义过一次)，你可以抛出一个错误。

你可能不得不支持其他赋值类型(例如，对于导入的东西，可能对于函数内部的局部变量，解包等)，不使用全局变量，因为字典可以很容易地修改，实际上调查这是否安全，接受这个实现将对你的整个应用程序造成的性能损失，确保它在REPL之外工作，在ipython内部工作，等等等等。不管怎样，我们开始吧:

>>> import sys
>>> import ast
>>> import dis
>>> import types
>>> 
>>> 
>>> def hook(name, tup):
...     if name == "exec" and tup:
...         if tup and isinstance(tup[0], types.CodeType):
...             code = tup[0]
...             store_instruction_arg = None
...             instructions = [dis.opname[op] for op in code.co_code]
...             
...             for i, instruction in enumerate(instructions):
...                 if instruction == "STORE_NAME":
...                     store_instruction_arg = code.co_code[i + 1]
...                     break
...             
...             if store_instruction_arg is not None:
...                 var_name = code.co_names[store_instruction_arg]
...                 if var_name in globals():
...                     raise Exception("Cannot re-assign variable")
... 
>>> 
>>> sys.addaudithook(hook)
>>> 
>>> a = '123'
>>> a = 456
Traceback (most recent call last):
  File "<stdin>", line 16, in hook
Exception: Cannot re-assign variable
>>> 
>>> a
'123'

如果你以这种方式结束，你不应该，除了修复和泛化代码，你可能会想要找到一种方法，只让一些东西不变，例如，只有那些有特殊前缀的对象或只有对象有一些注释。

在其他语言中没有const关键字，但是可以创建一个具有“getter函数”来读取数据，但没有“setter函数”来重写数据的Property。这从本质上保护标识符不被更改。

下面是一个使用class属性的替代实现:

请注意，对于想了解常量的读者来说，代码远非简单。见下面的解释。

def constant(f):
    def fset(self, value):
        raise TypeError
    def fget(self):
        return f()
    return property(fget, fset)

class _Const(object):
    @constant
    def FOO():
        return 0xBAADFACE
    @constant
    def BAR():
        return 0xDEADBEEF

CONST = _Const()

print(hex(CONST.FOO))  # -> '0xbaadfaceL'

CONST.FOO = 0
##Traceback (most recent call last):
##  File "example1.py", line 22, in <module>
##    CONST.FOO = 0
##  File "example1.py", line 5, in fset
##    raise TypeError
##TypeError

代码的解释:

定义一个接受表达式的函数常量，并使用它来构造一个“getter”——一个仅返回表达式值的函数。 setter函数引发TypeError，因此它是只读的 使用我们刚刚创建的常量函数作为装饰来快速定义只读属性。

用另一种更传统的方式:

(代码相当棘手，下面有更多解释)

class _Const(object):
    def FOO():
        def fset(self, value):
            raise TypeError
        def fget(self):
            return 0xBAADFACE
        return property(**locals())
    FOO = FOO()  # Define property.

CONST = _Const()

print(hex(CONST.FOO))  # -> '0xbaadfaceL'

CONST.FOO = 0
##Traceback (most recent call last):
##  File "example2.py", line 16, in <module>
##    CONST.FOO = 0
##  File "example2.py", line 6, in fset
##    raise TypeError
##TypeError

要定义标识符FOO，首先定义两个函数(fset, fget -名称由我选择)。 然后使用内置的属性函数构造一个可以“set”或“get”的对象。 注意属性函数的前两个参数名为fset和fget。 利用我们为自己的getter和setter选择这些名称的事实，并使用应用于该作用域的所有本地定义的**(双星号)创建一个关键字字典，将参数传递给属性函数