Python 静态不可变属性

Question

在 Python 中实现静态不可变属性的正确方法是什么？

小例子：

程序模块“家庭”有一个类Parent，定义如下：

class Parent():
    def __init__(self, type):
        self.type = type

父级可以是以下两种字符串类型之一：'mother' 或 'father'。该类的外部用户应该能够在构造时设置类型，然后查询parent.type 以获取这两个值中的任何一个。此外，Family 模块的其他部分使用Parent 类并依赖于返回的这两个值中的任何一个。因此，对类型的要求如下：

• 可供用户外部和家庭模块内部使用
• 始终是“母亲”或“父亲”，因此基于不可变变量

---

一种天真的方法可以通过传递字符串来鼓励设置类型：

parent = Parent('mother')

但这允许意外拼写错误（例如Parent('omther')）。为了防止这种情况，我采用了以下方法：

class Parent():
    TYPE_MOTHER = 'mother'
    TYPE_FATHER = 'father'
    TYPES = [TYPE_MOTHER, TYPE_FATHER]

    def __init__(self, type):
        assert type in self.TYPES, ('Invalid type "%s"' % type)
        self.type = type

parent = Parent(Parent.TYPE_MOTHER)

但是，没有什么能阻止用户随意更改这些静态变量，例如：

parent = Parent('mother')
Parent.TYPE_MOTHER = 'burrito'
print(parent.type == Parent.TYPE_MOTHER)
#> False

为了解决这个问题，我考虑使用@staticmethod 和@property 注释：

class Parent():
    @property
    @staticmethod
    def TYPE_MOTHER():
        return 'mother'

    @property
    @staticmethod
    def TYPE_FATHER():
        return 'father'

这不会阻止用户将字符串传递给构造函数（例如Parent('mother')），但至少可以防止他们通过更改父类型来搞砸 Family 模块。

---

我在使用这种方法时遇到的问题：

• 很丑，4行代码而不是1行
• 感觉很老套（可能是由于我在其他语言中使用受语言支持的私有静态变量的经验）
• 我的 IDE 的 linter 不喜欢它，因为没有“self”参数（即使提供了）

您的问题：

• 这个方法是 Pythonic 的吗？
• 有更好的方法吗？
• 您能否建议一种模式来实现这种不变性，同时强制用户仅使用我希望他们使用的变量，防止他们将原始字符串传递给构造函数？

Answer 1

这不就是课程的用途吗？只需要继承 Mother 和 Father 类即可：

class Parent():
    def __init__(self, type):
        self.type = type

class Mother(Parent):
    def __init__(self):
        super().__init__('mother')

class Father(Parent):
    def __init__(self):
        super().__init__('father')

parent = Mother()

Answer 2

总体而言，方法很好，只是有点长。如果您不想实现继承，最简单的方法是让TYPES 列表成为受保护的类变量：

class Parent():
    def __init__(self, type):
        self._TYPES = ['mother', 'father']
        assert type in self._TYPES, ('Invalid type "%s"' % type)
        self.type = type

Answer 3

我为我的问题找到了一个整洁的答案 - Enum class (doc)。

from enum import Enum
class Parent():
    class TYPES(Enum):
        MOTHER = 'mother'
        FATHER = 'father'

    def __init__(self, type:TYPES):
        assert type in self.TYPES, ('Invalid type "%s"' % type)
        self.type = type

parent = Parent(Parent.TYPES.MOTHER)

在这种情况下，用户仍然可以覆盖Parent.TYPES。除了使用__setattr__ 并捕获恶意写入之外，我想不出另一种方法来防止它。如果你能想到这里分享你的想法。

这种模式提供以下好处：

• 由于 Enum 的政策，无法覆盖单个属性 MOTHER 和 FATHER
• 由于__setattr__，无法覆盖类型
• 无法使用原始字符串代替 Parent.TYPES.MOTHER（或 .FATHER）
• 兼容assert type in self.TYPES或assert isinstance(type, self.TYPES)

到目前为止，我可以看到两个用法上的不同：

• 如果我想获得实际值 - 即。 “母亲”或“父亲”，那么我需要使用枚举的.value 属性。所以我需要使用parent.type.value 而不是parent.type（它将返回"TYPES.MOTHER"），它正确返回'mother'。
• 要打印TYPES的内容我需要使用list(self.TYPES)

我认为使用 Enum 我也可以放弃 ALL_CAPS 标准，因为我不需要表示 types 是静态的。