Question

我想在代码中替换字符串文字，因为我想最大程度地减少打字错误的风险，尤其是在dict键集中：

a['typoh'] = 'this is bad'

我不想重复输入两次（错误输入错误的值）
我希望它可以被各种IDE“跟踪”（即，单击以查看其定义位置并转义完成）。
枚举用尽：获取“ a”的“ E.a.name”是愚蠢的。

有人告诉我可以使用插槽来完成此操作，但是我无法弄清楚没有一点诡计。我可以想到以下几种方法：

这是不可接受的答案：

class TwiceIsNotNice(object):
    this_is_a_string = 'this_is_a_string'
    ... (five thousand string constants in)
    this_has_a_hard_to_spot_typographical_error = 
                   'this_has_a_had_to_spot_typographical_error'
    ... (five thousand more string constants)

“ Stringspace”类/对象是一个清晰而烦人的方法，该类/对象通过传入的字符串列表来设置属性。这解决了打字错误的风险最小化，非常易于阅读，但是既没有IDE的可跟踪性，也没有自动完成功能。没关系，但是会让人们抱怨（请不要在这里抱怨，我只是在演示如何做到）：

string_consts = Stringspace('a', 'b',...,'asdfasdfasdf')
print(string_consts.a)

... where:
class Stringspace(object):
    def __init__(self, *strlist):
        for s in strlist:
            setattr(self, s, s)

另一种方法是使用哨兵对象定义类，并在后期阶段设置值。可以，可以跟踪，可以将自己显示为实际的类，可以使用别名等。但这需要在类结束时进行一个烦人的额外调用：

same = object()

class StrList(object):
    this_is_a_strval = same
    this_is_another_strval = same
    this_gets_aliased = "to something else"

# This would of course could become a function
for attr in dir(StrList):
    if getattr(StrList, attr) is same:
        setattr(StrList, attr, attr) 

print(StrList.a)

如果这正是插槽的魔力所在，那么我很失望，因为实际上必须实例化一个对象：

class SlotEnum(object):
    __slots__ = []
    def __init__(self):
       for k in self.__slots__:
            setattr(self, k, k)

class Foo(SlotEnum):
    __slots__ = ['a', 'b']

foo_enum_OBJECT = Foo()
print(foo_enum_OBJECT.a)

Answer 1

我发现了一个使用自定义元类的解决方案at this external link，该类包含字符串成员变量：

第1步，共2步：可以如下定义自定义元类：

class MetaForMyStrConstants(type):
    def __new__(metacls, cls, bases, classdict):
        object_attrs = set(dir(type(cls, (object,), {})))
        simple_enum_cls = super().__new__(metacls, cls, bases, classdict)
        simple_enum_cls._member_names_ = set(classdict.keys()) - object_attrs
        non_members = set()
        for attr in simple_enum_cls._member_names_:
            if attr.startswith('_') and attr.endswith('_'):
                non_members.add(attr)
            else:
                setattr(simple_enum_cls, attr, attr)

        simple_enum_cls._member_names_.difference_update(non_members)

        return simple_enum_cls

第2步，共2步：可以这样定义定义字符串的类（使用伪值，例如空元组）：

class MyStrConstants(metaclass=MetaForMyStrConstants):
    ONE_LONG_STR = ()
    ANOTHER_LONG_STR = ()
    THE_REAL_LONGEST_STR = ()

进行测试：

print (MyStrConstants.ONE_LONG_STR)
print (MyStrConstants.ANOTHER_LONG_STR)
print (MyStrConstants.THE_REAL_LONGEST_STR)

输出：

ONE_LONG_STR
ANOTHER_LONG_STR
THE_REAL_LONGEST_STR

Answer 2

枚举用尽：E.a.name变得愚蠢。{li>

from enum import Enum, auto

class StrEnum(str, Enum):
    "base class for Enum members to be strings matching the member's name"

    def __repr__(self):
        return '<%s.%s>' % (self.__class__.__name__, self.name)

    def __str__(self):
        return self.name


class E(StrEnum):

    a = auto()
    this_is_a_string = auto()
    no_typo_here = auto()

设置一个成员变量字符串，其值为其名称

2 个答案: