blocks|key|3111214|text|不没有。在Python中，不能将变量或值声明为常量。只是不要改变它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3111215|如果您在某个类中，则等效项为：|3111216|class+Foo(object):
++++CONST_NAME+=+"Name"|code-block|syntax|javascript|3111217|如果不是，它只是|3111218|CONST_NAME+=+"Name"|3111219|但是您可能想看一下Alex+Martelli编写的代码片段Constants+in+Python。|offset|length|3111220|3111221|从Python3.8开始，有一个typing.Final变量注释，它会告诉静态类型检查器(比如mypy)你的变量不应该被重新赋值。这是与Java的final最接近的等价物。但是，it+实际上并不会阻止重新分配|style|CODE|BOLD|3111222|from+typing+import+Final

a:+Final+=+1

#+Executes+fine,+but+mypy+will+report+an+error+if+you+run+mypy+on+this:
a+=+2|3111223|entityMap|0|LINK|mutability|MUTABLE|url|http://web.archive.org/web/20100523132518/http://code.activestate.com/recipes/65207-constants-in-python/?in=user-97991|1|https://docs.python.org/3/library/typing.html#typing.Final^0|0|0|0|0|0|T|J|0|0|0|G|C|21|5|2K|C|G|C|1|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1D|8|@]|9|@$O|1E|P|1F|1|1G]]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1I|8|@$O|1J|P|1K|T|U]|$O|1L|P|1M|T|U]|$O|1N|P|1O|T|V]]|9|@$O|1P|P|1Q|1|1R]]|A|$]]|$1|W|3|X|5|F|7|1S|8|@]|9|@]|A|$G|H]]|$1|Y|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

No there is not. You cannot declare a variable or value as constant in Python. Just don't change it.
If you are in a class, the equivalent would be:
<pre><code>class Foo(object):
 CONST_NAME = &quot;Name&quot;
</code></pre>
if not, it is just
<pre><code>CONST_NAME = &quot;Name&quot;
</code></pre>
But you might want to have a look at the code snippet <a href="http://web.archive.org/web/20100523132518/http://code.activestate.com/recipes/65207-constants-in-python/?in=user-97991" rel="noreferrer">Constants in Python</a> by Alex Martelli.
<hr />
As of Python 3.8, there's a <a href="https://docs.python.org/3/library/typing.html#typing.Final" rel="noreferrer"><code>typing.Final</code></a> variable annotation that will tell static type checkers (like mypy) that your variable shouldn't be reassigned. This is the closest equivalent to Java's <code>final</code>. However, it does not actually prevent reassignment:
<pre><code>from typing import Final

a: Final = 1

# Executes fine, but mypy will report an error if you run mypy on this:
a = 2
</code></pre>

blocks|key|1702661|text|在Python中，人们使用命名约定，例如私有方法使用__method，保护方法使用_method，而不是使用语言强制执行某些东西。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1702662|因此，以同样的方式，您可以简单地将常量声明为所有大写，例如|1702663|MY_CONSTANT+=+"one"|code-block|syntax|javascript|1702664|如果您希望这个常量永远不会改变，您可以挂钩到属性访问并执行一些技巧，但更简单的方法是声明一个函数|1702665|def+MY_CONSTANT():
++++return+"one"|1702666|唯一的问题是你必须做MY_CONSTANT()，但是在python中MY_CONSTANT+=+"one"+(通常)是正确的方式。|1702667|您还可以使用namedtuple创建常量：|1702668|>>>+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|1702669|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/2/library/collections.html#collections.namedtuple^0|Q|8|15|7|0|0|0|0|0|Y|J|0|6|A|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|U|3|V|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|W|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

In Python instead of language enforcing something, people use naming conventions e.g <code>__method</code> for private methods and using <code>_method</code> for protected methods.

So in same manner you can simply declare the constant as all caps e.g.

<pre><code>MY_CONSTANT = "one"
</code></pre>

If you want that this constant never changes, you can hook into attribute access and do tricks, but a simpler approach is to declare a function

<pre><code>def MY_CONSTANT():
 return "one"
</code></pre>

Only problem is everywhere you will have to do MY_CONSTANT(), but again <code>MY_CONSTANT = "one"</code> is the correct way in python(usually).

You can also use <a href="http://docs.python.org/2/library/collections.html#collections.namedtuple" rel="noreferrer">namedtuple</a> to create constants:

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

blocks|key|1115582|text|Pythonic中声明“常量”的方式基本上是一个模块级变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1115583|RED+=+1
GREEN+=+2
BLUE+=+3|code-block|syntax|javascript|1115584|然后编写您的类或函数。由于常量几乎总是整数，而且它们在Python中也是不可变的，因此更改它的机会很小。|1115585|当然，除非您显式设置了RED+=+2。|offset|length|style|CODE|1115586|entityMap^0|0|0|0|B|7|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The Pythonic way of declaring "constants" is basically a module level variable:

<pre><code>RED = 1
GREEN = 2
BLUE = 3
</code></pre>

And then write your classes or functions. Since constants are almost always integers, and they are also immutable in Python, you have a very little chance of altering it.

Unless, of course, if you explicitly set <code>RED = 2</code>.

blocks|key|1115609|text|在其他语言中没有const关键字，但是可以创建一个属性，即有一个"getter+function"来读取数据，但是没有"setter+function"来重写数据。这实际上保护了标识符不会被更改。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|1115610|下面是一个使用class属性的替代实现：|1115611|请注意，对于想要了解常量的读者来说，代码远非易事。请参阅下面的说明|1115612|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+CONST.FOO
##3131964110

CONST.FOO+=+0
##Traceback+(most+recent+call+last):
##++++...
##++++CONST.FOO+=+0
##TypeError:+None|code-block|syntax|javascript|1115613|代码说明：|1115614|expression.|1115615|The+setter定义一个接受表达式的函数constant，并使用它来构造一个“TypeError”-一个只返回expression.|unordered-list-item|1115616|
|1115617|The+setter函数的值的函数引发一个setter，因此它是我们刚刚创建的作为装饰的constantTypeError，以快速定义只读属性。|1115618|1115619|1115620|以及其他一些更老式的方式：|1115621|(代码相当棘手，下面有更多解释)|1115622|class+_Const(object):
++++@apply
++++def+FOO():
++++++++def+fset(self,+value):
++++++++++++raise+TypeError
++++++++def+fget(self):
++++++++++++return+0xBAADFACE
++++++++return+property(**locals())

CONST+=+_Const()

print+CONST.FOO
##3131964110

CONST.FOO+=+0
##Traceback+(most+recent+call+last):
##++++...
##++++CONST.FOO+=+0
##TypeError:+None|1115623|请注意，@apply修饰符似乎已被弃用。|1115624|使用内置的property函数来构造一个可以是“”或“|1115625|”的对象。|ordered-list-item|1115626|注意property函数的前两个参数分别命名为fset和fget。|1115627|利用我们为自己的getter和setter选择了这些名称的事实，并使用应用于该作用域的所有本地定义的**+(双星号)创建了一个关键字字典，以将参数传递给property函数|1115628|1115629|entityMap^0|8|5|T|K|1L|J|2A|G|0|0|0|0|0|5|0|0|M|8|0|0|18|8|0|0|0|0|0|0|0|5|8|0|0|2|8|N|4|S|4|0|24|8|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|D]|$9|1R|A|1S|B|D]|$9|1T|A|1U|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1V|8|@]|E|@]|F|$]]|$1|I|3|J|5|6|7|1W|8|@]|E|@]|F|$]]|$1|K|3|L|5|M|7|1X|8|@]|E|@]|F|$N|O]]|$1|P|3|Q|5|6|7|1Y|8|@$9|1Z|A|20|B|D]]|E|@]|F|$]]|$1|R|3|S|5|6|7|21|8|@]|E|@]|F|$]]|$1|T|3|U|5|V|7|22|8|@$9|23|A|24|B|C]]|E|@]|F|$]]|$1|W|3|X|5|6|7|25|8|@]|E|@]|F|$]]|$1|Y|3|Z|5|V|7|26|8|@$9|27|A|28|B|C]]|E|@]|F|$]]|$1|10|3|-4|5|6|7|29|8|@]|E|@]|F|$]]|$1|11|3|-4|5|6|7|2A|8|@]|E|@]|F|$]]|$1|12|3|13|5|6|7|2B|8|@]|E|@]|F|$]]|$1|14|3|15|5|6|7|2C|8|@]|E|@]|F|$]]|$1|16|3|17|5|M|7|2D|8|@]|E|@]|F|$N|O]]|$1|18|3|19|5|6|7|2E|8|@]|E|@]|F|$]]|$1|1A|3|1B|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|E|@]|F|$]]|$1|1C|3|1D|5|1E|7|2I|8|@]|E|@]|F|$]]|$1|1F|3|1G|5|1E|7|2J|8|@$9|2K|A|2L|B|C]|$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]]|E|@]|F|$]]|$1|1H|3|1I|5|1E|7|2Q|8|@$9|2R|A|2S|B|C]]|E|@]|F|$]]|$1|1J|3|-4|5|6|7|2T|8|@]|E|@]|F|$]]|$1|1K|3|-4|5|6|7|2U|8|@]|E|@]|F|$]]]|1L|$]]

There's no <code>const</code> keyword as in other languages, however it is possible to create a Property that has a "getter function" to read the data, but no "setter function" to re-write the data. This essentially protects the identifier from being changed.

Here is an alternative implementation using class property:

Note that the code is far from easy for a reader wondering about constants. See explanation below

<pre><code>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 CONST.FOO
##3131964110

CONST.FOO = 0
##Traceback (most recent call last):
## ...
## CONST.FOO = 0
##TypeError: None
</code></pre>

Code Explanation:

<ol>
<li>Define a function <code>constant</code> that takes an expression, and uses it to construct a "getter" - a function that solely returns the value of the expression.</li>
<li>The setter function raises a TypeError so it's read-only</li>
<li>Use the <code>constant</code> function we just created as a decoration to quickly define read-only properties.</li>
</ol>

<hr>

And in some other more old-fashioned way:

(The code is quite tricky, more explanations below)

<pre><code>class _Const(object):
 @apply
 def FOO():
 def fset(self, value):
 raise TypeError
 def fget(self):
 return 0xBAADFACE
 return property(**locals())

CONST = _Const()

print CONST.FOO
##3131964110

CONST.FOO = 0
##Traceback (most recent call last):
## ...
## CONST.FOO = 0
##TypeError: None
</code></pre>

Note that the @apply decorator seems to be deprecated.

<ol>
<li>To define the identifier FOO, firs define two functions (fset, fget - the names are at my choice).</li>
<li>Then use the built-in <code>property</code> function to construct an object that can be "set" or "get".</li>
<li>Note hat the <code>property</code> function's first two parameters are named <code>fset</code> and <code>fget</code>. </li>
<li>Use the fact that we chose these very names for our own getter &amp; setter and create a keyword-dictionary using the ** (double asterisk) applied to all the local definitions of that scope to pass parameters to the <code>property</code> function</li>
</ol>

blocks|key|1119163|text|Python字典是可变的，因此它们似乎不是声明常量的好方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1119164|>>>+constants+=+{"foo":1,+"bar":2}
>>>+print+constants
{'foo':+1,+'bar':+2}
>>>+constants["bar"]+=+3
>>>+print+constants
{'foo':+1,+'bar':+3}|code-block|syntax|javascript|1119165|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Python dictionaries are mutable, so they don't seem like a good way to declare constants:

<pre><code>&gt;&gt;&gt; constants = {"foo":1, "bar":2}
&gt;&gt;&gt; print constants
{'foo': 1, 'bar': 2}
&gt;&gt;&gt; constants["bar"] = 3
&gt;&gt;&gt; print constants
{'foo': 1, 'bar': 3}
</code></pre>

blocks|key|1115652|text|我会创建一个覆盖基本object类的__setattr__方法的类，并用它包装我的常量，注意我使用的是Python2.7：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1115653|class+const(object):
++++def+__init__(self,+val):
++++++++super(const,+self).__setattr__("value",+val)
++++def+__setattr__(self,+name,+val):
++++++++raise+ValueError("Trying+to+change+a+constant+value",+self)|code-block|syntax|javascript|1115654|要换行字符串，请执行以下操作：|1115655|>>>+constObj+=+const("Try+to+change+me")
>>>+constObj.value
'Try+to+change+me'
>>>+constObj.value+=+"Changed"
Traceback+(most+recent+call+last):
+++...
ValueError:+Trying+to+change+a+constant+value
>>>+constObj2+=+const("+or+not")
>>>+mutableObj+=+constObj.value+%2B+constObj2.value
>>>+mutableObj+#just+a+string
'Try+to+change+me+or+not'|1115656|它非常简单，但是如果您想像使用非常数对象一样使用常量(不使用constObj.value)，它将会更密集一些。这可能会导致问题，所以最好让.value显示并知道您正在使用常量进行操作(虽然可能不是最“pythonic”的方式)。|1115657|entityMap^0|I|B|0|0|0|0|1X|6|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

I would make a class that overrides the <code>__setattr__</code> method of the base object class and wrap my constants with that, note that I'm using python 2.7:

<pre><code>class const(object):
 def __init__(self, val):
 super(const, self).__setattr__("value", val)
 def __setattr__(self, name, val):
 raise ValueError("Trying to change a constant value", self)
</code></pre>

To wrap a string:

<pre><code>&gt;&gt;&gt; constObj = const("Try to change me")
&gt;&gt;&gt; constObj.value
'Try to change me'
&gt;&gt;&gt; constObj.value = "Changed"
Traceback (most recent call last):
 ...
ValueError: Trying to change a constant value
&gt;&gt;&gt; constObj2 = const(" or not")
&gt;&gt;&gt; mutableObj = constObj.value + constObj2.value
&gt;&gt;&gt; mutableObj #just a string
'Try to change me or not'
</code></pre>

It's pretty simple, but if you want to use your constants the same as you would a non-constant object (without using constObj.value), it will be a bit more intensive. It's possible that this could cause problems, so it might be best to keep the <code>.value</code> to show and know that you are doing operations with constants (maybe not the most 'pythonic' way though).

blocks|key|3111487|text|扩展Raufio的答案，添加一个__repr__来返回值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3111488|class+const(object):
++++def+__init__(self,+val):
++++++++super(const,+self).__setattr__("value",+val)
++++def+__setattr__(self,+name,+val):
++++++++raise+ValueError("Trying+to+change+a+constant+value",+self)
++++def+__repr__(self):
++++++++return+('{0}'.format(self.value))

dt+=+const(float(0.01))
print+dt|code-block|syntax|javascript|3111489|然后这个对象的行为就更像你所期望的了，你可以直接访问它而不是'.value‘|3111490|entityMap^0|G|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Extending Raufio's answer, add a <code>__repr__</code> to return the value.

<pre><code>class const(object):
 def __init__(self, val):
 super(const, self).__setattr__("value", val)
 def __setattr__(self, name, val):
 raise ValueError("Trying to change a constant value", self)
 def __repr__(self):
 return ('{0}'.format(self.value))

dt = const(float(0.01))
print dt
</code></pre>

then the object behaves a little more like you might expect, you can access it directly rather then '.value'

blocks|key|3111539|text|除了两个最好的答案(只使用大写名称的变量，或者使用属性将值设为只读)，我还想提一下，为了实现命名常量，可以使用元类。我在GitHub中提供了一个使用元类的非常简单的解决方案，如果您想让值更多地了解它们的类型/名称，它可能会很有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3111540|>>>+from+named_constants+import+Constants
>>>+class+Colors(Constants):
...+++++black+=+0
...+++++red+=+1
...+++++white+=+15
...
>>>+c+=+Colors.black
>>>+c+==+0
True
>>>+c
Colors.black
>>>+c.name()
'black'
>>>+Colors(0)+is+c
True|code-block|syntax|javascript|3111541|这是稍微高级一点的Python，但仍然非常容易使用和方便。(该模块还有一些其他功能，包括常量是只读的，请参阅其自述文件。)|3111542|在不同的存储库中都有类似的解决方案，但据我所知，它们要么缺少我期望的常量的基本特性之一(比如常量，或者是任意类型)，要么它们添加了一些深奥的特性，这使得它们不那么普遍适用。但是YMMV，我将非常感谢您的反馈。:-)|3111543|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/hmeine/named_constants^0|1O|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

In addition to the two top answers (just use variables with UPPERCASE names, or use properties to make the values read-only), I want to mention that it's possible to use metaclasses in order to implement named constants. I provide a very simple solution using metaclasses at <a href="https://github.com/hmeine/named_constants">GitHub</a> which may be helpful if you want the values to be more informative about their type/name:

<pre><code>&gt;&gt;&gt; from named_constants import Constants
&gt;&gt;&gt; class Colors(Constants):
... black = 0
... red = 1
... white = 15
...
&gt;&gt;&gt; c = Colors.black
&gt;&gt;&gt; c == 0
True
&gt;&gt;&gt; c
Colors.black
&gt;&gt;&gt; c.name()
'black'
&gt;&gt;&gt; Colors(0) is c
True
</code></pre>

This is slightly more advanced Python, but still very easy to use and handy. (The module has some more features, including constants being read-only, see its README.)

There are similar solutions floating around in various repositories, but to the best of my knowledge they either lack one of the fundamental features that I would expect from constants (like being constant, or being of arbitrary type), or they have esoteric features added that make them less generally applicable. But YMMV, I would be grateful for feedback. :-)

blocks|key|1702960|text|下面是一个"Constants“类的实现，它创建具有只读(常量)属性的实例。例如，可以使用Nums.PI获取已初始化为3.14159的值，而Nums.PI+=+22会引发异常。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1702961|#+----------+Constants.py+----------
class+Constants(object):
++++"""
++++Create+objects+with+read-only+(constant)+attributes.
++++Example:
++++++++Nums+=+Constants(ONE=1,+PI=3.14159,+DefaultWidth=100.0)
++++++++print+10+%2B+Nums.PI
++++++++print+'-----+Following+line+is+deliberate+ValueError+-----'
++++++++Nums.PI+=+22
++++"""

++++def+__init__(self,+*args,+**kwargs):
++++++++self._d+=+dict(*args,+**kwargs)

++++def+__iter__(self):
++++++++return+iter(self._d)

++++def+__len__(self):
++++++++return+len(self._d)

++++#+NOTE:+This+is+only+called+if+self+lacks+the+attribute.
++++#+So+it+does+not+interfere+with+get+of+'self._d',+etc.
++++def+__getattr__(self,+name):
++++++++return+self._d[name]

++++#+ASSUMES+'_..'+attribute+is+OK+to+set.+Need+this+to+initialize+'self._d',+etc.
++++#If+use+as+keys,+they+won't+be+constant.
++++def+__setattr__(self,+name,+value):
++++++++if+(name[0]+==+'_'):
++++++++++++super(Constants,+self).__setattr__(name,+value)
++++++++else:
++++++++++++raise+ValueError("setattr+while+locked",+self)

if+(__name__+==+"__main__"):
++++#+Usage+example.
++++Nums+=+Constants(ONE=1,+PI=3.14159,+DefaultWidth=100.0)
++++print+10+%2B+Nums.PI
++++print+'-----+Following+line+is+deliberate+ValueError+-----'
++++Nums.PI+=+22|code-block|syntax|javascript|1702962|多亏了@MikeGraham+'s+FrozenDict，我用它作为起点。已更改，因此使用语法为Nums.ONE，而不是Nums['ONE']。|1702963|多亏了@Raufio的回答，有了覆盖__+setattr+__的想法。|1702964|或者有关具有更多功能的实现，请参阅@Hans_meine的named_constants+at+GitHub|1702965|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2704866/199364|1|https://github.com/hmeine/named_constants^0|19|7|1N|7|1Y|C|0|0|1C|8|1O|B|3|P|0|0|0|T|P|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|M|3|N|5|6|7|1G|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1H|8|@]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|Q|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

Here is an implementation of a "Constants" class, which creates instances with read-only (constant) attributes. E.g. can use <code>Nums.PI</code> to get a value that has been initialized as <code>3.14159</code>, and <code>Nums.PI = 22</code> raises an exception.

<pre><code># ---------- Constants.py ----------
class Constants(object):
 """
 Create objects with read-only (constant) attributes.
 Example:
 Nums = Constants(ONE=1, PI=3.14159, DefaultWidth=100.0)
 print 10 + Nums.PI
 print '----- Following line is deliberate ValueError -----'
 Nums.PI = 22
 """

 def __init__(self, *args, **kwargs):
 self._d = dict(*args, **kwargs)

 def __iter__(self):
 return iter(self._d)

 def __len__(self):
 return len(self._d)

 # NOTE: This is only called if self lacks the attribute.
 # So it does not interfere with get of 'self._d', etc.
 def __getattr__(self, name):
 return self._d[name]

 # ASSUMES '_..' attribute is OK to set. Need this to initialize 'self._d', etc.
 #If use as keys, they won't be constant.
 def __setattr__(self, name, value):
 if (name[0] == '_'):
 super(Constants, self).__setattr__(name, value)
 else:
 raise ValueError("setattr while locked", self)

if (__name__ == "__main__"):
 # Usage example.
 Nums = Constants(ONE=1, PI=3.14159, DefaultWidth=100.0)
 print 10 + Nums.PI
 print '----- Following line is deliberate ValueError -----'
 Nums.PI = 22
</code></pre>

Thanks to <a href="https://stackoverflow.com/a/2704866/199364">@MikeGraham 's FrozenDict</a>, which I used as a starting point. Changed, so instead of <code>Nums['ONE']</code> the usage syntax is <code>Nums.ONE</code>.

And thanks to @Raufio's answer, for idea to override __ setattr __.

Or for an implementation with more functionality, see @Hans_meine 's
<a href="https://github.com/hmeine/named_constants" rel="noreferrer">named_constants at GitHub</a>

blocks|key|3111679|text|我最近发现了一个非常简洁的更新，它会自动引发有意义的错误消息，并阻止通过__dict__进行访问|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3111680|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'|code-block|syntax|javascript|3111681|我们将自己定义为使自己成为一个实例，然后使用插槽来确保不会添加任何额外的属性。这还会删除__dict__访问路由。当然，整个对象仍然可以重新定义。|3111682|编辑-原始解决方案|BOLD|3111683|我可能在这里遗漏了一个技巧，但这似乎对我有效：|3111684|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|3111685|创建实例允许神奇的__setattr__方法介入并拦截设置FOO变量的尝试。如果你愿意，你可以在这里抛出一个异常。在类名上实例化实例可防止直接通过类进行访问。|3111686|对于一个值来说，这是非常痛苦的，但是您可以将很多东西附加到CONST对象上。有了上流社会，类名看起来也有点难看，但我认为总体上它相当简洁。|3111687|entityMap^0|10|8|0|0|18|8|0|0|9|0|0|0|9|B|T|3|0|T|5|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|16|8|@$9|17|A|18|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@]|D|@]|E|$]]|$1|R|3|S|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|T|3|U|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|V|3|W|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Y|$]]

I've recently found a very succinct update to this which automatically raises meaningful error messages and prevents access via <code>__dict__</code>:

<pre><code>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'
</code></pre>

We define over ourselves as to make ourselves an instance and then use slots to ensure that no additional attributes can be added. This also removes the <code>__dict__</code> access route. Of course, the whole object can still be redefined.

Edit - Original solution

I'm probably missing a trick here, but this seems to work for me:

<pre><code>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
</code></pre>

Creating the instance allows the magic <code>__setattr__</code> method to kick in and intercept attempts to set the <code>FOO</code> variable. You could throw an exception here if you wanted to. Instantiating the instance over the class name prevents access directly via the class.

It's a total pain for one value, but you could attach lots to your <code>CONST</code> object. Having an upper class, class name also seems a bit grotty, but I think it's quite succinct overall.

blocks|key|1703112|text|好吧..。尽管这已经过时了，让我在这里补充我的2点意见:-)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1703113|class+ConstDict(dict):
++++def+__init__(self,+*args,+**kwargs):
++++++++super(ConstDict,+self).__init__(*args,+**kwargs)

++++def+__setitem__(self,+key,+value):
++++++++if+key+in+self:
++++++++++++raise+ValueError("Value+%25s+already+exists"+%25+(key))
++++++++super(ConstDict,+self).__setitem__(key,+value)|code-block|syntax|javascript|1703114|而不是ValueError+to+break，你可以防止任何更新发生在那里。这样做的一个好处是，您可以在程序中动态添加常量，但一旦设置了常量，就不能再进行更改。此外，您可以在设置常量之前添加任何规则或其他任何内容(例如key必须是字符串、小写字符串或大写字符串等等，然后才能设置key)|1703115|但是，我不认为在Python中设置常量有任何重要性。没有像C中那样的优化，因此我想它是不需要的。|1703116|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

well.. even though this is outdated, let me add my 2 cents here :-)

<pre><code>class ConstDict(dict):
 def __init__(self, *args, **kwargs):
 super(ConstDict, self).__init__(*args, **kwargs)

 def __setitem__(self, key, value):
 if key in self:
 raise ValueError("Value %s already exists" % (key))
 super(ConstDict, self).__setitem__(key, value)
</code></pre>

Instead of ValueError to break, you can prevent any update happening there. One advantage of this is that you can add constants dynamically in the program but you cannot change once a constant is set. Also you can add any rule or whatsoever before setting a constant(something like key must be a string or a lower case string or upper case string and so on before setting the key)

However, I do not see any importance of setting constants in Python. No optimizations can happen like in C and hence it is something that is not required, I guess.

blocks|key|1703151|text|在我的例子中，我需要不可变的字节数组来实现一个密码库，该密码库包含许多我想确保是常量的文字数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1703152|This+answer可以工作，但尝试重新分配bytearray元素不会引发错误。|offset|length|1703153|def+const(func):
++++'''implement+const+decorator'''
++++def+fset(self,+val):
++++++++'''attempting+to+set+a+const+raises+`ConstError`'''
++++++++class+ConstError(TypeError):
++++++++++++'''special+exception+for+const+reassignment'''
++++++++++++pass

++++++++raise+ConstError

++++def+fget(self):
++++++++'''get+a+const'''
++++++++return+func()

++++return+property(fget,+fset)


class+Consts(object):
++++'''contain+all+constants'''

++++@const
++++def+C1():
++++++++'''reassignment+to+C1+fails+silently'''
++++++++return+bytearray.fromhex('deadbeef')

++++@const
++++def+pi():
++++++++'''is+immutable'''
++++++++return+3.141592653589793|code-block|syntax|javascript|1703154|常量是不可变的，但常量bytearray赋值会静默失败：|1703155|>>>+c+=+Consts()
>>>+c.pi+=+6.283185307179586++#+(https://en.wikipedia.org/wiki/Tau_(2%25CF%2580))
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
++File+"consts.py",+line+9,+in+fset
++++raise+ConstError
__main__.ConstError
>>>+c.C1[0]+=+0
>>>+c.C1[0]
222
>>>+c.C1
bytearray(b'\xde\xad\xbe\xef')|1703156|一种更强大、更简单、甚至更“python”的方法涉及到内存视图对象(+<=+Python2.6中的buffer对象)的使用。|1703157|import+sys

PY_VER+=+sys.version.split()[0].split('.')

if+int(PY_VER[0])+==+2:
++++if+int(PY_VER[1])+<+6:
++++++++raise+NotImplementedError
++++elif+int(PY_VER[1])+==+6:
++++++++memoryview+=+buffer

class+ConstArray(object):
++++'''represent+a+constant+bytearray'''
++++def+__init__(self,+init):
++++++++'''
++++++++create+a+hidden+bytearray+and+expose+a+memoryview+of+that+bytearray+for
++++++++read-only+use
++++++++'''
++++++++if+int(PY_VER[1])+==+6:
++++++++++++self.__array+=+bytearray(init.decode('hex'))
++++++++else:
++++++++++++self.__array+=+bytearray.fromhex(init)

++++++++self.array+=+memoryview(self.__array)

++++def+__str__(self):
++++++++return+str(self.__array)

++++def+__getitem__(self,+*args,+**kwargs):
+++++++return+self.array.__getitem__(*args,+**kwargs)|1703158|ConstArray项分配是一个TypeError|style|CODE|1703159|>>>+C1+=+ConstArray('deadbeef')
>>>+C1[0]+=+0
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
TypeError:+'ConstArray'+object+does+not+support+item+assignment
>>>+C1[0]
222|1703160|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2688086/2880685^0|0|0|B|0|0|0|0|0|0|0|G|9|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|1G|8|@$D|1H|E|1I|U|V]]|9|@]|A|$]]|$1|W|3|X|5|H|7|1J|8|@]|9|@]|A|$I|J]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

In my case, I needed immutable bytearrays for an implementation of a crypto library containing many literal numbers I wanted to ensure were constant.

<a href="https://stackoverflow.com/a/2688086/2880685">This answer</a> works but attempted reassignment of bytearray elements does not raise an error.

<pre><code>def const(func):
 '''implement const decorator'''
 def fset(self, val):
 '''attempting to set a const raises `ConstError`'''
 class ConstError(TypeError):
 '''special exception for const reassignment'''
 pass

 raise ConstError

 def fget(self):
 '''get a const'''
 return func()

 return property(fget, fset)


class Consts(object):
 '''contain all constants'''

 @const
 def C1():
 '''reassignment to C1 fails silently'''
 return bytearray.fromhex('deadbeef')

 @const
 def pi():
 '''is immutable'''
 return 3.141592653589793
</code></pre>

Constants are immutable, but constant bytearray assignment fails silently:

<pre><code>&gt;&gt;&gt; c = Consts()
&gt;&gt;&gt; c.pi = 6.283185307179586 # (https://en.wikipedia.org/wiki/Tau_(2%CF%80))
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
 File "consts.py", line 9, in fset
 raise ConstError
__main__.ConstError
&gt;&gt;&gt; c.C1[0] = 0
&gt;&gt;&gt; c.C1[0]
222
&gt;&gt;&gt; c.C1
bytearray(b'\xde\xad\xbe\xef')
</code></pre>

A more powerful, simple, and perhaps even more 'pythonic' approach involves the use of memoryview objects (buffer objects in &lt;= python-2.6).

<pre><code>import sys

PY_VER = sys.version.split()[0].split('.')

if int(PY_VER[0]) == 2:
 if int(PY_VER[1]) &lt; 6:
 raise NotImplementedError
 elif int(PY_VER[1]) == 6:
 memoryview = buffer

class ConstArray(object):
 '''represent a constant bytearray'''
 def __init__(self, init):
 '''
 create a hidden bytearray and expose a memoryview of that bytearray for
 read-only use
 '''
 if int(PY_VER[1]) == 6:
 self.__array = bytearray(init.decode('hex'))
 else:
 self.__array = bytearray.fromhex(init)

 self.array = memoryview(self.__array)

 def __str__(self):
 return str(self.__array)

 def __getitem__(self, *args, **kwargs):
 return self.array.__getitem__(*args, **kwargs)
</code></pre>

ConstArray item assignment is a <code>TypeError</code>:

<pre><code>&gt;&gt;&gt; C1 = ConstArray('deadbeef')
&gt;&gt;&gt; C1[0] = 0
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
TypeError: 'ConstArray' object does not support item assignment
&gt;&gt;&gt; C1[0]
222
</code></pre>

blocks|key|370951|text|编辑:添加了Python+3的示例代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|370952|注意：this+other+answer看起来提供了一个更完整的实现，类似于下面(有更多特性)。|offset|length|370953|首先，创建一个metaclass|370954|class+MetaConst(type):
++++def+__getattr__(cls,+key):
++++++++return+cls[key]

++++def+__setattr__(cls,+key,+value):
++++++++raise+TypeError|code-block|syntax|javascript|370955|这可以防止静态属性被更改。然后创建另一个使用该元类的类：|370956|class+Const(object):
++++__metaclass__+=+MetaConst

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

++++def+__setattr__(self,+name,+value):
++++++++raise+TypeError|370957|或者，如果您使用的是Python+3：|370958|class+Const(object,+metaclass=MetaConst):
++++def+__getattr__(self,+name):
++++++++return+self[name]

++++def+__setattr__(self,+name,+value):
++++++++raise+TypeError|370959|这应该可以防止实例道具被更改。要使用它，请继承：|370960|class+MyConst(Const):
++++A+=+1
++++B+=+2|370961|现在，直接访问或通过实例访问的属性应该是常量：|370962|MyConst.A
#+1
my_const+=+MyConst()
my_const.A
#+1

MyConst.A+=+'changed'
#+TypeError
my_const.A+=+'changed'
#+TypeError|370963|Here's是上面的一个例子。Here's是Python3的另一个例子。|370964|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/19306516/1858091|1|https://stackoverflow.com/a/100146/1858091|2|https://repl.it/BMwL|3|https://repl.it/BMwR^0|0|3|H|0|0|7|9|1|0|0|0|0|0|0|0|0|0|0|0|6|2|F|6|3|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@]|9|@$D|1K|E|1L|1|1M]]|A|$]]|$1|F|3|G|5|6|7|1N|8|@]|9|@$D|1O|E|1P|1|1Q]]|A|$]]|$1|H|3|I|5|J|7|1R|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1S|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1T|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1U|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1V|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|J|7|1X|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|1Z|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|20|8|@]|9|@$D|21|E|22|1|23]|$D|24|E|25|1|26]]|A|$]]|$1|14|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]|1C|$5|17|18|19|A|$1A|1D]]|1E|$5|17|18|19|A|$1A|1F]]|1G|$5|17|18|19|A|$1A|1H]]]]

Edit: Added sample code for Python 3

Note: <a href="https://stackoverflow.com/a/19306516/1858091">this other answer</a> looks like it provides a much more complete implementation similar to the following (with more features).

First, make a <a href="https://stackoverflow.com/a/100146/1858091">metaclass</a>:

<pre class="lang-py prettyprint-override"><code>class MetaConst(type):
 def __getattr__(cls, key):
 return cls[key]

 def __setattr__(cls, key, value):
 raise TypeError
</code></pre>

This prevents statics properties from being changed. Then make another class that uses that metaclass:

<pre class="lang-py prettyprint-override"><code>class Const(object):
 __metaclass__ = MetaConst

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

 def __setattr__(self, name, value):
 raise TypeError
</code></pre>

Or, if you're using Python 3:

<pre class="lang-py prettyprint-override"><code>class Const(object, metaclass=MetaConst):
 def __getattr__(self, name):
 return self[name]

 def __setattr__(self, name, value):
 raise TypeError
</code></pre>

This should prevent instance props from being changed. To use it, inherit:

<pre class="lang-py prettyprint-override"><code>class MyConst(Const):
 A = 1
 B = 2
</code></pre>

Now the props, accessed directly or via an instance, should be constant:

<pre class="lang-py prettyprint-override"><code>MyConst.A
# 1
my_const = MyConst()
my_const.A
# 1

MyConst.A = 'changed'
# TypeError
my_const.A = 'changed'
# TypeError
</code></pre>

<a href="https://repl.it/BMwL" rel="noreferrer">Here's</a> an example of above in action. <a href="https://repl.it/BMwR" rel="noreferrer">Here's</a> another example for Python 3.

blocks|key|3111856|text|我为python+const编写了一个util+lib：+kkconst+-+pypi+支持str、int、float、datetime|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3111857|常量字段实例将保持其基类型行为。|3111858|例如：|3111859|from+__future__+import+print_function
from+kkconst+import+(
++++BaseConst,
++++ConstFloatField,
)

class+MathConst(BaseConst):
++++PI+=+ConstFloatField(3.1415926,+verbose_name=u"Pi")
++++E+=+ConstFloatField(2.7182818284,+verbose_name=u"mathematical+constant")++#+Euler's+number"
++++GOLDEN_RATIO+=+ConstFloatField(0.6180339887,+verbose_name=u"Golden+Ratio")

magic_num+=+MathConst.GOLDEN_RATIO
assert+isinstance(magic_num,+ConstFloatField)
assert+isinstance(magic_num,+float)

print(magic_num)++#+0.6180339887
print(magic_num.verbose_name)++#+Golden+Ratio|code-block|syntax|javascript|3111860|更多详细用法可以阅读pypi+url：+pypi+或+github+|3111861|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.python.org/pypi/kkconst|1|2|https://github.com/kaka19ace/kkconst^0|S|G|0|0|0|0|0|J|6|1|Q|8|2|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]|$A|1A|B|1B|1|1C]]|C|$]]|$1|O|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|V]]|X|$5|R|S|T|C|$U|Y]]]]

I write a util lib for python const:
<a href="https://pypi.python.org/pypi/kkconst" rel="nofollow"> kkconst - pypi </a>
support str, int, float, datetime 

the const field instance will keep its base type behavior.

For example:

<pre><code>from __future__ import print_function
from kkconst import (
 BaseConst,
 ConstFloatField,
)

class MathConst(BaseConst):
 PI = ConstFloatField(3.1415926, verbose_name=u"Pi")
 E = ConstFloatField(2.7182818284, verbose_name=u"mathematical constant") # Euler's number"
 GOLDEN_RATIO = ConstFloatField(0.6180339887, verbose_name=u"Golden Ratio")

magic_num = MathConst.GOLDEN_RATIO
assert isinstance(magic_num, ConstFloatField)
assert isinstance(magic_num, float)

print(magic_num) # 0.6180339887
print(magic_num.verbose_name) # Golden Ratio
</code></pre>

more details usage you can read the pypi url: 
<a href="https://pypi.python.org/pypi/kkconst" rel="nofollow"> pypi </a> or <a href="https://github.com/kaka19ace/kkconst" rel="nofollow"> github </a>

blocks|key|3111898|text|从技术上讲，元组是一个常量，因为如果您尝试更改元组的某个值，元组将引发错误。如果你想声明一个只有一个值的元组，那么在它唯一的值后面加一个逗号，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3111899|my_tuple+=+(0+"""Or+any+other+value""",)|code-block|syntax|javascript|3111900|要检查此变量的值，请使用类似以下内容的内容：|3111901|if+my_tuple[0]+==+0:
++++#Code+goes+here|3111902|如果您尝试更改此值，将引发错误。|3111903|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A tuple technically qualifies as a constant, as a tuple will raise an error if you try to change one of its values. If you want to declare a tuple with one value, then place a comma after its only value, like this:

<pre><code>my_tuple = (0 """Or any other value""",)
</code></pre>

To check this variable's value, use something similar to this: 

<pre><code>if my_tuple[0] == 0:
 #Code goes here
</code></pre>

If you attempt to change this value, an error will be raised.

blocks|key|3111938|text|您可以使用命名元组作为变通方法来有效地创建一个常量，它的工作方式与Java中的静态最终变量(+Java“常量”)相同。作为变通方法，它是一种优雅的方式。(更优雅的方法是简单地改进Python语言-哪种语言允许您重新定义math.pi？)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3111939|(在我写这篇文章的时候，我意识到这个问题的另一个答案提到了namedtuple，但我将在这里继续，因为我将展示一种与您在Java中期望的语法更相似的语法，因为不需要像namedtuple那样强制您创建命名类型。)|3111940|按照您的示例，您将记住，在Java语言中，我们必须在某个类中定义常量；因为您没有提到类名，所以我们将其称为Foo。下面是Java类：|3111941|public+class+Foo+{
++public+static+final+String+CONST_NAME+=+"Name";
}|code-block|syntax|javascript|3111942|下面是等效的Python。|3111943|from+collections+import+namedtuple
Foo+=+namedtuple('_Foo',+'CONST_NAME')('Name')|3111944|我想在这里补充的关键点是，您不需要单独的元组类型(“匿名命名元组”会很好，尽管这听起来有点矛盾)，所以我们将命名元组命名为_Foo，希望它不会逃脱到导入模块。|3111945|这里的第二点是，我们立即创建了名称元组的一个实例，将其命名为Foo；不需要在单独的步骤中执行此操作(除非您想这样做)。现在，您可以在Java中执行以下操作：|3111946|>>>+Foo.CONST_NAME
'Name'|3111947|但是你不能给它赋值：|3111948|>>>+Foo.CONST_NAME+=+'bar'
…
AttributeError:+can't+set+attribute|3111949|致谢:我以为我发明了命名元组方法，但后来我看到其他人给出了类似的答案(虽然不那么紧凑)。然后我还注意到了What+are+"named+tuples"+in+Python?，它指出sys.version_info现在是一个命名元组，所以也许Python标准库很早就提出了这个想法。|3111950|请注意，不幸的是(这仍然是Python)，您可以完全删除整个Foo赋值：|3111951|>>>+Foo+=+'bar'|3111952|(facepalm)|3111953|但至少我们可以防止Foo.CONST_NAME值被更改，这总比什么都没有好。祝好运。|3111954|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/2970608/421049|1|https://docs.python.org/3/library/sys.html#sys.version_info^0|31|7|0|0|1H|3|0|0|0|0|1P|4|0|U|3|0|0|0|0|2I|G|1G|Y|0|2I|G|1|0|U|3|0|0|0|9|E|0^^$0|@$1|2|3|4|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1P|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1T|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1U|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1V|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|W|3|X|5|L|7|22|8|@]|D|@]|E|$M|N]]|$1|Y|3|Z|5|6|7|23|8|@]|D|@]|E|$]]|$1|10|3|11|5|L|7|24|8|@]|D|@]|E|$M|N]]|$1|12|3|13|5|6|7|25|8|@$9|26|A|27|B|C]]|D|@$9|28|A|29|1|2A]|$9|2B|A|2C|1|2D]]|E|$]]|$1|14|3|15|5|6|7|2E|8|@$9|2F|A|2G|B|C]]|D|@]|E|$]]|$1|16|3|17|5|L|7|2H|8|@]|D|@]|E|$M|N]]|$1|18|3|19|5|6|7|2I|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|1C|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]]|1D|$1E|$5|1F|1G|1H|E|$1I|1J]]|1K|$5|1F|1G|1H|E|$1I|1L]]]]

You can use a namedtuple as a workaround to effectively create a constant that works the same way as a static final variable in Java (a Java "constant"). As workarounds go, it's sort of elegant. (A more elegant approach would be to simply improve the Python language --- what sort of language lets you redefine <code>math.pi</code>? -- but I digress.)

(As I write this, I realize another answer to this question mentioned namedtuple, but I'll continue here because I'll show a syntax that more closely parallels what you'd expect in Java, as there is no need to create a named type as namedtuple forces you to do.)

Following your example, you'll remember that in Java we must define the constant inside some class; because you didn't mention a class name, let's call it <code>Foo</code>. Here's the Java class:

<pre><code>public class Foo {
 public static final String CONST_NAME = "Name";
}
</code></pre>

Here's the equivalent Python.

<pre><code>from collections import namedtuple
Foo = namedtuple('_Foo', 'CONST_NAME')('Name')
</code></pre>

The key point I want to add here is that you don't need a separate <code>Foo</code> type (an "anonymous named tuple" would be nice, even though that sounds like an oxymoron), so we name our namedtuple <code>_Foo</code> so that hopefully it won't escape to importing modules.

The second point here is that we immediately create an instance of the nametuple, calling it <code>Foo</code>; there's no need to do this in a separate step (unless you want to). Now you can do what you can do in Java:

<pre><code>&gt;&gt;&gt; Foo.CONST_NAME
'Name'
</code></pre>

But you can't assign to it:

<pre><code>&gt;&gt;&gt; Foo.CONST_NAME = 'bar'
…
AttributeError: can't set attribute
</code></pre>

Acknowledgement: I thought I invented the namedtuple approach, but then I see that someone else gave a similar (although less compact) answer. Then I also noticed <a href="https://stackoverflow.com/q/2970608/421049">What are &quot;named tuples&quot; in Python?</a>, which points out that <a href="https://docs.python.org/3/library/sys.html#sys.version_info" rel="noreferrer"><code>sys.version_info</code></a> is now a namedtuple, so perhaps the Python standard library already came up with this idea much earlier.

Note that unfortunately (this still being Python), you can erase the entire <code>Foo</code> assignment altogether:

<pre><code>&gt;&gt;&gt; Foo = 'bar'
</code></pre>

(facepalm)

But at least we're preventing the <code>Foo.CONST_NAME</code> value from being changed, and that's better than nothing. Good luck.

blocks|key|3112014|text|不幸的是，到目前为止，Python还没有常量，这是一种耻辱。ES6已经向JavaScript+(https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const)添加了支持常量，因为它在任何编程语言中都是非常有用的东西。正如在Python社区的其他答案中所回答的那样，使用约定用户大写变量作为常量，但它不能防止代码中的任意错误。如果你喜欢，你可能会发现下一个单文件解决方案很有用(参见文档字符串如何使用它)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3112015|文件constants.py|style|BOLD|3112016|import+collections


__all__+=+('const',+)


class+Constant(object):
++++"""
++++Implementation+strict+constants+in+Python+3.

++++A+constant+can+be+set+up,+but+can+not+be+changed+or+deleted.
++++Value+of+constant+may+any+immutable+type,+as+well+as+list+or+set.
++++Besides+if+value+of+a+constant+is+list+or+set,+it+will+be+converted+in+an+immutable+type+as+next:
++++++++list+->+tuple
++++++++set+->+frozenset
++++Dict+as+value+of+a+constant+has+no+support.

++++>>>+const+=+Constant()
++++>>>+del+const.temp
++++Traceback+(most+recent+call+last):
++++NameError:+name+'temp'+is+not+defined
++++>>>+const.temp+=+1
++++>>>+const.temp+=+88
++++Traceback+(most+recent+call+last):
++++++++...
++++TypeError:+Constanst+can+not+be+changed
++++>>>+del+const.temp
++++Traceback+(most+recent+call+last):
++++++++...
++++TypeError:+Constanst+can+not+be+deleted
++++>>>+const.I+=+['a',+1,+1.2]
++++>>>+print(const.I)
++++('a',+1,+1.2)
++++>>>+const.F+=+{1.2}
++++>>>+print(const.F)
++++frozenset([1.2])
++++>>>+const.D+=+dict()
++++Traceback+(most+recent+call+last):
++++++++...
++++TypeError:+dict+can+not+be+used+as+constant
++++>>>+del+const.UNDEFINED
++++Traceback+(most+recent+call+last):
++++++++...
++++NameError:+name+'UNDEFINED'+is+not+defined
++++>>>+const()
++++{'I':+('a',+1,+1.2),+'temp':+1,+'F':+frozenset([1.2])}
++++"""

++++def+__setattr__(self,+name,+value):
++++++++"""Declaration+a+constant+with+value.+If+mutable+-+it+will+be+converted+to+immutable,+if+possible.
++++++++If+the+constant+already+exists,+then+made+prevent+againt+change+it."""

++++++++if+name+in+self.__dict__:
++++++++++++raise+TypeError('Constanst+can+not+be+changed')

++++++++if+not+isinstance(value,+collections.Hashable):
++++++++++++if+isinstance(value,+list):
++++++++++++++++value+=+tuple(value)
++++++++++++elif+isinstance(value,+set):
++++++++++++++++value+=+frozenset(value)
++++++++++++elif+isinstance(value,+dict):
++++++++++++++++raise+TypeError('dict+can+not+be+used+as+constant')
++++++++++++else:
++++++++++++++++raise+ValueError('Muttable+or+custom+type+is+not+supported')
++++++++self.__dict__[name]+=+value

++++def+__delattr__(self,+name):
++++++++"""Deny+against+deleting+a+declared+constant."""

++++++++if+name+in+self.__dict__:
++++++++++++raise+TypeError('Constanst+can+not+be+deleted')
++++++++raise+NameError("name+'%25s'+is+not+defined"+%25+name)

++++def+__call__(self):
++++++++"""Return+all+constans."""

++++++++return+self.__dict__


const+=+Constant()


if+__name__+==+'__main__':
++++import+doctest
++++doctest.testmod()|code-block|syntax|javascript|3112017|如果这还不够，请参阅完整的测试用例。|3112018|import+decimal
import+uuid
import+datetime
import+unittest

from+..constants+import+Constant


class+TestConstant(unittest.TestCase):
++++"""
++++Test+for+implementation+constants+in+the+Python
++++"""

++++def+setUp(self):

++++++++self.const+=+Constant()

++++def+tearDown(self):

++++++++del+self.const

++++def+test_create_constant_with_different_variants_of_name(self):

++++++++self.const.CONSTANT+=+1
++++++++self.assertEqual(self.const.CONSTANT,+1)
++++++++self.const.Constant+=+2
++++++++self.assertEqual(self.const.Constant,+2)
++++++++self.const.ConStAnT+=+3
++++++++self.assertEqual(self.const.ConStAnT,+3)
++++++++self.const.constant+=+4
++++++++self.assertEqual(self.const.constant,+4)
++++++++self.const.co_ns_ta_nt+=+5
++++++++self.assertEqual(self.const.co_ns_ta_nt,+5)
++++++++self.const.constant1111+=+6
++++++++self.assertEqual(self.const.constant1111,+6)

++++def+test_create_and_change_integer_constant(self):

++++++++self.const.INT+=+1234
++++++++self.assertEqual(self.const.INT,+1234)
++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.INT+=+.211

++++def+test_create_and_change_float_constant(self):

++++++++self.const.FLOAT+=+.1234
++++++++self.assertEqual(self.const.FLOAT,+.1234)
++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.FLOAT+=+.211

++++def+test_create_and_change_list_constant_but_saved_as_tuple(self):

++++++++self.const.LIST+=+[1,+.2,+None,+True,+datetime.date.today(),+[],+{}]
++++++++self.assertEqual(self.const.LIST,+(1,+.2,+None,+True,+datetime.date.today(),+[],+{}))

++++++++self.assertTrue(isinstance(self.const.LIST,+tuple))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.LIST+=+.211

++++def+test_create_and_change_none_constant(self):

++++++++self.const.NONE+=+None
++++++++self.assertEqual(self.const.NONE,+None)
++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.NONE+=+.211

++++def+test_create_and_change_boolean_constant(self):

++++++++self.const.BOOLEAN+=+True
++++++++self.assertEqual(self.const.BOOLEAN,+True)
++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.BOOLEAN+=+False

++++def+test_create_and_change_string_constant(self):

++++++++self.const.STRING+=+"Text"
++++++++self.assertEqual(self.const.STRING,+"Text")

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.STRING+%2B=+'...'

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.STRING+=+'TEst1'

++++def+test_create_dict_constant(self):

++++++++with+self.assertRaisesRegexp(TypeError,+'dict+can+not+be+used+as+constant'):
++++++++++++self.const.DICT+=+{}

++++def+test_create_and_change_tuple_constant(self):

++++++++self.const.TUPLE+=+(1,+.2,+None,+True,+datetime.date.today(),+[],+{})
++++++++self.assertEqual(self.const.TUPLE,+(1,+.2,+None,+True,+datetime.date.today(),+[],+{}))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.TUPLE+=+'TEst1'

++++def+test_create_and_change_set_constant(self):

++++++++self.const.SET+=+{1,+.2,+None,+True,+datetime.date.today()}
++++++++self.assertEqual(self.const.SET,+{1,+.2,+None,+True,+datetime.date.today()})

++++++++self.assertTrue(isinstance(self.const.SET,+frozenset))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.SET+=+3212

++++def+test_create_and_change_frozenset_constant(self):

++++++++self.const.FROZENSET+=+frozenset({1,+.2,+None,+True,+datetime.date.today()})
++++++++self.assertEqual(self.const.FROZENSET,+frozenset({1,+.2,+None,+True,+datetime.date.today()}))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.FROZENSET+=+True

++++def+test_create_and_change_date_constant(self):

++++++++self.const.DATE+=+datetime.date(1111,+11,+11)
++++++++self.assertEqual(self.const.DATE,+datetime.date(1111,+11,+11))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.DATE+=+True

++++def+test_create_and_change_datetime_constant(self):

++++++++self.const.DATETIME+=+datetime.datetime(2000,+10,+10,+10,+10)
++++++++self.assertEqual(self.const.DATETIME,+datetime.datetime(2000,+10,+10,+10,+10))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.DATETIME+=+None

++++def+test_create_and_change_decimal_constant(self):

++++++++self.const.DECIMAL+=+decimal.Decimal(13123.12312312321)
++++++++self.assertEqual(self.const.DECIMAL,+decimal.Decimal(13123.12312312321))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.DECIMAL+=+None

++++def+test_create_and_change_timedelta_constant(self):

++++++++self.const.TIMEDELTA+=+datetime.timedelta(days=45)
++++++++self.assertEqual(self.const.TIMEDELTA,+datetime.timedelta(days=45))

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.TIMEDELTA+=+1

++++def+test_create_and_change_uuid_constant(self):

++++++++value+=+uuid.uuid4()
++++++++self.const.UUID+=+value
++++++++self.assertEqual(self.const.UUID,+value)

++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+changed'):
++++++++++++self.const.UUID+=+[]

++++def+test_try_delete_defined_const(self):

++++++++self.const.VERSION+=+'0.0.1'
++++++++with+self.assertRaisesRegexp(TypeError,+'Constanst+can+not+be+deleted'):
++++++++++++del+self.const.VERSION

++++def+test_try_delete_undefined_const(self):

++++++++with+self.assertRaisesRegexp(NameError,+"name+'UNDEFINED'+is+not+defined"):
++++++++++++del+self.const.UNDEFINED

++++def+test_get_all_defined_constants(self):

++++++++self.assertDictEqual(self.const(),+{})

++++++++self.const.A+=+1
++++++++self.assertDictEqual(self.const(),+{'A':+1})

++++++++self.const.B+=+"Text"
++++++++self.assertDictEqual(self.const(),+{'A':+1,+'B':+"Text"})|3112019|优点:+1.获取整个项目的所有常量2.严格控制常量的值|3112020|缺少:+1.不支持自定义类型和类型'dict‘|3112021|备注：|3112022|使用Python3.4和Python3.5+(我使用“tox”测试)测试的|3112023|ordered-list-item|3112024|测试环境：|3112025|3112026|。|3112027|$+uname+-a
Linux+wlysenko-Aspire+3.13.0-37-generic+#64-Ubuntu+SMP+Mon+Sep+22+21:28:38+UTC+2014+x86_64+x86_64+x86_64+GNU/Linux|3112028|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const^0|1C|27|0|0|0|E|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|D|3|E|5|6|7|1J|8|@$A|1K|B|1L|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1M|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1N|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1O|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|1P|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|1R|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|1S|8|@]|9|@]|C|$]]|$1|Y|3|-4|5|Z|7|1T|8|@]|9|@]|C|$]]|$1|10|3|11|5|Z|7|1U|8|@]|9|@]|C|$]]|$1|12|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]|$1|13|3|14|5|6|7|1W|8|@]|9|@]|C|$]]|$1|15|3|16|5|J|7|1X|8|@]|9|@]|C|$K|L]]|$1|17|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]]|18|$19|$5|1A|1B|1C|C|$1D|1E]]]]

Unfortunately the Python has no constants so yet and it is shame. ES6 already added support constants to JavaScript (<a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const" rel="noreferrer">https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/const</a>) since it is a very useful thing in any programming language.
As answered in other answers in Python community use the convention - user uppercase variable as constants, but it does not protect against arbitrary errors in code.
If you like, you may be found useful a single-file solution as next
(see docstrings how use it).

file constants.py

<pre><code>import collections


__all__ = ('const', )


class Constant(object):
 """
 Implementation strict constants in Python 3.

 A constant can be set up, but can not be changed or deleted.
 Value of constant may any immutable type, as well as list or set.
 Besides if value of a constant is list or set, it will be converted in an immutable type as next:
 list -&gt; tuple
 set -&gt; frozenset
 Dict as value of a constant has no support.

 &gt;&gt;&gt; const = Constant()
 &gt;&gt;&gt; del const.temp
 Traceback (most recent call last):
 NameError: name 'temp' is not defined
 &gt;&gt;&gt; const.temp = 1
 &gt;&gt;&gt; const.temp = 88
 Traceback (most recent call last):
 ...
 TypeError: Constanst can not be changed
 &gt;&gt;&gt; del const.temp
 Traceback (most recent call last):
 ...
 TypeError: Constanst can not be deleted
 &gt;&gt;&gt; const.I = ['a', 1, 1.2]
 &gt;&gt;&gt; print(const.I)
 ('a', 1, 1.2)
 &gt;&gt;&gt; const.F = {1.2}
 &gt;&gt;&gt; print(const.F)
 frozenset([1.2])
 &gt;&gt;&gt; const.D = dict()
 Traceback (most recent call last):
 ...
 TypeError: dict can not be used as constant
 &gt;&gt;&gt; del const.UNDEFINED
 Traceback (most recent call last):
 ...
 NameError: name 'UNDEFINED' is not defined
 &gt;&gt;&gt; const()
 {'I': ('a', 1, 1.2), 'temp': 1, 'F': frozenset([1.2])}
 """

 def __setattr__(self, name, value):
 """Declaration a constant with value. If mutable - it will be converted to immutable, if possible.
 If the constant already exists, then made prevent againt change it."""

 if name in self.__dict__:
 raise TypeError('Constanst can not be changed')

 if not isinstance(value, collections.Hashable):
 if isinstance(value, list):
 value = tuple(value)
 elif isinstance(value, set):
 value = frozenset(value)
 elif isinstance(value, dict):
 raise TypeError('dict can not be used as constant')
 else:
 raise ValueError('Muttable or custom type is not supported')
 self.__dict__[name] = value

 def __delattr__(self, name):
 """Deny against deleting a declared constant."""

 if name in self.__dict__:
 raise TypeError('Constanst can not be deleted')
 raise NameError("name '%s' is not defined" % name)

 def __call__(self):
 """Return all constans."""

 return self.__dict__


const = Constant()


if __name__ == '__main__':
 import doctest
 doctest.testmod()
</code></pre>

If this is not enough, see full testcase for it.

<pre><code>import decimal
import uuid
import datetime
import unittest

from ..constants import Constant


class TestConstant(unittest.TestCase):
 """
 Test for implementation constants in the Python
 """

 def setUp(self):

 self.const = Constant()

 def tearDown(self):

 del self.const

 def test_create_constant_with_different_variants_of_name(self):

 self.const.CONSTANT = 1
 self.assertEqual(self.const.CONSTANT, 1)
 self.const.Constant = 2
 self.assertEqual(self.const.Constant, 2)
 self.const.ConStAnT = 3
 self.assertEqual(self.const.ConStAnT, 3)
 self.const.constant = 4
 self.assertEqual(self.const.constant, 4)
 self.const.co_ns_ta_nt = 5
 self.assertEqual(self.const.co_ns_ta_nt, 5)
 self.const.constant1111 = 6
 self.assertEqual(self.const.constant1111, 6)

 def test_create_and_change_integer_constant(self):

 self.const.INT = 1234
 self.assertEqual(self.const.INT, 1234)
 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.INT = .211

 def test_create_and_change_float_constant(self):

 self.const.FLOAT = .1234
 self.assertEqual(self.const.FLOAT, .1234)
 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.FLOAT = .211

 def test_create_and_change_list_constant_but_saved_as_tuple(self):

 self.const.LIST = [1, .2, None, True, datetime.date.today(), [], {}]
 self.assertEqual(self.const.LIST, (1, .2, None, True, datetime.date.today(), [], {}))

 self.assertTrue(isinstance(self.const.LIST, tuple))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.LIST = .211

 def test_create_and_change_none_constant(self):

 self.const.NONE = None
 self.assertEqual(self.const.NONE, None)
 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.NONE = .211

 def test_create_and_change_boolean_constant(self):

 self.const.BOOLEAN = True
 self.assertEqual(self.const.BOOLEAN, True)
 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.BOOLEAN = False

 def test_create_and_change_string_constant(self):

 self.const.STRING = "Text"
 self.assertEqual(self.const.STRING, "Text")

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.STRING += '...'

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.STRING = 'TEst1'

 def test_create_dict_constant(self):

 with self.assertRaisesRegexp(TypeError, 'dict can not be used as constant'):
 self.const.DICT = {}

 def test_create_and_change_tuple_constant(self):

 self.const.TUPLE = (1, .2, None, True, datetime.date.today(), [], {})
 self.assertEqual(self.const.TUPLE, (1, .2, None, True, datetime.date.today(), [], {}))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.TUPLE = 'TEst1'

 def test_create_and_change_set_constant(self):

 self.const.SET = {1, .2, None, True, datetime.date.today()}
 self.assertEqual(self.const.SET, {1, .2, None, True, datetime.date.today()})

 self.assertTrue(isinstance(self.const.SET, frozenset))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.SET = 3212

 def test_create_and_change_frozenset_constant(self):

 self.const.FROZENSET = frozenset({1, .2, None, True, datetime.date.today()})
 self.assertEqual(self.const.FROZENSET, frozenset({1, .2, None, True, datetime.date.today()}))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.FROZENSET = True

 def test_create_and_change_date_constant(self):

 self.const.DATE = datetime.date(1111, 11, 11)
 self.assertEqual(self.const.DATE, datetime.date(1111, 11, 11))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.DATE = True

 def test_create_and_change_datetime_constant(self):

 self.const.DATETIME = datetime.datetime(2000, 10, 10, 10, 10)
 self.assertEqual(self.const.DATETIME, datetime.datetime(2000, 10, 10, 10, 10))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.DATETIME = None

 def test_create_and_change_decimal_constant(self):

 self.const.DECIMAL = decimal.Decimal(13123.12312312321)
 self.assertEqual(self.const.DECIMAL, decimal.Decimal(13123.12312312321))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.DECIMAL = None

 def test_create_and_change_timedelta_constant(self):

 self.const.TIMEDELTA = datetime.timedelta(days=45)
 self.assertEqual(self.const.TIMEDELTA, datetime.timedelta(days=45))

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.TIMEDELTA = 1

 def test_create_and_change_uuid_constant(self):

 value = uuid.uuid4()
 self.const.UUID = value
 self.assertEqual(self.const.UUID, value)

 with self.assertRaisesRegexp(TypeError, 'Constanst can not be changed'):
 self.const.UUID = []

 def test_try_delete_defined_const(self):

 self.const.VERSION = '0.0.1'
 with self.assertRaisesRegexp(TypeError, 'Constanst can not be deleted'):
 del self.const.VERSION

 def test_try_delete_undefined_const(self):

 with self.assertRaisesRegexp(NameError, "name 'UNDEFINED' is not defined"):
 del self.const.UNDEFINED

 def test_get_all_defined_constants(self):

 self.assertDictEqual(self.const(), {})

 self.const.A = 1
 self.assertDictEqual(self.const(), {'A': 1})

 self.const.B = "Text"
 self.assertDictEqual(self.const(), {'A': 1, 'B': "Text"})
</code></pre>

Advantages:
 1. Access to all constants for whole project
 2. Strict control for values of constants

Lacks:
 1. Not support for custom types and the type 'dict'

Notes:

<ol>
<li>Tested with Python3.4 and Python3.5 (I am use the 'tox' for it)</li>
<li>Testing environment:</li>
</ol>

.

<pre><code>$ uname -a
Linux wlysenko-Aspire 3.13.0-37-generic #64-Ubuntu SMP Mon Sep 22 21:28:38 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
</code></pre>

blocks|key|3112090|text|您可以在下一个类的帮助下模拟常量变量。一个用法示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3112091|#+Const
const+=+Const().add(two=2,+three=3)

print+'const.two:+',+const.two
print+'const.three:+',+const.three

const.add(four=4)

print+'const.four:+',+const.four

#const.four+=+5+#+a+error+here:+four+is+a+constant

const.add(six=6)

print+'const.six:+',+const.six

const2+=+Const().add(five=5)+#+creating+a+new+namespace+with+Const()
print+'const2.five:+',+const2.five
#print+'const2.four:+',+const2.four+#+a+error+here:+four+does+not+exist+in+const2+namespace

const2.add(five=26)|code-block|syntax|javascript|3112092|当您想要启动一个新的常量命名空间时，调用构造函数。请注意，当Martelli的常量类不是时，该类受到保护，不会意外地修改序列类型常量。|offset|length|style|BOLD|3112093|源代码如下所示。|3112094|from+copy+import+copy

class+Const(object):
"A+class+to+create+objects+with+constant+fields."

def+__init__(self):
++++object.__setattr__(self,+'_names',+[])


def+add(self,+**nameVals):
++++for+name,+val+in+nameVals.iteritems():++++++++++
++++++++if+hasattr(self,+name):
++++++++++++raise+ConstError('A+field+with+a+name+\'%25s\'+is+already+exist+in+Const+class.'+%25+name)

++++++++setattr(self,+name,+copy(val))+#+set+up+getter

++++++++self._names.append(name)

++++return+self


def+__setattr__(self,+name,+val):
++++if+name+in+self._names:
++++++++raise+ConstError('You+cannot+change+a+value+of+a+stored+constant.')

++++object.__setattr__(self,+name,+val)|3112095|entityMap^0|0|0|13|2|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can emulate constant variables with help of the next class. An example of usage:

<pre><code># Const
const = Const().add(two=2, three=3)

print 'const.two: ', const.two
print 'const.three: ', const.three

const.add(four=4)

print 'const.four: ', const.four

#const.four = 5 # a error here: four is a constant

const.add(six=6)

print 'const.six: ', const.six

const2 = Const().add(five=5) # creating a new namespace with Const()
print 'const2.five: ', const2.five
#print 'const2.four: ', const2.four # a error here: four does not exist in const2 namespace

const2.add(five=26)
</code></pre>

Call the constructor when you want to start a new constant namespace. Note that the class is under protection from unexpected modifying sequence type constants when Martelli's const class is not.

The source is below.

<pre><code>from copy import copy

class Const(object):
"A class to create objects with constant fields."

def __init__(self):
 object.__setattr__(self, '_names', [])


def add(self, **nameVals):
 for name, val in nameVals.iteritems(): 
 if hasattr(self, name):
 raise ConstError('A field with a name \'%s\' is already exist in Const class.' % name)

 setattr(self, name, copy(val)) # set up getter

 self._names.append(name)

 return self


def __setattr__(self, name, val):
 if name in self._names:
 raise ConstError('You cannot change a value of a stored constant.')

 object.__setattr__(self, name, val)
</code></pre>

blocks|key|3112145|text|您可以将常量包装在numpy数组中，将其标记为只写，并始终通过索引0调用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3112146|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+%25s'+%25+CONSTANT[0]

#+attempt+to+modify+our+constant+with+try/except
new_value+=+'goodbye'
try:
++++CONSTANT[0]+=+new_value
except:
++++print+"cannot+change+CONSTANT+to+'%25s'+it's+value+'%25s'+is+immutable"+%25+(
++++++++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|code-block|syntax|javascript|3112147|当然，这只保护numpy的内容，而不是变量"CONSTANT“本身；您仍然可以这样做：|3112148|CONSTANT+=+'foo'|3112149|CONSTANT会发生变化，但是在脚本中第一次调用CONSTANT[0]时，会很快抛出TypeError。|offset|length|style|CODE|3112150|尽管..。我想如果你在某个时候把它改成|3112151|CONSTANT+=+[1,2,3]|3112152|现在你不会再得到TypeError了。嗯……|3112153|https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.setflags.html|3112154|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|8|P|B|0|0|0|0|0|28|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|19|8|@$M|1A|N|1B|O|P]|$M|1C|N|1D|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1E|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1G|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1H|8|@]|9|@$M|1I|N|1J|1|1K]]|A|$]]|$1|Y|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|X]]]]

You can wrap a constant in a numpy array, flag it write only, and always call it by index zero.

<pre><code>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



&gt;&gt;&gt;
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 &lt;module&gt;
 CONSTANT[0] = new_value
ValueError: assignment destination is read-only
</code></pre>

of course this only protects the contents of the numpy, not the variable "CONSTANT" itself; you can still do:

<pre><code>CONSTANT = 'foo'
</code></pre>

and <code>CONSTANT</code> would change, however that would quickly throw an TypeError the first time <code>CONSTANT[0]</code> is later called in the script.

although... I suppose if you at some point changed it to 

<pre><code>CONSTANT = [1,2,3]
</code></pre>

now you wouldn't get the TypeError anymore. hmmmm....

<a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.setflags.html" rel="nofollow noreferrer">https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.setflags.html</a>

blocks|key|1703563|text|我们可以创建一个描述符对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1703564|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")|code-block|syntax|javascript|1703565|1)如果我们想在实例级别使用常量，那么：|1703566|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|1703567|2)如果我们只想在类级别创建常量，我们可以使用元类作为常量(我们的描述符对象)的容器；所有继承下来的类都将继承我们的常量(我们的描述符对象)，而不会有任何可以修改的风险。|1703568|#+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|1703569|如果我创建一个Foo的子类，这个类将继承常量而不可能修改它们|1703570|class+Bar(Foo):+pass

>>>+Bar.NUM++#=>+255
>>>+Bar.NUM+=+0++#=>+ValueError:+You+can't+change+a+constant|1703571|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

We can create a descriptor object.

<pre><code>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")
</code></pre>

1) If we wanted to work with constants at the instance level then:

<pre><code>class A:
 NULL = Constant()
 NUM = Constant(0xFF)

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

&gt;&gt;&gt; obj=A()
&gt;&gt;&gt; print(obj.NUM) #=&gt; 255
&gt;&gt;&gt; obj.NUM =100

Traceback (most recent call last):
File "&lt;stdin&gt;", line 1, in &lt;module&gt;
ValueError: You can't change a constant
</code></pre>

2) if we wanted to create constants only at the class level, we could use a metaclass that serves as a container for our constants (our descriptor objects); all the classes that descend will inherit our constants (our descriptor objects) without any risk that can be modified.

<pre><code># 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')

&gt;&gt;&gt; Foo.NUM #=&gt; 255
&gt;&gt;&gt; Foo.NAME #=&gt; 'FOO'
&gt;&gt;&gt; Foo.NUM = 0 #=&gt; ValueError: You can't change a constant
</code></pre>

If I create a subclass of Foo, this class will inherit the constant without the possibility of modifying them

<pre><code>class Bar(Foo): pass

&gt;&gt;&gt; Bar.NUM #=&gt; 255
&gt;&gt;&gt; Bar.NUM = 0 #=&gt; ValueError: You can't change a constant
</code></pre>

blocks|key|371563|text|属性是创建常量的一种方法。你可以声明一个getter属性，但是忽略setter。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|371564|class+MyFinalProperty(object):

++++@property
++++def+name(self):
++++++++return+"John"|code-block|syntax|javascript|371565|您可以查看an+article+I've+written以找到使用Python属性的更多方法。|offset|length|371566|entityMap|0|LINK|mutability|MUTABLE|url|http://www.navedali.com/technology/python/property-in-python^0|0|0|5|N|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Properties are one way to create constants. You can do it by declaring a getter property, but ignoring the setter. For example:

<pre><code>class MyFinalProperty(object):

 @property
 def name(self):
 return "John"
</code></pre>

You can have a look at <a href="http://www.navedali.com/technology/python/property-in-python" rel="noreferrer">an article I've written</a> to find more ways to use Python properties.

blocks|key|3112325|text|如果你想要常量而不关心它们的值，这里有一个技巧：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3112326|只定义空类。|offset|length|style|BOLD|3112327|例如：|3112328|class+RED:+
++++pass
class+BLUE:+
++++pass|code-block|syntax|javascript|3112329|entityMap^0|0|0|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|V|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Here's a trick if you want constants and don't care their values:

Just define empty classes.

e.g:

<pre><code>class RED: 
 pass
class BLUE: 
 pass
</code></pre>

blocks|key|1703715|text|Python没有常量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1703716|也许最简单的替代方法是为它定义一个函数：|1703717|def+MY_CONSTANT():
++++return+42|code-block|syntax|javascript|1703718|MY_CONSTANT()现在拥有常量的所有功能(加上一些烦人的花括号)。|offset|length|style|CODE|1703719|entityMap^0|0|0|0|0|D|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Python doesn't have constants.

Perhaps the easiest alternative is to define a function for it:


<pre><code>def MY_CONSTANT():
 return 42
</code></pre>

<code>MY_CONSTANT()</code> now has all the functionality of a constant (plus some annoying braces).

blocks|key|371609|text|您可以使用collections.namedtuple和itertools来完成此任务|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|371610|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|code-block|syntax|javascript|371611|entityMap^0|5|M|S|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

You can do it with <code>collections.namedtuple</code> and <code>itertools</code>:

<pre><code>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()))

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

blocks|key|3112495|text|在Python语言中，常量是不存在的，但是您可以通过在变量名的开头添加CONST_并在注释中声明它是常量来指示变量是常量，并且不能进行更改：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3112496|myVariable+=+0
CONST_daysInWeek+=+7++++#+This+is+a+constant+-+do+not+change+its+value.+++
CONSTANT_daysInMonth+=+30+#+This+is+also+a+constant+-+do+not+change+this+value.|code-block|syntax|javascript|3112497|或者，您可以创建一个功能类似于常量的函数：|3112498|def+CONST_daysInWeek():
++++return+7;|3112499|entityMap^0|Z|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

In Python, constants do not exist, but you can indicate that a variable is a constant and must not be changed by adding <code>CONST_</code> to the start of the variable name and stating that it is a constant in a comment:

<pre class="lang-py prettyprint-override"><code>myVariable = 0
CONST_daysInWeek = 7 # This is a constant - do not change its value. 
CONSTANT_daysInMonth = 30 # This is also a constant - do not change this value.
</code></pre>

Alternatively, you may create a function that acts like a constant:

<pre class="lang-py prettyprint-override"><code>def CONST_daysInWeek():
 return 7;
</code></pre>

blocks|key|1703796|text|在python中，常量只是一个变量，其名称全部大写，单词之间用下划线分隔，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1703797|e.g|1703798|DAYS_IN_WEEK+=7|1703799|该值是可变的，因为在中您可以更改它。但是如果名字的规则告诉你是一个常量，你为什么要这样做呢？我的意思是，这毕竟是你的程序！|1703800|这就是贯穿python的方法。出于同样的原因，没有private关键字。在名称前加上下划线，您就知道该名称是私有的。代码可以破坏rule....just，因为程序员无论如何都可以删除私有关键字。|offset|length|style|CODE|1703801|Python可以添加一个const关键字...但是程序员可以删除关键字，然后更改常量，但为什么要这样做呢？如果你想打破规则，你可以改变规则。但是，如果名称清楚地表明了意图，为什么还要费心打破规则呢？|1703802|也许在一些单元测试中，对值进行更改是有意义的？看看一周8天会发生什么，即使在现实世界中，一周中的天数是不能改变的。如果语言阻止您进行异常如果只有这一种情况，您需要打破rule...you，然后必须停止将其声明为常量，即使它在应用程序中仍然是常量，并且只有一个测试用例，看看如果它被更改了会发生什么。|1703803|全大写的名称告诉你它是一个常量。这才是最重要的。不是一种强制对代码进行约束的语言，您无论如何都有能力进行更改。|1703804|这就是python的哲学。|1703805|entityMap^0|0|0|0|0|P|7|0|C|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@$J|12|K|13|L|M]]|9|@]|A|$]]|$1|N|3|O|5|6|7|14|8|@$J|15|K|16|L|M]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|17|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|18|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|19|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|W|$]]

In python, a constant is simply a variable with a name in all capitals, with words separated by the underscore character,

e.g

DAYS_IN_WEEK = 7

The value is mutable, as in you can change it. But given the rules for the name tell you is a constant, why would you? I mean, it is your program after all!

This is the approach taken throughout python. There is no <code>private</code> keyword for the same reason. Prefix the name with an underscore and you know it is intended to be private. Code can break the rule....just as a programmer could remove the private keyword anyway. 

Python could have added a <code>const</code> keyword... but a programmer could remove keyword and then change the constant if they want to, but why do that? If you want to break the rule, you could change the rule anyway. But why bother to break the rule if the name makes the intention clear?

Maybe there is some unit test where it makes sense to apply a change to value? To see what happens for an 8 day week even though in the real world the number of days in the week cannot be changed. If the language stopped you making an exception if there is just this one case you need to break the rule...you would then have to stop declaring it as a constant, even though it still is a constant in the application, and there is just this one test case that sees what happens if it is changed.

The all upper case name tells you it is intended to be a constant. That is what is important. Not a language forcing constraints on code you have the power to change anyway.

That is the philosophy of python.

blocks|key|1703839|text|简单地说，您只需：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1703840|STRING_CONSTANT+=+"hi"
NUMBER_CONSTANT+=+89|code-block|syntax|javascript|1703841|希望这能让一切变得更简单|1703842|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Simply you can just:

<pre><code>STRING_CONSTANT = "hi"
NUMBER_CONSTANT = 89
</code></pre>

hope that makes everything much simpler

blocks|key|3112653|text|没有完美的方法可以做到这一点。据我所知，大多数程序员只会将标识符大写，因此PI+=+3.142很容易理解为常量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3112654|另一方面，如果你想要一个像常量一样的东西，我不确定你是否能找到它。无论你做什么，总会有一些方法来编辑“常量”，所以它不会真的是常量。下面是一个非常简单的下流例子：|3112655|def+define(name,+value):
++if+(name+%2B+str(id(name)))+not+in+globals():
++++globals()[name+%2B+str(id(name))]+=+value

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

define("PI",3.142)

print(constant("PI"))|code-block|syntax|javascript|3112656|这看起来像是一个PHP风格的常量。|3112657|实际上，更改值所需的全部内容如下所示：|3112658|globals()["PI"%2Bstr(id("PI"))]+=+3.1415|3112659|这对于您在这里找到的所有其他解决方案都是一样的-即使是那些创建类并重新定义set+attribute方法的聪明解决方案-总会有一种方法绕过它们。这就是Python的本质。|3112660|我的建议是避免所有的麻烦，只需要大写你的标识符。它不会是一个合适的常量，但也不是。|3112661|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

There's no perfect way to do this. As I understand it most programmers will just capitalize the identifier, so PI = 3.142 can be readily understood to be a constant.

On the otherhand, if you want something that actually acts like a constant, I'm not sure you'll find it. With anything you do there will always be some way of editing the "constant" so it won't really be a constant. Here's a very simple, dirty example:

<pre><code>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"))
</code></pre>

This looks like it will make a PHP-style constant.

In reality all it takes for someone to change the value is this:

<pre><code>globals()["PI"+str(id("PI"))] = 3.1415
</code></pre>

This is the same for all the other solutions you'll find on here - even the clever ones that make a class and redefine the set attribute method - there will always be a way around them. That's just how Python is.

My recommendation is to just avoid all the hassle and just capitalize your identifiers. It wouldn't really be a proper constant but then again nothing would.

blocks|key|1119651|text|(这段话是对提到namedtuple的答案here和there的评论，但它太长了，无法放入评论中，所以，这里就是它了。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1119652|上面提到的命名元组方法绝对是创新的。不过，为了完整起见，在its+official+documentation的NamedTuple部分的末尾，它写道：|1119653|可以使用命名元组实现|1119654|枚举常量，但使用简单的类声明会更简单、更有效：|blockquote|1119655|1119656|类状态:+open、pending、closed+=范围(3)|1119657|1119658|换句话说，官方文档更倾向于使用一种实用的方式，而不是实际实现只读行为。我猜它成了Zen+of+Python的又一个例子。|1119659|1119660|+Simple比complex更好。|1119661|1119662|实用胜过纯洁。|1119663|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2683099/728675|1|https://stackoverflow.com/a/40029632/728675|2|https://docs.python.org/2/library/collections.html#collections.namedtuple|3|https://www.python.org/dev/peps/pep-0020/^0|8|A|L|4|0|Q|5|1|0|T|Q|2|0|0|0|0|0|0|14|D|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]|$9|1I|A|1J|1|1K]]|E|$]]|$1|F|3|G|5|6|7|1L|8|@]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|H|3|I|5|6|7|1P|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1Q|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1S|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1U|8|@]|D|@$9|1V|A|1W|1|1X]]|E|$]]|$1|S|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|T|3|U|5|L|7|1Z|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|20|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|21|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|22|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]|16|$5|11|12|13|E|$14|17]]|18|$5|11|12|13|E|$14|19]]|1A|$5|11|12|13|E|$14|1B]]]]

(This paragraph was meant to be a comment on those answers <a href="https://stackoverflow.com/a/2683099/728675">here</a> and <a href="https://stackoverflow.com/a/40029632/728675">there</a>, which mentioned <code>namedtuple</code>, but it is getting too long to be fit into a comment, so, here it goes.)
The namedtuple approach mentioned above is definitely innovative. For the sake of completeness, though, at the end of the NamedTuple section of <a href="https://docs.python.org/2/library/collections.html#collections.namedtuple" rel="nofollow noreferrer">its official documentation</a>, it reads:
<blockquote>
enumerated constants can be implemented with named tuples, but it is simpler and more efficient to use a simple class declaration:
<pre><code>class Status:
 open, pending, closed = range(3)
</code></pre>
</blockquote>
In other words, the official documentation kind of prefers to use a practical way, rather than actually implementing the read-only behavior. I guess it becomes yet another example of <a href="https://www.python.org/dev/peps/pep-0020/" rel="nofollow noreferrer">Zen of Python</a>:
<blockquote>
Simple is better than complex.
practicality beats purity.
</blockquote>

blocks|key|3112765|text|对于namedtuple，有一种更简洁的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3112766|from+collections+import+namedtuple


def+make_consts(name,+**kwargs):
++++return+namedtuple(name,+kwargs.keys())(**kwargs)|code-block|syntax|javascript|3112767|使用示例|3112768|CONSTS+=+make_consts("baz1",
+++++++++++++++++++++foo=1,
+++++++++++++++++++++bar=2)|3112769|使用这种方法，您可以将常量命名为空间。|3112770|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

There is a cleaner way to do this with namedtuple:

<pre><code>from collections import namedtuple


def make_consts(name, **kwargs):
 return namedtuple(name, kwargs.keys())(**kwargs)
</code></pre>

Usage Example

<pre><code>CONSTS = make_consts("baz1",
 foo=1,
 bar=2)
</code></pre>

With this exactly approach you can namespace your constants.

blocks|key|371781|text|也许pconst库可以帮助你(github)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|371782|$+pip+install+pconst|style|CODE|371783|from+pconst+import+const
const.APPLE_PRICE+=+100
const.APPLE_PRICE+=+200|code-block|syntax|javascript|371784|[Out]+Constant+value+of+"APPLE_PRICE"+is+not+editable.|371785|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/simon-ritchie/pconst^0|F|6|0|0|0|K|0|0|0|1I|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@$A|11|B|12|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|13|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|14|8|@$A|15|B|16|F|G]]|9|@]|C|$]]|$1|O|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Maybe pconst library will help you (<a href="https://github.com/simon-ritchie/pconst" rel="nofollow noreferrer">github</a>).

<code>$ pip install pconst</code>

<pre><code>from pconst import const
const.APPLE_PRICE = 100
const.APPLE_PRICE = 200
</code></pre>

<code>[Out] Constant value of "APPLE_PRICE" is not editable.</code>

blocks|key|3112907|text|这里是我创建的一个习语集合，试图改进一些已经可用的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3112908|我知道常量的用法不是pythonic式的，你不应该在家里这样做！|3112909|然而，Python是这样一种动态语言！这个论坛展示了如何创建外观和感觉都像常量的结构。这个答案的主要目的是探索语言可以表达什么。|3112910|请不要对我太苛刻:-)。|3112911|为了了解更多细节，我写了一个accompaniment+blog+about+these+idioms。|offset|length|3112912|在这篇文章中，我将调用一个常量变量来引用常量的值(不可变的或其他的)。此外，我说当一个变量引用一个客户端代码不能更新它的值的可变对象时，它有一个冻结值。|3112913|常量空间(SpaceConstants)|3112914|这个习惯用法创建了一个看起来像常量变量的命名空间(也就是SpaceConstants)。它是Alex+Martelli对代码片段的修改，以避免使用模块对象。特别是，这个修改使用了我称之为类工厂的东西，因为在SpaceConstants函数中，定义了一个名为SpaceConstants的类，并返回了它的一个实例。|style|BOLD|3112915|我探索了如何使用类工厂在Python、stackoverflow和blogpost中实现基于策略的外观设计。|3112916|def+SpaceConstants():
++++def+setattr(self,+name,+value):
++++++++if+hasattr(self,+name):
++++++++++++raise+AttributeError(
++++++++++++++++"Cannot+reassign+members"
++++++++++++)
++++++++self.__dict__[name]+=+value
++++cls+=+type('SpaceConstants',+(),+{
++++++++'__setattr__':+setattr
++++})
++++return+cls()

sc+=+SpaceConstants()

print(sc.x)+#+raise+"AttributeError:+'SpaceConstants'+object+has+no+attribute+'x'"
sc.x+=+2+#+bind+attribute+x
print(sc.x)+#+print+"2"
sc.x+=+3+#+raise+"AttributeError:+Cannot+reassign+members"
sc.y+=+{'name':+'y',+'value':+2}+#+bind+attribute+y
print(sc.y)+#+print+"{'name':+'y',+'value':+2}"
sc.y['name']+=+'yprime'+#+mutable+object+can+be+changed
print(sc.y)+#+print+"{'name':+'yprime',+'value':+2}"
sc.y+=+{}+#+raise+"AttributeError:+Cannot+reassign+members"|code-block|syntax|javascript|3112917|冻结值的空间(SpaceFrozenValues)|3112918|下一个习惯用法是对SpaceConstants的修改，其中引用的可变对象被冻结。这个实现利用了我所说的setattr和getattr函数之间的shared+closure。可变对象的值由函数共享闭包中定义的变量cache复制和引用。它形成了我所说的closure+protected+copy+of+a+mutable+object。|3112919|在使用这个习惯用法时必须小心，因为getattr通过执行深度复制来返回缓存值。此操作可能会对大型对象产生显著的性能影响！|3112920|from+copy+import+deepcopy

def+SpaceFrozenValues():
++++cache+=+{}
++++def+setattr(self,+name,+value):
++++++++nonlocal+cache
++++++++if+name+in+cache:
++++++++++++raise+AttributeError(
++++++++++++++++"Cannot+reassign+members"
++++++++++++)
++++++++cache[name]+=+deepcopy(value)
++++def+getattr(self,+name):
++++++++nonlocal+cache
++++++++if+name+not+in+cache:
++++++++++++raise+AttributeError(
++++++++++++++++"Object+has+no+attribute+'{}'".format(name)
++++++++++++)
++++++++return+deepcopy(cache[name])
++++cls+=+type('SpaceFrozenValues',+(),{
++++++++'__getattr__':+getattr,
++++++++'__setattr__':+setattr
++++})
++++return+cls()

fv+=+SpaceFrozenValues()
print(fv.x)+#+AttributeError:+Object+has+no+attribute+'x'
fv.x+=+2+#+bind+attribute+x
print(fv.x)+#+print+"2"
fv.x+=+3+#+raise+"AttributeError:+Cannot+reassign+members"
fv.y+=+{'name':+'y',+'value':+2}+#+bind+attribute+y
print(fv.y)+#+print+"{'name':+'y',+'value':+2}"
fv.y['name']+=+'yprime'+#+you+can+try+to+change+mutable+objects
print(fv.y)+#+print+"{'name':+'y',+'value':+2}"
fv.y+=+{}+#+raise+"AttributeError:+Cannot+reassign+members"|3112921|常量空间(ConstantSpace)|3112922|这个习惯用法是常量变量或ConstantSpace.的不可变的命名空间它结合了Jon+Betts在stackoverflow中极其简单的回答和一个class+factory。|3112923|def+ConstantSpace(**args):
++++args['__slots__']+=+()
++++cls+=+type('ConstantSpace',+(),+args)
++++return+cls()

cs+=+ConstantSpace(
++++x+=+2,
++++y+=+{'name':+'y',+'value':+2}
)

print(cs.x)+#+print+"2"
cs.x+=+3+#+raise+"AttributeError:+'ConstantSpace'+object+attribute+'x'+is+read-only"
print(cs.y)+#+print+"{'name':+'y',+'value':+2}"
cs.y['name']+=+'yprime'+#+mutable+object+can+be+changed
print(cs.y)+#+print+"{'name':+'yprime',+'value':+2}"
cs.y+=+{}+#+raise+"AttributeError:+'ConstantSpace'+object+attribute+'x'+is+read-only"
cs.z+=+3+#+raise+"AttributeError:+'ConstantSpace'+object+has+no+attribute+'z'"|3112924|冻结空间(FrozenSpace)|3112925|这个习惯用法是冻结变量或FrozenSpace.的不可变的命名空间它是从前面的模式派生而来的，方法是使每个变量都是生成的FrozenSpace类的protected+property+by+closure。|3112926|from+copy+import+deepcopy

def+FreezeProperty(value):
++++cache+=+deepcopy(value)
++++return+property(
++++++++lambda+self:+deepcopy(cache)
++++)

def+FrozenSpace(**args):
++++args+=+{k:+FreezeProperty(v)+for+k,+v+in+args.items()}
++++args['__slots__']+=+()
++++cls+=+type('FrozenSpace',+(),+args)
++++return+cls()

fs+=+FrozenSpace(
++++x+=+2,
++++y+=+{'name':+'y',+'value':+2}
)

print(fs.x)+#+print+"2"
fs.x+=+3+#+raise+"AttributeError:+'FrozenSpace'+object+attribute+'x'+is+read-only"
print(fs.y)+#+print+"{'name':+'y',+'value':+2}"
fs.y['name']+=+'yprime'+#+try+to+change+mutable+object
print(fs.y)+#+print+"{'name':+'y',+'value':+2}"
fs.y+=+{}+#+raise+"AttributeError:+'FrozenSpace'+object+attribute+'x'+is+read-only"
fs.z+=+3+#+raise+"AttributeError:+'FrozenSpace'+object+has+no+attribute+'z'"|3112927|entityMap|0|LINK|mutability|MUTABLE|url|https://baites.github.io/computer-science/idioms/2019/08/16/constant-and-frozen-variable-in-python.html|1|https://en.wikipedia.org/wiki/Alex_Martelli|2|https://stackoverflow.com/questions/57365189/what-are-the-measures-to-call-a-python-code-a-policy-based-design|3|https://baites.github.io/computer-science/patterns/python-policy-based-mixins-series/2019/08/02/policy-based-design-in-python.html|4|https://baites.github.io/computer-science/idioms/closure-series/2017/12/11/are-closures-trivial.html|5|https://baites.github.io/computer-science/idioms/closure-series/2017/12/04/made-up-patterns-with-closures.html|6|https://stackoverflow.com/a/23274028/11875212|7|8^0|0|0|0|0|E|11|0|0|0|0|2V|E|3K|E|1A|D|1|0|J|D|2|X|8|3|0|0|0|9|E|1F|7|1N|7|1Z|E|4|3G|16|5|0|0|0|0|C|D|1D|D|6|21|D|7|0|0|0|C|B|1O|B|21|T|8|0|0^^$0|@$1|2|3|4|5|6|7|26|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|27|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|28|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|29|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|2A|8|@]|9|@$J|2B|K|2C|1|2D]]|A|$]]|$1|L|3|M|5|6|7|2E|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|2F|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|2G|8|@$J|2H|K|2I|R|S]|$J|2J|K|2K|R|S]]|9|@$J|2L|K|2M|1|2N]]|A|$]]|$1|T|3|U|5|6|7|2O|8|@]|9|@$J|2P|K|2Q|1|2R]|$J|2S|K|2T|1|2U]]|A|$]]|$1|V|3|W|5|X|7|2V|8|@]|9|@]|A|$Y|Z]]|$1|10|3|11|5|6|7|2W|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2X|8|@$J|2Y|K|2Z|R|S]|$J|30|K|31|R|S]|$J|32|K|33|R|S]]|9|@$J|34|K|35|1|36]|$J|37|K|38|1|39]]|A|$]]|$1|14|3|15|5|6|7|3A|8|@]|9|@]|A|$]]|$1|16|3|17|5|X|7|3B|8|@]|9|@]|A|$Y|Z]]|$1|18|3|19|5|6|7|3C|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|3D|8|@$J|3E|K|3F|R|S]]|9|@$J|3G|K|3H|1|3I]|$J|3J|K|3K|1|3L]]|A|$]]|$1|1C|3|1D|5|X|7|3M|8|@]|9|@]|A|$Y|Z]]|$1|1E|3|1F|5|6|7|3N|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|3O|8|@$J|3P|K|3Q|R|S]|$J|3R|K|3S|R|S]]|9|@$J|3T|K|3U|1|3V]]|A|$]]|$1|1I|3|1J|5|X|7|3W|8|@]|9|@]|A|$Y|Z]]|$1|1K|3|-4|5|6|7|3X|8|@]|9|@]|A|$]]]|1L|$1M|$5|1N|1O|1P|A|$1Q|1R]]|1S|$5|1N|1O|1P|A|$1Q|1T]]|1U|$5|1N|1O|1P|A|$1Q|1V]]|1W|$5|1N|1O|1P|A|$1Q|1X]]|1Y|$5|1N|1O|1P|A|$1Q|1Z]]|20|$5|1N|1O|1P|A|$1Q|21]]|22|$5|1N|1O|1P|A|$1Q|23]]|24|$5|1N|1O|1P|A|$1Q|1X]]|25|$5|1N|1O|1P|A|$1Q|21]]]]

Here it is a collection of idioms that I created as an attempt to improve some of the already available answers.
I know the use of constant is not pythonic, and you should not do this at home!
However, Python is such a dynamic language! This forum shows how it is possible the creation of constructs that looks and feels like constants. This answer has as the primary purpose to explore what can be expressed by the language.
Please do not be too harsh with me :-).
For more details I wrote a <a href="https://baites.github.io/computer-science/idioms/2019/08/16/constant-and-frozen-variable-in-python.html" rel="noreferrer">accompaniment blog about these idioms</a>.
In this post, I will call a constant variable to a constant reference to values (immutable or otherwise). Moreover, I say that a variable has a frozen value when it references a mutable object that a client-code cannot update its value(s).
<h2>A space of constants (SpaceConstants)</h2>
This idiom creates what looks like a namespace of constant variables (a.k.a. SpaceConstants). It is a modification of a code snippet by <a href="https://en.wikipedia.org/wiki/Alex_Martelli" rel="noreferrer">Alex Martelli</a> to avoid the use of module objects. In particular, this modification uses what I call a class factory because within SpaceConstants function, a class called SpaceConstants is defined, and an instance of it is returned.
I explored the use of class factory to implement a policy-based design look-alike in Python in <a href="https://stackoverflow.com/questions/57365189/what-are-the-measures-to-call-a-python-code-a-policy-based-design">stackoverflow</a> and also in a <a href="https://baites.github.io/computer-science/patterns/python-policy-based-mixins-series/2019/08/02/policy-based-design-in-python.html" rel="noreferrer">blogpost</a>.
<pre class="lang-py prettyprint-override"><code>def SpaceConstants():
 def setattr(self, name, value):
 if hasattr(self, name):
 raise AttributeError(
 &quot;Cannot reassign members&quot;
 )
 self.__dict__[name] = value
 cls = type('SpaceConstants', (), {
 '__setattr__': setattr
 })
 return cls()

sc = SpaceConstants()

print(sc.x) # raise &quot;AttributeError: 'SpaceConstants' object has no attribute 'x'&quot;
sc.x = 2 # bind attribute x
print(sc.x) # print &quot;2&quot;
sc.x = 3 # raise &quot;AttributeError: Cannot reassign members&quot;
sc.y = {'name': 'y', 'value': 2} # bind attribute y
print(sc.y) # print &quot;{'name': 'y', 'value': 2}&quot;
sc.y['name'] = 'yprime' # mutable object can be changed
print(sc.y) # print &quot;{'name': 'yprime', 'value': 2}&quot;
sc.y = {} # raise &quot;AttributeError: Cannot reassign members&quot;

</code></pre>
<h2>A space of frozen values (SpaceFrozenValues)</h2>
This next idiom is a modification of the SpaceConstants in where referenced mutable objects are frozen. This implementation exploits what I call <a href="https://baites.github.io/computer-science/idioms/closure-series/2017/12/11/are-closures-trivial.html" rel="noreferrer">shared closure</a> between setattr and getattr functions. The value of the mutable object is copied and referenced by variable cache define inside of the function shared closure. It forms what I call a <a href="https://baites.github.io/computer-science/idioms/closure-series/2017/12/04/made-up-patterns-with-closures.html" rel="noreferrer">closure protected copy of a mutable object</a>.
You must be careful in using this idiom because getattr return the value of cache by doing a deep copy. This operation could have a significant performance impact on large objects!
<pre class="lang-py prettyprint-override"><code>from copy import deepcopy

def SpaceFrozenValues():
 cache = {}
 def setattr(self, name, value):
 nonlocal cache
 if name in cache:
 raise AttributeError(
 &quot;Cannot reassign members&quot;
 )
 cache[name] = deepcopy(value)
 def getattr(self, name):
 nonlocal cache
 if name not in cache:
 raise AttributeError(
 &quot;Object has no attribute '{}'&quot;.format(name)
 )
 return deepcopy(cache[name])
 cls = type('SpaceFrozenValues', (),{
 '__getattr__': getattr,
 '__setattr__': setattr
 })
 return cls()

fv = SpaceFrozenValues()
print(fv.x) # AttributeError: Object has no attribute 'x'
fv.x = 2 # bind attribute x
print(fv.x) # print &quot;2&quot;
fv.x = 3 # raise &quot;AttributeError: Cannot reassign members&quot;
fv.y = {'name': 'y', 'value': 2} # bind attribute y
print(fv.y) # print &quot;{'name': 'y', 'value': 2}&quot;
fv.y['name'] = 'yprime' # you can try to change mutable objects
print(fv.y) # print &quot;{'name': 'y', 'value': 2}&quot;
fv.y = {} # raise &quot;AttributeError: Cannot reassign members&quot;
</code></pre>
<h2>A constant space (ConstantSpace)</h2>
This idiom is an immutable namespace of constant variables or ConstantSpace. It is a combination of awesomely simple Jon Betts' answer in <a href="https://stackoverflow.com/a/23274028/11875212">stackoverflow</a> with a <a href="https://baites.github.io/computer-science/patterns/python-policy-based-mixins-series/2019/08/02/policy-based-design-in-python.html" rel="noreferrer">class factory</a>.
<pre class="lang-py prettyprint-override"><code>def ConstantSpace(**args):
 args['__slots__'] = ()
 cls = type('ConstantSpace', (), args)
 return cls()

cs = ConstantSpace(
 x = 2,
 y = {'name': 'y', 'value': 2}
)

print(cs.x) # print &quot;2&quot;
cs.x = 3 # raise &quot;AttributeError: 'ConstantSpace' object attribute 'x' is read-only&quot;
print(cs.y) # print &quot;{'name': 'y', 'value': 2}&quot;
cs.y['name'] = 'yprime' # mutable object can be changed
print(cs.y) # print &quot;{'name': 'yprime', 'value': 2}&quot;
cs.y = {} # raise &quot;AttributeError: 'ConstantSpace' object attribute 'x' is read-only&quot;
cs.z = 3 # raise &quot;AttributeError: 'ConstantSpace' object has no attribute 'z'&quot;
</code></pre>
<h2>A frozen space (FrozenSpace)</h2>
This idiom is an immutable namespace of frozen variables or FrozenSpace. It is derived from the previous pattern by making each variable a <a href="https://baites.github.io/computer-science/idioms/closure-series/2017/12/04/made-up-patterns-with-closures.html" rel="noreferrer">protected property by closure</a> of the generated FrozenSpace class.
<pre class="lang-py prettyprint-override"><code>from copy import deepcopy

def FreezeProperty(value):
 cache = deepcopy(value)
 return property(
 lambda self: deepcopy(cache)
 )

def FrozenSpace(**args):
 args = {k: FreezeProperty(v) for k, v in args.items()}
 args['__slots__'] = ()
 cls = type('FrozenSpace', (), args)
 return cls()

fs = FrozenSpace(
 x = 2,
 y = {'name': 'y', 'value': 2}
)

print(fs.x) # print &quot;2&quot;
fs.x = 3 # raise &quot;AttributeError: 'FrozenSpace' object attribute 'x' is read-only&quot;
print(fs.y) # print &quot;{'name': 'y', 'value': 2}&quot;
fs.y['name'] = 'yprime' # try to change mutable object
print(fs.y) # print &quot;{'name': 'y', 'value': 2}&quot;
fs.y = {} # raise &quot;AttributeError: 'FrozenSpace' object attribute 'x' is read-only&quot;
fs.z = 3 # raise &quot;AttributeError: 'FrozenSpace' object has no attribute 'z'&quot;
</code></pre>

blocks|key|371413|text|PEP+591有'final‘限定符。强制执行取决于类型检查器。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|371414|所以你可以这样做：|371415|MY_CONSTANT:+Final+=+12407|code-block|syntax|javascript|371416|注意：+Final关键字仅适用于Python3.8版本|style|BOLD|CODE|371417|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0591/^0|0|7|0|0|0|0|0|3|4|5|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|13|8|@$A|14|B|15|M|N]|$A|16|B|17|M|O]]|9|@]|C|$]]|$1|P|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

<a href="https://www.python.org/dev/peps/pep-0591/" rel="noreferrer">PEP 591</a> has the 'final' qualifier. Enforcement is down to the type checker.

So you can do: 

<pre><code>MY_CONSTANT: Final = 12407
</code></pre>

Note: <code>Final</code> keyword is only applicable for Python 3.8 version

blocks|key|371883|text|from+enum+import+Enum
class+StringConsts(str,Enum):
++++ONE='one'
++++TWO='two'

print(f'Truth+is++{StringConsts.ONE=="one"}')+#Truth+is+True
StringConsts.ONE="one"+#Error:+Cannot+reassign|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|371884|Enum和str的混合使您不必重新实现setattr+(通过Enum)并与其他str对象进行比较(通过str)。|unstyled|371885|这可能会完全弃用http://code.activestate.com/recipes/65207-constants-in-python/?in=user-97991。|offset|length|371886|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/65207-constants-in-python/?in=user-97991^0|0|0|8|24|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<pre><code>from enum import Enum
class StringConsts(str,Enum):
 ONE='one'
 TWO='two'

print(f'Truth is {StringConsts.ONE=="one"}') #Truth is True
StringConsts.ONE="one" #Error: Cannot reassign
</code></pre>

This mixin of Enum and str gives you the power of not having to reimplement setattr (through Enum) and comparison to other str objects (through str).

This might deprecate <a href="http://code.activestate.com/recipes/65207-constants-in-python/?in=user-97991" rel="noreferrer">http://code.activestate.com/recipes/65207-constants-in-python/?in=user-97991</a> completely.

blocks|key|1704367|text|我不得不提供我自己的非常轻量级的简约metaclass实现(它可能看起来像是上一个元类答案的变体)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1704368|常量存储在容器类中(，不需要实例化)。值可以设置一次，但一旦设置就不能更改(或删除)。|BOLD|1704369|就我个人而言，我目前还没有这方面的用例，但这是一个有趣的练习。|1704370|class+MetaConstant(type):
++++'''+Metaclass+that+allows+underlying+class+to+store+constants+at+class-level+(subclass+instance+not+needed).
++++++++Non-existent+attributes+of+underlying+class+(constants)+can+be+set+initially,+but+cannot+be+changed+or+deleted.
++++'''

++++def+__setattr__(klass,+attr,+value):
++++++++'If+attribute+(constant)+doesn\'t+exist,+set+value.+If+attribute+exists,+raise+AttributeError.'
++++++++if+hasattr(klass,+attr):
++++++++++++raise+AttributeError(f'Can\'t+change+the+value+of+the+constant+{klass.__name__}.{attr}+to+{value}'
+++++++++++++++++++++++++++++++++f'+(the+value+of+{klass.__name__}.{attr}+is+already+set+to'
+++++++++++++++++++++++++++++++++f'+{getattr(klass,+attr)}).')
++++++++super().__setattr__(attr,+value)

++++def+__delattr__(klass,+attr):
++++++++if+hasattr(klass,+attr):
++++++++++++raise+AttributeError(f'Can\'t+delete+constant+{klass.__name__}.{attr}'
+++++++++++++++++++++++++++++++++f'+(set+to+{getattr(klass,+attr)}).')


class+Constants(metaclass=MetaConstant):
++++'Container+class+for+constants.+No+instantiation+required.'
++++#pass+++++++++++++++#+uncomment+if+no+constants+set+upon+class+creation
++++B+=+'Six'+++++++++++#+sets+Constants.B+to+'Six'


Constants.B+=+6+++++++++#+AttributeError
del+Constants.B+++++++++#+AttributeError

Constants.A+=+'Five'++++#+sets+Constants.A+to+'Five'
Constants.A+=+5+++++++++#+AttributeError
del+Constants.A+++++++++#+AttributeError|code-block|syntax|javascript|1704371|请随时提出改进建议。|1704372|entityMap^0|I|9|0|A|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|Z|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|10|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|11|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|S|$]]

Can't help but provide my own very light minimalist <code>metaclass</code> implementation (which may appear as a variation from the previous metaclass answer).

Constants are stored inside a container class (no instantiation needed). Values can be set once, but cannot be changed (or deleted) once they are set.

Personally I currently have no use-case for this, but was a fun exercise.

<pre><code>class MetaConstant(type):
 ''' Metaclass that allows underlying class to store constants at class-level (subclass instance not needed).
 Non-existent attributes of underlying class (constants) can be set initially, but cannot be changed or deleted.
 '''

 def __setattr__(klass, attr, value):
 'If attribute (constant) doesn\'t exist, set value. If attribute exists, raise AttributeError.'
 if hasattr(klass, attr):
 raise AttributeError(f'Can\'t change the value of the constant {klass.__name__}.{attr} to {value}'
 f' (the value of {klass.__name__}.{attr} is already set to'
 f' {getattr(klass, attr)}).')
 super().__setattr__(attr, value)

 def __delattr__(klass, attr):
 if hasattr(klass, attr):
 raise AttributeError(f'Can\'t delete constant {klass.__name__}.{attr}'
 f' (set to {getattr(klass, attr)}).')


class Constants(metaclass=MetaConstant):
 'Container class for constants. No instantiation required.'
 #pass # uncomment if no constants set upon class creation
 B = 'Six' # sets Constants.B to 'Six'


Constants.B = 6 # AttributeError
del Constants.B # AttributeError

Constants.A = 'Five' # sets Constants.A to 'Five'
Constants.A = 5 # AttributeError
del Constants.A # AttributeError

</code></pre>

Feel free to suggest improvements.

blocks|key|1704433|text|所有的答案基本上都是两种类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1704434|1704435|创建某种类型的对象，您可以为其创建一旦定义就不能更改的属性。|ordered-list-item|1704436|使用约定(如以全大写形式编写常量，或者对于Python3.8，使用final限定符表示要将一个或多个名称设置为常量。|offset|length|style|CODE|1704437|1704438|它们可以总结为：“你不能用Python做你想做的事”。|1704439|然而，实际上有一种方法可以创建一个具有真正常量的模块。这样做的代码相当复杂，我将只概述需要做什么，因为它已经在开放源码许可证下可用。|1704440|1704441|使用import+hook创建自定义模块。我使用的通用代码是found+here.|1704442|Create，这是一个特殊的dict，它允许只添加一次符合您选择的模式的项(例如，全部大写的名称)，并防止此类名称的值发生更改。为此，您需要定义自己的方法，如__setitem__、__delitem__等。这样的字典(如found+in+this+file，超过250行)的代码大约有100行长。|1704443|普通Python模块的dict不能修改。因此，在创建模块时，您需要首先执行特殊dict中的代码，然后使用其内容来更新模块的dict。|1704444|为了防止从模块外部修改常数的值(即__class__匹配)，您可以用重新定义的__setattr__和__delattr__方法的自定义__class__替换模块的contants。|1704445|1704446|documentation+about+this+example+can+be+found+here。它可能应该进行更新，以反映对此问题的答案数量。|1704447|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0302/|1|https://github.com/aroberge/ideas/blob/master/ideas/import_hook.py|2|https://github.com/aroberge/ideas/blob/master/ideas/examples/constants.py|3|https://aroberge.github.io/ideas/docs/html/constants.html^0|0|0|0|X|5|0|0|0|0|0|2|B|0|U|A|1|0|E|4|27|B|2J|B|39|C|2|0|B|4|0|H|9|13|B|1F|B|1W|9|0|0|0|1E|3|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1J|8|@$H|1K|I|1L|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1N|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|R|3|S|5|E|7|1Q|8|@]|9|@$H|1R|I|1S|1|1T]|$H|1U|I|1V|1|1W]]|A|$]]|$1|T|3|U|5|E|7|1X|8|@$H|1Y|I|1Z|J|K]|$H|20|I|21|J|K]|$H|22|I|23|J|K]]|9|@$H|24|I|25|1|26]]|A|$]]|$1|V|3|W|5|E|7|27|8|@$H|28|I|29|J|K]]|9|@]|A|$]]|$1|X|3|Y|5|E|7|2A|8|@$H|2B|I|2C|J|K]|$H|2D|I|2E|J|K]|$H|2F|I|2G|J|K]|$H|2H|I|2I|J|K]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|2K|8|@]|9|@$H|2L|I|2M|1|2N]]|A|$]]|$1|12|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]|1A|$5|15|16|17|A|$18|1B]]|1C|$5|15|16|17|A|$18|1D]]|1E|$5|15|16|17|A|$18|1F]]]]

All of the answers given are essentially of two types:

<ol>
<li>Create some sort of object for which you can 
create attributes which cannot be changed once defined.</li>
<li>Use a convention (like writing constants in all UPPERCASE or, for Python 3.8, use the <code>final</code> qualifier to indicate that you intend one or more names to be a constant.</li>
</ol>

They can be summarized as saying "you cannot do what you ask using Python".

However, there is actually a way to create a module with true constants. The code to do so is rather involved, and I will only give an outline of what is needed to do as it is already available under an open source license.

<ol>
<li>Use an <a href="https://www.python.org/dev/peps/pep-0302/" rel="nofollow noreferrer">import hook</a> to enable the creation of a custom module. The versatile code I use for this is <a href="https://github.com/aroberge/ideas/blob/master/ideas/import_hook.py" rel="nofollow noreferrer">found here</a>.</li>
<li>Create a special <code>dict</code> which allows adding items that conform to your chosen pattern (for example, names in all UPPERCASE) only once and prevent such names to have their values changed. For this, you will need to define your own methods such as <code>__setitem__</code>, <code>__delitem__</code>, etc. The code for such a dict (such as found <a href="https://github.com/aroberge/ideas/blob/master/ideas/examples/constants.py" rel="nofollow noreferrer">in this file</a>, which is over 250 lines) is approximately 100 lines long.</li>
<li>The <code>dict</code> for a normal Python module cannot be modified. So, when creating the module, you need to execute the code in your special dict first, and then use its content to update the module's dict. </li>
<li>To prevent modifications of the values of the contants from outside of the module (i.e. monkeypatching), you can replace the <code>__class__</code> of the module by a custom one with the <code>__setattr__</code> and <code>__delattr__</code> method redefined.</li>
</ol>

The <a href="https://aroberge.github.io/ideas/docs/html/constants.html" rel="nofollow noreferrer">documentation about this example can be found here</a>. It probably should be updated to reflect the number of answers given to this question.

blocks|key|1704473|text|我知道这是一个老问题，但由于新的解决方案仍在不断添加，我想让可能的解决方案列表更加完整。通过继承如下所示的类，您可以通过属性访问在实例中实现常量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1704474|class+ConstantError(Exception):
++++pass++#+maybe+give+nice+error+message

class+AllowConstants:
++++_constants+=+None
++++_class_constants+=+None

++++def+__init__(self):
++++++++self._constants+=+{}
++++++++if+self._class_constants+is+not+None:
++++++++++++self._constants.update(self._class_constants)

++++def+constant(self,+name,+value):
++++++++assert+isinstance(name,+str)
++++++++assert+self._constants+is+not+None,+"AllowConstants+was+not+initialized"
++++++++if+name+in+self._constants+or+name+in+self.__dict__:
++++++++++++raise+ConstantError(name)
++++++++self._constants[name]+=+value

++++def+__getattr__(self,+attr):
++++++++if+attr+in+self._constants:
++++++++++++return+self._constants[attr]
++++++++raise+AttributeError(attr)

++++def+__setattr__(self,+attr,+val):
++++++++if+self._constants+is+None:
++++++++++++#+not+finished+initialization
++++++++++++self.__dict__[attr]+=+val
++++++++else:
++++++++++++if+attr+in+self._constants:
++++++++++++++++raise+ConstantError(attr)
++++++++++++else:
++++++++++++++++self.__dict__[attr]+=+val

++++def+__dir__(self):
++++++++return+super().__dir__()+%2B+list(self._constants.keys())|code-block|syntax|javascript|1704475|在子类化它时，您创建的常量将受到保护：|1704476|class+Example(AllowConstants):
++++def+__init__(self,+a,+b):
++++++++super().__init__()
++++++++self.constant("b",+b)
++++++++self.a+=+a

++++def+try_a(self,+value):
++++++++self.a+=+value

++++def+try_b(self,+value):
++++++++self.b+=+value

++++def+__str__(self):
++++++++return+str({"a":+self.a,+"b":+self.b})

++++def+__repr__(self):
++++++++return+self.__str__()


example+=+Example(1,+2)
print(example)++#+{'a':+1,+'b':+2}

example.try_a(5)
print(example)++#+{'a':+5,+'b':+2}

example.try_b(6)++#+ConstantError:+b

example.a+=+7
print(example)++#+{'a':+7,+'b':+2}

example.b+=+8++#+ConstantError:+b

print(hasattr(example,+"b"))++#+True

#++To+show+that+constants+really+do+immediately+become+constant:+

class+AnotherExample(AllowConstants):
++++def+__init__(self):
++++++++super().__init__()
++++++++self.constant("a",+2)
++++++++print(self.a)
++++++++self.a=3


AnotherExample()++#+2++ConstantError:+a


#+finally,+for+class+constants:
class+YetAnotherExample(Example):
++++_class_constants+=+{
++++++++'BLA':+3
++++}

++++def+__init__(self,+a,+b):
++++++++super().__init__(a,b)

++++def+try_BLA(self,+value):
++++++++self.BLA+=+value

ex3+=+YetAnotherExample(10,+20)
ex3.BLA++#+3
ex3.try_BLA(10)++#+ConstantError:+BLA
ex3.BLA+=+4++#+ConstantError:+BLA|1704477|常量是本地的(从AllowConstants继承的类的每个实例都有自己的常量)，只要它们不被重新赋值，就充当普通属性，并且编写继承自常量的类允许使用与支持常量的语言或多或少相同的风格。|1704478|此外，如果您想要防止任何人通过直接访问instance._constants来更改值，您可以使用其他答案中建议的许多容器中的一个。最后，如果您确实觉得需要，可以通过AllowConstants的更多属性访问来防止人们将所有的instance._constants设置到一个新的字典中。(当然，所有这些都不是pythonic式的，但这不是重点)。|1704479|编辑(因为使python+unpythonic是一个有趣的游戏)：为了使继承更容易，您可以修改AllowConstants，如下所示：|1704480|class+AllowConstants:
++++_constants+=+None
++++_class_constants+=+None

++++def+__init__(self):
++++++++self._constants+=+{}
++++++++self._update_class_constants()

++++def+__init_subclass__(cls):
++++++++"""
++++++++Without+this,+it+is+necessary+to+set+_class_constants+in+any+subclass+of+any+class+that+has+class+constants
++++++++"""
++++++++if+cls._class_constants+is+not+None:
++++++++++++#prevent+trouble+where+_class_constants+is+not+overwritten
++++++++++++possible_cases+=+cls.__mro__[1:-1]+#0+will+have+cls+and+-1+will+have+object
++++++++++++for+case+in+possible_cases:
++++++++++++++++if+cls._class_constants+is+case._class_constants:
++++++++++++++++++++cls._class_constants+=+None
++++++++++++++++++++break

++++def+_update_class_constants(self):
++++++++"""
++++++++Help+with+the+inheritance+of+class+constants
++++++++"""
++++++++for+superclass+in+self.__class__.__mro__:
++++++++++++if+hasattr(superclass,+"_class_constants"):
++++++++++++++++sccc+=+superclass._class_constants
++++++++++++++++if+sccc+is+not+None:
++++++++++++++++++++for+key+in+sccc:
++++++++++++++++++++++++if+key+in+self._constants:
++++++++++++++++++++++++++++raise+ConstantError(key)
++++++++++++++++++++self._constants.update(sccc)

++++def+constant(self,+name,+value):
++++++++assert+isinstance(name,+str)
++++++++assert+self._constants+is+not+None,+"AllowConstants+was+not+initialized"
++++++++if+name+in+self._constants+or+name+in+self.__dict__:
++++++++++++raise+ConstantError(name)
++++++++self._constants[name]+=+value

++++def+__getattr__(self,+attr):
++++++++if+attr+in+self._constants:
++++++++++++return+self._constants[attr]
++++++++raise+AttributeError(attr)

++++def+__setattr__(self,+attr,+val):
++++++++if+self._constants+is+None:
++++++++++++#+not+finished+initialization
++++++++++++self.__dict__[attr]+=+val
++++++++else:
++++++++++++if+attr+in+self._constants:
++++++++++++++++raise+ConstantError(attr)
++++++++++++else:
++++++++++++++++self.__dict__[attr]+=+val

++++def+__dir__(self):
++++++++return+super().__dir__()+%2B+list(self._constants.keys())|1704481|这样你就可以这样做了：|1704482|class+Example(AllowConstants):
++++_class_constants+=+{
++++++++"BLA":+2
++++}
++++def+__init__(self,+a,+b):
++++++++super().__init__()
++++++++self.constant("b",+b)
++++++++self.a+=+a

++++def+try_a(self,+value):
++++++++self.a+=+value

++++def+try_b(self,+value):
++++++++self.b+=+value

++++def+__str__(self):
++++++++return+str({"a":+self.a,+"b":+self.b})

++++def+__repr__(self):
++++++++return+self.__str__()


class+ChildExample1(Example):
++++_class_constants+=+{
++++++++"BLI":+88
++++}


class+ChildExample2(Example):
++++_class_constants+=+{
++++++++"BLA":+44
++++}


example+=+ChildExample1(2,3)
print(example.BLA)++#+2
example.BLA+=+8++#+ConstantError+BLA
print(example.BLI)++#+88
example.BLI+=+8++#+ConstantError+BLI

example+=+ChildExample2(2,3)++#+ConstantError+BLA|1704483|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

I know this is an old question, but since new solutions are still being added to it, I'd like to make the list of possible solutions even more complete. You could implement constants within instances through attribute access by inheriting from a class like the following: 

<pre><code>class ConstantError(Exception):
 pass # maybe give nice error message

class AllowConstants:
 _constants = None
 _class_constants = None

 def __init__(self):
 self._constants = {}
 if self._class_constants is not None:
 self._constants.update(self._class_constants)

 def constant(self, name, value):
 assert isinstance(name, str)
 assert self._constants is not None, "AllowConstants was not initialized"
 if name in self._constants or name in self.__dict__:
 raise ConstantError(name)
 self._constants[name] = value

 def __getattr__(self, attr):
 if attr in self._constants:
 return self._constants[attr]
 raise AttributeError(attr)

 def __setattr__(self, attr, val):
 if self._constants is None:
 # not finished initialization
 self.__dict__[attr] = val
 else:
 if attr in self._constants:
 raise ConstantError(attr)
 else:
 self.__dict__[attr] = val

 def __dir__(self):
 return super().__dir__() + list(self._constants.keys())

</code></pre>

When subclassing this, constants you create will be protected:

<pre><code>class Example(AllowConstants):
 def __init__(self, a, b):
 super().__init__()
 self.constant("b", b)
 self.a = a

 def try_a(self, value):
 self.a = value

 def try_b(self, value):
 self.b = value

 def __str__(self):
 return str({"a": self.a, "b": self.b})

 def __repr__(self):
 return self.__str__()


example = Example(1, 2)
print(example) # {'a': 1, 'b': 2}

example.try_a(5)
print(example) # {'a': 5, 'b': 2}

example.try_b(6) # ConstantError: b

example.a = 7
print(example) # {'a': 7, 'b': 2}

example.b = 8 # ConstantError: b

print(hasattr(example, "b")) # True

# To show that constants really do immediately become constant: 

class AnotherExample(AllowConstants):
 def __init__(self):
 super().__init__()
 self.constant("a", 2)
 print(self.a)
 self.a=3


AnotherExample() # 2 ConstantError: a


# finally, for class constants:
class YetAnotherExample(Example):
 _class_constants = {
 'BLA': 3
 }

 def __init__(self, a, b):
 super().__init__(a,b)

 def try_BLA(self, value):
 self.BLA = value

ex3 = YetAnotherExample(10, 20)
ex3.BLA # 3
ex3.try_BLA(10) # ConstantError: BLA
ex3.BLA = 4 # ConstantError: BLA
</code></pre>

Constants are local (every instance of classes inheriting from AllowConstants will have their own constants), act as normal attributes as long as they are not being re-assigned, and writing classes that inherit from this allows for more or less the same style as with languages that do support constants. 

Also, if you want to prevent anyone from changing the values by directly accessing instance._constants, you can use one of the many containers not allowing this that were suggested in other answers. Finally, if you really feel you need to, you could prevent people from setting all of instance._constants to a new dictionary through some more attribute access of AllowConstants. (Of course none of this is very pythonic, but that's besides the point).

Edit (since making python unpythonic is a fun game): In order to make inheritance a bit easier you could modify AllowConstants as follows:

<pre><code>class AllowConstants:
 _constants = None
 _class_constants = None

 def __init__(self):
 self._constants = {}
 self._update_class_constants()

 def __init_subclass__(cls):
 """
 Without this, it is necessary to set _class_constants in any subclass of any class that has class constants
 """
 if cls._class_constants is not None:
 #prevent trouble where _class_constants is not overwritten
 possible_cases = cls.__mro__[1:-1] #0 will have cls and -1 will have object
 for case in possible_cases:
 if cls._class_constants is case._class_constants:
 cls._class_constants = None
 break

 def _update_class_constants(self):
 """
 Help with the inheritance of class constants
 """
 for superclass in self.__class__.__mro__:
 if hasattr(superclass, "_class_constants"):
 sccc = superclass._class_constants
 if sccc is not None:
 for key in sccc:
 if key in self._constants:
 raise ConstantError(key)
 self._constants.update(sccc)

 def constant(self, name, value):
 assert isinstance(name, str)
 assert self._constants is not None, "AllowConstants was not initialized"
 if name in self._constants or name in self.__dict__:
 raise ConstantError(name)
 self._constants[name] = value

 def __getattr__(self, attr):
 if attr in self._constants:
 return self._constants[attr]
 raise AttributeError(attr)

 def __setattr__(self, attr, val):
 if self._constants is None:
 # not finished initialization
 self.__dict__[attr] = val
 else:
 if attr in self._constants:
 raise ConstantError(attr)
 else:
 self.__dict__[attr] = val

 def __dir__(self):
 return super().__dir__() + list(self._constants.keys())
</code></pre>

That way you can just do:

<pre><code>class Example(AllowConstants):
 _class_constants = {
 "BLA": 2
 }
 def __init__(self, a, b):
 super().__init__()
 self.constant("b", b)
 self.a = a

 def try_a(self, value):
 self.a = value

 def try_b(self, value):
 self.b = value

 def __str__(self):
 return str({"a": self.a, "b": self.b})

 def __repr__(self):
 return self.__str__()


class ChildExample1(Example):
 _class_constants = {
 "BLI": 88
 }


class ChildExample2(Example):
 _class_constants = {
 "BLA": 44
 }


example = ChildExample1(2,3)
print(example.BLA) # 2
example.BLA = 8 # ConstantError BLA
print(example.BLI) # 88
example.BLI = 8 # ConstantError BLI

example = ChildExample2(2,3) # ConstantError BLA
</code></pre>

blocks|key|1704550|text|我正在尝试用不同的方法在Python中创建一个真正的常量，也许我找到了一个很好的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1704551|示例：|offset|length|style|BOLD|1704552|创建常量容器|1704553|>>>+DAYS+=+Constants(
...+++++MON=0,
...+++++TUE=1,
...+++++WED=2,
...+++++THU=3,
...+++++FRI=4,
...+++++SAT=5,
...+++++SUN=6
...+)+++|code-block|syntax|javascript|1704554|从容器中获取值|1704555|>>>+DAYS.MON
0
>>>+DAYS['MON']
0++|1704556|用纯python数据结构表示|1704557|>>>+list(DAYS)
['WED',+'SUN',+'FRI',+'THU',+'MON',+'TUE',+'SAT']
>>>+dict(DAYS)
{'WED':+2,+'SUN':+6,+'FRI':+4,+'THU':+3,+'MON':+0,+'TUE':+1,+'SAT':+5}|1704558|所有常量都是不可变的。|1704559|>>>+DAYS.MON+=+7
...
AttributeError:+Immutable+attribute

>>>+del+DAYS.MON+
...
AttributeError:+Immutable+attribute|1704560|仅对常量自动完成|1704561|>>>+dir(DAYS)
['FRI',+'MON',+'SAT',+'SUN',+'THU',+'TUE',+'WED']|1704562|像list.sort一样排序|CODE|1704563|>>>+DAYS.sort(key=lambda+(k,+v):+v,+reverse=True)
>>>+list(DAYS)
['SUN',+'SAT',+'FRI',+'THU',+'WED',+'TUE',+'MON']|1704564|与python2和python3的可复制性|1704565|1704566|from+collections+import+OrderedDict
from+copy+import+deepcopy

class+Constants(object):
++++"""Container+of+constant"""

++++__slots__+=+('__dict__')

++++def+__init__(self,+**kwargs):

++++++++if+list(filter(lambda+x:+not+x.isupper(),+kwargs)):
++++++++++++raise+AttributeError('Constant+name+should+be+uppercase.')

++++++++super(Constants,+self).__setattr__(
++++++++++++'__dict__',
++++++++++++OrderedDict(map(lambda+x:+(x[0],+deepcopy(x[1])),+kwargs.items()))
++++++++)

++++def+sort(self,+key=None,+reverse=False):
++++++++super(Constants,+self).__setattr__(
++++++++++++'__dict__',
++++++++++++OrderedDict(sorted(self.__dict__.items(),+key=key,+reverse=reverse))
++++++++)

++++def+__getitem__(self,+name):
++++++++return+self.__dict__[name]

++++def+__len__(self):
++++++++return++len(self.__dict__)

++++def+__iter__(self):
++++++++for+name+in+self.__dict__:
++++++++++++yield+name

++++def+keys(self):
++++++++return+list(self)

++++def+__str__(self):
++++++++return+str(list(self))

++++def+__repr__(self):
++++++++return+'<%25s:+%25s>'+%25+(self.__class__.__name__,+str(self.__dict__))

++++def+__dir__(self):
++++++++return+list(self)

++++def+__setattr__(self,+name,+value):
++++++++raise+AttributeError("Immutable+attribute")

++++def+__delattr__(*_):
++++++++raise+AttributeError("Immutable+attribute")|1704567|entityMap^0|0|0|3|0|0|0|0|0|0|0|0|0|0|0|1|9|0|0|1|7|9|7|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1K|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1O|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1P|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1R|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|1S|8|@]|9|@]|A|$]]|$1|12|3|13|5|L|7|1T|8|@]|9|@]|A|$M|N]]|$1|14|3|15|5|6|7|1U|8|@$D|1V|E|1W|F|16]]|9|@]|A|$]]|$1|17|3|18|5|L|7|1X|8|@]|9|@]|A|$M|N]]|$1|19|3|1A|5|6|7|1Y|8|@$D|1Z|E|20|F|16]|$D|21|E|22|F|16]]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|L|7|24|8|@]|9|@]|A|$M|N]]|$1|1E|3|-4|5|6|7|25|8|@]|9|@]|A|$]]]|1F|$]]

I am trying different ways to create a real constant in Python and perhaps I found the pretty solution.
Example:
Create container for constants
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; DAYS = Constants(
... MON=0,
... TUE=1,
... WED=2,
... THU=3,
... FRI=4,
... SAT=5,
... SUN=6
... ) 
</code></pre>
Get value from container
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; DAYS.MON
0
&gt;&gt;&gt; DAYS['MON']
0 
</code></pre>
Represent with pure python data structures
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; list(DAYS)
['WED', 'SUN', 'FRI', 'THU', 'MON', 'TUE', 'SAT']
&gt;&gt;&gt; dict(DAYS)
{'WED': 2, 'SUN': 6, 'FRI': 4, 'THU': 3, 'MON': 0, 'TUE': 1, 'SAT': 5}
</code></pre>
All constants are immutable
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; DAYS.MON = 7
...
AttributeError: Immutable attribute

&gt;&gt;&gt; del DAYS.MON 
...
AttributeError: Immutable attribute
</code></pre>
Autocomplete only for constants
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; dir(DAYS)
['FRI', 'MON', 'SAT', 'SUN', 'THU', 'TUE', 'WED']
</code></pre>
Sorting like <code>list.sort</code>
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; DAYS.sort(key=lambda (k, v): v, reverse=True)
&gt;&gt;&gt; list(DAYS)
['SUN', 'SAT', 'FRI', 'THU', 'WED', 'TUE', 'MON']
</code></pre>
Copability with <code>python2</code> and <code>python3</code>
<a href="https://github.com/kephircheek/python-constants" rel="nofollow noreferrer">Simple container for constants</a>
<pre class="lang-py prettyprint-override"><code>from collections import OrderedDict
from copy import deepcopy

class Constants(object):
 &quot;&quot;&quot;Container of constant&quot;&quot;&quot;

 __slots__ = ('__dict__')

 def __init__(self, **kwargs):

 if list(filter(lambda x: not x.isupper(), kwargs)):
 raise AttributeError('Constant name should be uppercase.')

 super(Constants, self).__setattr__(
 '__dict__',
 OrderedDict(map(lambda x: (x[0], deepcopy(x[1])), kwargs.items()))
 )

 def sort(self, key=None, reverse=False):
 super(Constants, self).__setattr__(
 '__dict__',
 OrderedDict(sorted(self.__dict__.items(), key=key, reverse=reverse))
 )

 def __getitem__(self, name):
 return self.__dict__[name]

 def __len__(self):
 return len(self.__dict__)

 def __iter__(self):
 for name in self.__dict__:
 yield name

 def keys(self):
 return list(self)

 def __str__(self):
 return str(list(self))

 def __repr__(self):
 return '&lt;%s: %s&gt;' % (self.__class__.__name__, str(self.__dict__))

 def __dir__(self):
 return list(self)

 def __setattr__(self, name, value):
 raise AttributeError(&quot;Immutable attribute&quot;)

 def __delattr__(*_):
 raise AttributeError(&quot;Immutable attribute&quot;)

</code></pre>

blocks|key|3113239|text|您可以对常量变量使用元组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3113240|·元组是有序的、不可更改的元组()集合|offset|length|style|BOLD|3113241|my_tuple+=+(1,+"Hello",+3.4)
print(my_tuple[0])|code-block|syntax|javascript|3113242|entityMap^0|0|G|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can use Tuple for constant variable :
• A tuple is a collection which is ordered and unchangeable
<pre><code>my_tuple = (1, &quot;Hello&quot;, 3.4)
print(my_tuple[0])
</code></pre>

blocks|key|3113278|text|在Python语言中创建常量的一种更好的方法是从优秀的attrs库中获得灵感，该库可以帮助Python程序员创建没有样板的类。通过为attr.make_class提供一个方便的包装器，short-con包对常量也做了同样的事情。免责声明：我是short-con的作者。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3113279|值可以通过dict或kwargs显式声明:这些示例做同样的事情。constants()函数支持该库的所有特性，而cons()是一个帮助器，用于简单的基于kwarg的使用。|CODE|3113280|from+short_con+import+constants,+cons

Pieces+=+constants('Pieces',+dict(king+=+0,+queen+=+9,+rook+=+5,+bishop+=+3,+knight+=+3,+pawn+=+1))
Pieces+=+cons('Pieces',+king+=+0,+queen+=+9,+rook+=+5,+bishop+=+3,+knight+=+3,+pawn+=+1)|code-block|syntax|javascript|3113281|对于值与属性名称相同(或可以从属性名称派生)的情况，使用更加紧凑。只需以空格分隔的字符串、列表或元组形式提供名称即可。|3113282|NAMES+=+'KING+QUEEN+ROOK+BISHOP+KNIGHT+PAWN'
xs+=+NAMES.split()

Pieces+=+constants('Pieces',+NAMES)++++++#+All+of+these+do+the+same+thing.
Pieces+=+constants('Pieces',+xs)
Pieces+=+constants('Pieces',+tuple(xs))|3113283|基于名称的用法支持一些样式约定:大写或小写的属性名称，以及枚举样式的值。|3113284|与内置enum库创建的常量不同，底层的值可以直接访问：|3113285|Pieces.QUEEN++++++++#+short-con+usage
Pieces.QUEEN.value++#+enum+library+usage|3113286|并且该对象可以直接迭代和转换为其他集合：|3113287|for+name,+value+in+Pieces:
++++print(name,+value)

d+=+dict(Pieces)
tups+=+list(Pieces)|3113288|entityMap|0|LINK|mutability|MUTABLE|url|https://www.attrs.org/en/stable/|1|https://www.attrs.org/en/stable/api.html#attr.make_class|2|https://pypi.org/project/short-con/|3|https://docs.python.org/3/library/enum.html^0|36|4|R|5|0|1U|F|1|2K|9|2|0|5|4|A|6|W|B|1K|6|0|0|0|0|0|3|4|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@$9|1I|A|1J|1|1K]|$9|1L|A|1M|1|1N]|$9|1O|A|1P|1|1Q]]|E|$]]|$1|F|3|G|5|6|7|1R|8|@$9|1S|A|1T|B|H]|$9|1U|A|1V|B|H]|$9|1W|A|1X|B|H]|$9|1Y|A|1Z|B|H]]|D|@]|E|$]]|$1|I|3|J|5|K|7|20|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|21|8|@]|D|@]|E|$]]|$1|P|3|Q|5|K|7|22|8|@]|D|@]|E|$L|M]]|$1|R|3|S|5|6|7|23|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|24|8|@]|D|@$9|25|A|26|1|27]]|E|$]]|$1|V|3|W|5|K|7|28|8|@]|D|@]|E|$L|M]]|$1|X|3|Y|5|6|7|29|8|@]|D|@]|E|$]]|$1|Z|3|10|5|K|7|2A|8|@]|D|@]|E|$L|M]]|$1|11|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]]|12|$13|$5|14|15|16|E|$17|18]]|19|$5|14|15|16|E|$17|1A]]|1B|$5|14|15|16|E|$17|1C]]|1D|$5|14|15|16|E|$17|1E]]]]

A better approach to creating constants in Python is to take inspiration from
the excellent <a href="https://www.attrs.org/en/stable/" rel="nofollow noreferrer">attrs</a> library, which helps
Python programmers create classes without boilerplate. The
<a href="https://pypi.org/project/short-con/" rel="nofollow noreferrer">short-con</a> package does the same for
constants by providing a convenience wrapper around
<a href="https://www.attrs.org/en/stable/api.html#attr.make_class" rel="nofollow noreferrer">attr.make_class</a>. [Disclaimer: I am the author of short-con.]
Values can be declared explicitly via either a <code>dict</code> or <code>kwargs</code>: These
examples do the same thing. The <code>constants()</code> function supports all features of
the library, and <code>cons()</code> is a helper for simple kwarg-based usage.
<pre><code>from short_con import constants, cons

Pieces = constants('Pieces', dict(king = 0, queen = 9, rook = 5, bishop = 3, knight = 3, pawn = 1))
Pieces = cons('Pieces', king = 0, queen = 9, rook = 5, bishop = 3, knight = 3, pawn = 1)
</code></pre>
For situations when the values are the same as (or can be derived from) the
attribute names, usage is even more compact. Just supply names as a
space-delimited string, list, or tuple.
<pre><code>NAMES = 'KING QUEEN ROOK BISHOP KNIGHT PAWN'
xs = NAMES.split()

Pieces = constants('Pieces', NAMES) # All of these do the same thing.
Pieces = constants('Pieces', xs)
Pieces = constants('Pieces', tuple(xs))
</code></pre>
The name-based usages support a few stylistic conventions: uppercase or
lowercase attribute names, along with enum-style values.
The underlying values are directly accessible, unlike constants created by the
built-in <a href="https://docs.python.org/3/library/enum.html" rel="nofollow noreferrer">enum</a> library:
<pre><code>Pieces.QUEEN # short-con usage
Pieces.QUEEN.value # enum library usage
</code></pre>
And the object is directly iterable and convertible to other collections:
<pre><code>for name, value in Pieces:
 print(name, value)

d = dict(Pieces)
tups = list(Pieces)
</code></pre>

blocks|key|371588|text|注意:这是一个糟糕的想法和糟糕的实现。此外，它只适用于最后的小示例，完整的实现将意味着大量的工作，这是我懒得做的。此外，在Python3.8之前的版本中，审计钩子可能不可用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|371589|我基本上回答了another+question，结果发现它和这个有关。这个想法是，你可以利用audit+hooks来捕获每一行的执行，解析代码对象，如果它满足了某个条件(例如，某个前缀并且已经定义了一次)，你就可以抛出一个错误。|offset|length|371590|你可能不得不支持其他赋值类型(例如，对于导入的东西，可能对于函数内部的局部变量，解包等)，不使用globals，因为这个字典很容易被修改，实际调查这是否安全，接受这个实现将对你的整个应用程序造成的性能损失，确保这在REPL之外工作，在ipython内，等等。|style|CODE|BOLD|371591|>>>+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+%2B+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'|code-block|syntax|javascript|371592|如果你最终走上了这种道路，而你不应该这样做，除了修复和泛化代码之外，你可能想要找到一种方法，只让一些东西保持不变，例如，只有那些有特殊前缀的对象或只有有一些注释的对象。|371593|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/11024646/is-it-possible-to-overload-python-assignment|1|https://www.python.org/dev/peps/pep-0578/^0|0|7|G|0|1A|B|1|0|1C|7|27|G|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]|$D|16|E|17|1|18]]|A|$]]|$1|F|3|G|5|6|7|19|8|@$D|1A|E|1B|H|I]|$D|1C|E|1D|H|J]]|9|@]|A|$]]|$1|K|3|L|5|M|7|1E|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|1F|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]|Z|$5|U|V|W|A|$X|10]]]]

Note: This is a terrible idea and a terrible implementation. Also it only works for the small example at the end, a full implementation would mean lots of work, which I'm too lazy to do. Also audit hooks are probably not available before Python 3.8.
I mostly-answered <a href="https://stackoverflow.com/questions/11024646/is-it-possible-to-overload-python-assignment">another question</a> and it turns out it's related to this one. The idea is that you can take advantage of <a href="https://www.python.org/dev/peps/pep-0578/" rel="nofollow noreferrer">audit hooks</a> to catch the execution of every line, parse the code object, and if it fills some condition (e.g. a certain prefix and has been defined once) you can throw an error.
You'd probably have to support other assignment types (e.g. for imported stuff, maybe for locals inside functions, with unpacking, etc), not use <code>globals</code> since that dict can easily be modified, actually investigate if this is secure, accept the performance penalty this implementation will have for your whole application, make sure this works outside the REPL, inside ipython, etc etc. Anyway, here's we go:
<pre class="lang-py prettyprint-override"><code>&gt;&gt;&gt; import sys
&gt;&gt;&gt; import ast
&gt;&gt;&gt; import dis
&gt;&gt;&gt; import types
&gt;&gt;&gt; 
&gt;&gt;&gt; 
&gt;&gt;&gt; def hook(name, tup):
... if name == &quot;exec&quot; 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 == &quot;STORE_NAME&quot;:
... 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(&quot;Cannot re-assign variable&quot;)
... 
&gt;&gt;&gt; 
&gt;&gt;&gt; sys.addaudithook(hook)
&gt;&gt;&gt; 
&gt;&gt;&gt; a = '123'
&gt;&gt;&gt; a = 456
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 16, in hook
Exception: Cannot re-assign variable
&gt;&gt;&gt; 
&gt;&gt;&gt; a
'123'
</code></pre>
If you end up going this way, which you shouldn't, other than fixes and generalization to the code you'll probably want to find a way to only make some stuff constant, e.g. only those objects with a special prefix or only objects that have some annotation.

blocks|key|1704723|text|这不完全是常量，但从Python3.7开始，您可以使用dataclasses模块，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1704724|from+dataclasses+import+dataclass
from+typing+import+Final

@dataclass(frozen=True)
class+A():
++++a1:Final+=+3

a+=+A()

a.a1+=+4

---------------------------------------------------------------------------
FrozenInstanceError+++++++++++++++++++++++Traceback+(most+recent+call+last)
<ipython-input-14-5f7f4efc5bf0>+in+<module>
---->+1+a.a1+=+4

<string>+in+__setattr__(self,+name,+value)

FrozenInstanceError:+cannot+assign+to+field+'a1'|code-block|syntax|javascript|1704725|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/dataclasses.html^0|R|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

This is not exactly constant but starting from python 3.7 you may use <a href="https://docs.python.org/3/library/dataclasses.html" rel="nofollow noreferrer">dataclasses</a> module like below:
<pre><code>from dataclasses import dataclass
from typing import Final

@dataclass(frozen=True)
class A():
 a1:Final = 3

a = A()

a.a1 = 4

---------------------------------------------------------------------------
FrozenInstanceError Traceback (most recent call last)
&lt;ipython-input-14-5f7f4efc5bf0&gt; in &lt;module&gt;
----&gt; 1 a.a1 = 4

&lt;string&gt; in __setattr__(self, name, value)

FrozenInstanceError: cannot assign to field 'a1'
</code></pre>

blocks|key|3113391|text|我使用冻结数据类声明常量值，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3113392|from+dataclasses+import+dataclass

@dataclass(frozen=True)
class+_Const:
++++SOME_STRING+=+'some_string'
++++SOME_INT+=+5
++++
Const+=+_Const()

#+In+another+file+import+Const+and+try
print(Const.SOME_STRING)++#+ITS+OK!
Const.SOME_INT+=+6++#+dataclasses.FrozenInstanceError:+cannot+assign+to+field+'SOME_INT'|code-block|syntax|javascript|3113393|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I declare constant values using frozen data class like this:
<pre><code>from dataclasses import dataclass

@dataclass(frozen=True)
class _Const:
 SOME_STRING = 'some_string'
 SOME_INT = 5
 
Const = _Const()

# In another file import Const and try
print(Const.SOME_STRING) # ITS OK!
Const.SOME_INT = 6 # dataclasses.FrozenInstanceError: cannot assign to field 'SOME_INT'
</code></pre>

Is there a way to declare a constant in Python? In Java we can create constant values in this manner:

<pre class="lang-java prettyprint-override"><code>public static final String CONST_NAME = "Name";
</code></pre>

What is the equivalent of the above Java constant declaration in Python?

How do I create a constant in Python?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有办法在Python中声明一个常量？在Java中，我们可以这样创建常量值：public static final String CONST_NAME = "Name";Python中上述Java常量声明的等价物是什么？

问如何在Python中创建常量？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中创建常量？EN