注意:这是一个糟糕的想法和糟糕的实现。此外，它只适用于最后的小例子，一个完整的实现将意味着大量的工作，这是我太懒了。而且，在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'

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

你可以使用Tuple常量变量:

tuple是一个有序且不可更改的集合

my_tuple = (1, "Hello", 3.4)
print(my_tuple[0])

注意:这是一个糟糕的想法和糟糕的实现。此外，它只适用于最后的小例子，一个完整的实现将意味着大量的工作，这是我太懒了。而且，在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'

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

在Python中，人们使用命名约定，例如私有方法使用__method，受保护方法使用_method。

所以用同样的方式，你可以简单地将常量声明为全大写，例如:

MY_CONSTANT = "one"

如果你想让这个常量永远不变，你可以挂钩到属性访问并做一些技巧，但更简单的方法是声明一个函数:

def MY_CONSTANT():
    return "one"

唯一的问题是，在任何地方都必须执行MY_CONSTANT()，但MY_CONSTANT = "one"在Python中是正确的方式(通常)。

你也可以使用namedtuple()来创建常量:

>>> from collections import namedtuple
>>> Constants = namedtuple('Constants', ['pi', 'e'])
>>> constants = Constants(3.14, 2.718)
>>> constants.pi
3.14
>>> constants.pi = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

没有完美的方法可以做到这一点。据我所知，大多数程序员只是将标识符大写，所以PI = 3.142可以很容易地理解为一个常数。

另一方面，如果你想要一个像常数一样的东西，我不确定你能找到它。无论你做什么，总会有一些方法来编辑“常数”，所以它不是一个真正的常数。这里有一个非常简单的例子:

def define(name, value):
  if (name + str(id(name))) not in globals():
    globals()[name + str(id(name))] = value

def constant(name):
  return globals()[name + str(id(name))]

define("PI",3.142)

print(constant("PI"))

这看起来像是一个php风格的常量。

在现实中，所有需要改变值的人是这样的:

globals()["PI"+str(id("PI"))] = 3.1415

这对于你在这里找到的所有其他解决方案都是一样的——即使是那些创建类并重新定义set属性方法的聪明的解决方案——总有一种方法可以绕过它们。Python就是这样的。

我的建议是避免所有的麻烦，将标识符大写。它不是一个合适的常数，但也没有什么合适的常数。

您可以将一个常量包装在numpy数组中，将其标记为仅写，并始终通过下标0调用它。

import numpy as np

# declare a constant
CONSTANT = 'hello'

# put constant in numpy and make read only
CONSTANT = np.array([CONSTANT])
CONSTANT.flags.writeable = False
# alternatively: CONSTANT.setflags(write=0)

# call our constant using 0 index    
print 'CONSTANT %s' % CONSTANT[0]

# attempt to modify our constant with try/except
new_value = 'goodbye'
try:
    CONSTANT[0] = new_value
except:
    print "cannot change CONSTANT to '%s' it's value '%s' is immutable" % (
        new_value, CONSTANT[0])

# attempt to modify our constant producing ValueError
CONSTANT[0] = new_value



>>>
CONSTANT hello
cannot change CONSTANT to 'goodbye' it's value 'hello' is immutable
Traceback (most recent call last):
  File "shuffle_test.py", line 15, in <module>
    CONSTANT[0] = new_value
ValueError: assignment destination is read-only

当然，这只保护numpy的内容，而不是变量“CONSTANT”本身;你仍然可以:

CONSTANT = 'foo'

和CONSTANT会改变，然而，这将很快抛出TypeError第一次在脚本中调用CONSTANT[0]。

尽管……我想如果你在某个时候把它改成

CONSTANT = [1,2,3]

现在你不会再得到TypeError了。嗯……

https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.setflags.html