使用namedtuple有一种更干净的方法:

from collections import namedtuple


def make_consts(name, **kwargs):
    return namedtuple(name, kwargs.keys())(**kwargs)

使用的例子

CONSTS = make_consts("baz1",
                     foo=1,
                     bar=2)

使用这种方法，您可以为常数命名空间。

我们可以创建一个描述符对象。

class Constant:
  def __init__(self,value=None):
    self.value = value
  def __get__(self,instance,owner):
    return self.value
  def __set__(self,instance,value):
    raise ValueError("You can't change a constant")

1)如果我们想在实例级使用常量，那么:

class A:
  NULL = Constant()
  NUM = Constant(0xFF)

class B:
  NAME = Constant('bar')
  LISTA = Constant([0,1,'INFINITY'])

>>> obj=A()
>>> print(obj.NUM)  #=> 255
>>> obj.NUM =100

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: You can't change a constant

2)如果我们只想在类级别上创建常量，我们可以使用元类作为常量(描述符对象)的容器;所有下降的类将继承我们的常量(我们的描述符对象)，没有任何可以修改的风险。

# metaclass of my class Foo
class FooMeta(type): pass

# class Foo
class Foo(metaclass=FooMeta): pass

# I create constants in my metaclass
FooMeta.NUM = Constant(0xff)
FooMeta.NAME = Constant('FOO')

>>> Foo.NUM   #=> 255
>>> Foo.NAME  #=> 'FOO'
>>> Foo.NUM = 0 #=> ValueError: You can't change a constant

如果我创建一个Foo的子类，这个类将继承常量，而不可能修改它们

class Bar(Foo): pass

>>> Bar.NUM  #=> 255
>>> Bar.NUM = 0  #=> ValueError: You can't change a constant

在其他语言中没有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选择这些名称的事实，并使用应用于该作用域的所有本地定义的**(双星号)创建一个关键字字典，将参数传递给属性函数

你可以使用StringVar或IntVar等，你的常量是const_val

val = 'Stackoverflow'
const_val = StringVar(val)
const.trace('w', reverse)

def reverse(*args):
    const_val.set(val)

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

e.g

Days_in_week = 7

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

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

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

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

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

这就是python的哲学。

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

class MyFinalProperty(object):

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

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