在python类中定义常量，真的需要self吗？

Question

我想在类中定义一组常量，例如：

class Foo(object):
   (NONEXISTING,VAGUE,CONFIRMED) = (0,1,2)
   def __init__(self):
       self.status = VAGUE

但是，我得到了

NameError: global name 'VAGUE' is not defined

是否有一种方法可以将这些常量定义为在类中可见，而无需借助 global 或 self.NONEXISTING = 0 等？

Answer 1

当您在类主体中分配名称时，您正在创建该类的属性。如果不直接或间接引用该类，则无法引用它们。您可以使用 Foo.VAGUE 正如其他答案所说，或者您可以使用 self.VAGUE。您不必分配给self的属性。

通常，使用 self.VAGUE 是您想要的，因为它允许子类重新定义属性，而不必重新实现使用它们的所有方法 - 在这个特定的情况下，这似乎不是明智的做法例子，但谁知道呢。

Answer 2

尝试代替：

self.status = VAGUE

这个：

self.status = Foo.VAGUE

你必须指定类

Answer 3

无论如何，都不建议任何代码使用此方法，但是可以完成如下所示的丑陋的黑客攻击。
我这样做只是为了更好地理解 Python AST API，所以任何在现实代码中使用它的人都应该在它造成任何伤害之前被枪杀:-)

#!/usr/bin/python
# -*- coding: utf-8-unix -*-
#
# AST hack to replace symbol reference in instance methods,
# so it will be resolved as a reference to class variables.
#

import inspect, types, ast

def trim(src):
    lines = src.split("\n")
    start = lines[0].lstrip()
    n = lines[0].index(start)
    src = "\n".join([line[n:] for line in lines])
    return src

#
# Method decorator that replaces symbol reference in a method
# so it will use symbols in belonging class instead of the one
# in global namespace.
#
def nsinclude(*args):
    # usecase: @nsinclude()
    # use classname in calling frame as a fallback
    stack = inspect.stack()
    opts  = [stack[1][3]]

    def wrap(func):
        if func.func_name == "tempfunc":
            return func

        def invoke(*args, **kw):
            base = eval(opts[0])

            src = trim(inspect.getsource(func))
            basenode = ast.parse(src)

            class hackfunc(ast.NodeTransformer):
                def visit_Name(self, node):
                    try:
                        # if base class (set in @nsinclude) can resolve
                        # given name, modify AST node to use that instead
                        val = getattr(base, node.id)

                        newnode = ast.parse("%s.%s" % (opts[0], node.id))
                        newnode = next(ast.iter_child_nodes(newnode))
                        newnode = next(ast.iter_child_nodes(newnode))
                        ast.copy_location(newnode, node)
                        return ast.fix_missing_locations(newnode)
                    except:
                        return node

            class hackcode(ast.NodeVisitor):
                def visit_FunctionDef(self, node):
                    if func.func_name != "tempfunc":
                        node.name = "tempfunc"
                        hackfunc().visit(node)

            hackcode().visit(basenode)

            newmod = compile(basenode, '<ast>', 'exec')
            eval(newmod)
            newfunc = eval("tempfunc")
            newfunc(*args, **kw)
        return invoke


    # usecase: @nsinclude
    if args and isinstance(args[0], types.FunctionType):
        return wrap(args[0])

    # usecase: @nsinclude("someclass")
    if args and args[0]:
        opts[0] = args[0]
    return wrap

class Bar:
    FOO = 987
    BAR = 876

class Foo:
    FOO = 123
    BAR = 234

    # import from belonging class
    @nsinclude
    def dump1(self, *args):
        print("dump1: FOO = " + str(FOO))


    # import from specified class (Bar)
    @nsinclude("Bar")
    def dump2(self, *args):
        print("dump2: BAR = " + str(BAR))

Foo().dump1()
Foo().dump2()

Answer 4

唯一的方法是通过类名访问它，例如

Foo.VAGUE

如果仅访问 __init__ 函数或函数内的 VAGUE，则必须在其中声明它才能以您想要的方式访问它。

使用 self 也适用于类的实例。

Answer 5

在Python3中，您还可以引用VAGUE：

type(self).VAGUE

这样，您可以清楚地将其作为类属性而不是对象属性进行引用，但这种方式对于类的名称更改来说是稳健的。此外，如果您在子类中重写VAGUE，则将使用子类中的值，就像您使用self.VAGUE一样。

请注意，此方法似乎在 Python2 中不起作用，至少在我的测试中不起作用，其中 type(self) 返回 instance 而不是我实例化的类。因此，考虑到 Python2 仍然广泛传播，Thomas Wouters 的答案可能更可取。