python声明“常量”的方式基本上是一个模块级别的变量:

RED = 1
GREEN = 2
BLUE = 3

然后编写类或函数。因为常量几乎都是整数，而且它们在Python中也是不可变的，所以你几乎没有机会改变它。

当然，除非显式地设置RED = 2。

编辑:添加了Python 3的示例代码

注意:另一个答案看起来提供了一个更完整的实现，类似于下面(具有更多的功能)。

首先，创建一个元类:

class MetaConst(type):
    def __getattr__(cls, key):
        return cls[key]

    def __setattr__(cls, key, value):
        raise TypeError

这可以防止静态属性被更改。然后创建另一个使用该元类的类:

class Const(object):
    __metaclass__ = MetaConst

    def __getattr__(self, name):
        return self[name]

    def __setattr__(self, name, value):
        raise TypeError

或者，如果你使用的是python3:

class Const(object, metaclass=MetaConst):
    def __getattr__(self, name):
        return self[name]

    def __setattr__(self, name, value):
        raise TypeError

这应该可以防止实例道具被更改。要使用它，继承:

class MyConst(Const):
    A = 1
    B = 2

现在，直接或通过实例访问的props应该是常量:

MyConst.A
# 1
my_const = MyConst()
my_const.A
# 1

MyConst.A = 'changed'
# TypeError
my_const.A = 'changed'
# TypeError

下面是上面的一个例子。下面是Python 3的另一个例子。

在python中，常量只是一个变量，名称全大写，单词之间用下划线分隔，

e.g

Days_in_week = 7

该值是可变的，即您可以更改它。但既然名字的规则告诉你是常数，你为什么要这么做呢?我是说，这毕竟是你的项目!

这是python中采用的方法。出于同样的原因，没有private关键字。用下划线作为名称的前缀，您就知道它是私有的。代码可以打破规则....就像程序员可以删除private关键字一样。

Python可以添加一个const关键字…但是程序员可以删除关键字，然后如果他们想要更改常量，但为什么要这样做呢?如果你想打破规则，你可以改变规则。但如果名字的意思已经很清楚了，为什么还要费心打破规则呢?

也许在某些单元测试中，对值应用更改是有意义的?看看一周8天会发生什么，尽管在现实世界中，一周的天数是不能改变的。如果语言阻止你做一个例外，如果只有这一个情况，你需要打破规则……然后您将不得不停止将它声明为常量，即使它在应用程序中仍然是常量，并且只有这个测试用例来查看如果它被更改会发生什么。

全大写的名称告诉您它是一个常量。这才是重要的。没有一种语言强制约束代码，无论如何你都可以修改。

这就是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值，这比什么都没有好。祝你好运。

也许pconst库会帮助你(github)。

$ PIP安装pconst

from pconst import const
const.APPLE_PRICE = 100
const.APPLE_PRICE = 200

“APPLE_PRICE”的常量值不可编辑。

我最近发现了一个非常简洁的更新，它会自动引发有意义的错误消息，并阻止通过__dict__访问:

class CONST(object):
    __slots__ = ()
    FOO = 1234

CONST = CONST()

# ----------

print(CONST.FOO)    # 1234

CONST.FOO = 4321              # AttributeError: 'CONST' object attribute 'FOO' is read-only
CONST.__dict__['FOO'] = 4321  # AttributeError: 'CONST' object has no attribute '__dict__'
CONST.BAR = 5678              # AttributeError: 'CONST' object has no attribute 'BAR'

我们将自己定义为一个实例，然后使用插槽来确保不能添加其他属性。这也删除了__dict__访问路由。当然，整个对象仍然可以重新定义。

编辑-原始解决方案

我可能忽略了一个技巧，但这似乎对我有用:

class CONST(object):
    FOO = 1234

    def __setattr__(self, *_):
        pass

CONST = CONST()

#----------

print CONST.FOO    # 1234

CONST.FOO = 4321
CONST.BAR = 5678

print CONST.FOO    # Still 1234!
print CONST.BAR    # Oops AttributeError

创建实例允许神奇的__setattr__方法介入并拦截设置FOO变量的尝试。如果您愿意，可以在这里抛出异常。通过类名实例化实例可以防止直接通过类进行访问。

对于一个值来说，这非常麻烦，但是您可以将许多值附加到CONST对象上。有一个上层的类，类名似乎也有点难看，但我认为它总体上是相当简洁的。