定义常量列表或字典的最佳/最简洁方法

Question

我无法创建与 C HEADER 文件 (.h) 同义的内容。

我有中等大小的字典和列表（大约 1,000 个元素）、冗长的枚举和“#defines”（实际上不是），但我找不到一种干净的方式来组织它们。在 C 中，我会将它们全部放入头文件中，并且不再考虑它，但是，在 Python 中这是不可能的，或者我认为是这样。

当前的脏解决方案：我正在初始化 MODULE 或 FUNCTION 顶部的所有常量变量（如果多个函数需要它，则为模块）。

如果有人想出一种干净地组织常量变量的方法，我将不胜感激。

非常感谢您！

Answer 1

将常量放入自己的模块中：

# constants.py

RED = 1
BLUE = 2
GREEN = 3

然后导入该模块并使用常量：

import constants

print "RED is", constants.RED

常量可以是你喜欢的任何值，我在这里显示了整数，但列表和字典的工作原理是一样的。

Answer 2

我通常这样做：

文件：constants.py

CONSTANT1 = 'asd'
CONSTANT_FOO = 123
CONSTANT_BAR = [1, 2, 5]

文件：your_script.py

from constants import CONSTANT1, CONSTANT_FOO
# or if you want *all* of them
# from constants import *

...

现在您的常量位于一个文件中，您可以很好地导入和使用它们。

Answer 3

创建一个单独的文件

constants.py

，并将所有全局相关的常量放入其中。然后您可以

import constants

将它们称为

constants.SPAM

或执行（有疑问的）

from constants import *

将它们简单地称为

SPAM

或

EGGS

。

这里请注意，Python 不支持 constant 常量。约定只是用

ALL_CAPS

命名它们，并承诺不会改变它们。

Answer 4

接受的答案很好，要更进一步，可以在定义常量时使用类型；您可以只指定 Final，或者更进一步并提供 Final[type]，例如：

from typing import Final, List
CONSTANT1: Final = 'asd'
CONSTANT_FOO: Final[int] = 123
ADLS_ENVIRONMENTS: Final[List[str]] = ["sandbox", "dev", "uat", "prod"]

# etc.

参见 https://www.python.org/dev/peps/pep-0591/#the-final-annotation

Answer 5

如果你想搞乱嵌套常量并且不喜欢听写，我想出了这个有趣的解决方案：

# Recursively transform a dict to instances of the desired class

import json
from collections import namedtuple

class DictTransformer():
    @classmethod
    def constantize(self, d):
        return self.transform(d, klass=namedtuple, klassname='namedtuple')

    @classmethod
    def transform(self, d, klass, klassname):
        return self._from_json(self._to_json(d), klass=klass, klassname=klassname)

    @classmethod
    def _to_json(self, d, access_method='__dict__'):
        return json.dumps(d, default=lambda o: getattr(o, access_method, str(o)))

    @classmethod
    def _from_json(self, jsonstr, klass, klassname):
        return json.loads(jsonstr, object_hook=lambda d: klass(klassname, d.keys())(*d.values()))

例如：

constants = {
  'A': {
    'B': {
      'C': 'D'
    }
  }
}
CONSTANTS = DictTransformer.transform(d, klass=namedtuple, klassname='namedtuple')
CONSTANTS.A.B.C == 'D'

优点：

• 处理嵌套字典
• 可能会生成其他类型的字典/类
• 命名元组为常量提供不变性

缺点：

• 如果您的 klass 上未提供 .keys 和 .values，则可能不会响应这些内容（尽管您有时可以使用 ._fields 和 list(A.B.C) 来模仿）

想法？

h/t 致@hlzr 和你们，了解最初的课程创意