class Directions:
            up = 0
            down = 1
            left = 2
            right =3
            

我给了一个1至Kugel补，但另一个更精简选项

dirUp, dirDown, dirLeft, dirRight = range(4)
            

该collections.namedtuple对象可以提供这样一个命名空间：

>>> import collections
            >>> dircoll=collections.namedtuple('directions', ('UP', 'DOWN', 'LEFT', 'RIGHT'))
            >>> directions=dircoll(0,1,2,3)
            >>> directions
            directions(UP=0, DOWN=1, LEFT=2, RIGHT=3)
            >>> directions.DOWN
            1
            >>>
            

如果您是使用Python 2.6 +那么你可以使用namedtuple 。他们有优势，有固定数量的属性，当你需要的所有枚举值，可以使用它就像一个元组。

为了更好地控制枚举值，你可以创建自己的枚举类。

def enum(args, start=0):
            class Enum(object):
            __slots__ = args.split()
            def __init__(self):
            for i, key in enumerate(Enum.__slots__, start):
            setattr(self, key, i)
            return Enum()
            >>> e_dir = enum('up down left right')
            >>> e_dir.up
            0
            >>> e_dir = enum('up down left right', start=1)
            >>> e_dir.up
            1
            

声明__slots__密封的枚举类，没有更多的属性可以被设置为1这是从一个类创建的对象Enum财产。

您的namedtuple类也可以namedtuple docs为基础，在这种情况下你也可以得到一个元组的功能。见在子类

如果您确信您需要一个枚举，其他人回答如何做到这一点。但是让我们明白你为什么要他们？认识的动机将有助于选择的解决方案。

• 原子值的c -小数目很容易通过周围，字符串是不是。在Python中，“字符串，如”行动是完全使用好了很多。此外，任何解决方案，最终只有一个数字更为严重的调试！

• 有意义的价值观中c - ，你经常要处理现有的幻数，而只想说一些语法糖。这不是这里的情况。然而， 还有其他有意义的信息想你可能会联想到的方向，如（dx和dy）载体-更多的下文。

• 类型检查 -在C，枚举帮助追赶无效的值在编译时。宁可牺牲，但一般的Python编译器中键入检查少。

• 反思 （不存在在C枚举） -你想知道所有的有效值。

  • 完成 -编辑器可以显示你的可能值，帮助您键入。

弦乐赎回（又名符号）

因此，在Python化解决方案的光端，只是使用字符串，可能有/的所有有效的值设置一个列表：

DIRECTIONS = set(['up', 'down', 'left', 'right'])
            def move(self, direction):
            # only if you feel like checking
            assert direction in DIRECTIONS
            # you can still just use the strings!
            if direction == 'up':
            # Do something
            

请注意，调试器会告诉你该函数与'了'作为它的参数调用。任何解决方案，其中direction其实0比这更糟糕得多！

在语言LISP的家庭，这种用法是被称为符号 -原子对象可用的将被视为容易为数字， 而是带着文本值 。 （准确，符号串类，而是一个单独的类型。然而，Python经常使用正则字符串将使用其中的LISP符号。）

命名空间字符串

你可以结合的思想， 'up'优于UP = 'up' ... RIGHT = 'right' 与其他解决方案。

如果你想赶上mispellings（在运行时间）：

class Directions:
            UP = "up"
            ...
            RIGHT = "right"
            

如果你想坚持键入一个前缀得到完成，把一类以上：

from directions import *

或只是在一个单独的文件，使一个模块。

模块允许用户做懒惰Directions.UP跳过前缀 - 取决于你是否认为这是一个加号或减号... （我个人不想被强迫型if如果我使用它的频率）。

对象与功能

如果有什么有用的信息/功能性价值与每个？“正确”的价值观不仅是一个4任意的，它是X轴正方向上了！

如果你在做什么在这def move(self, direction): if direction == 'up': self.y += STEP elif direction == 'down': self.y -= STEP elif direction == 'left': self.x -= STEP elif direction == 'right': self.x += STEP 是这样的：

def move(self, direction):
            self.x += direction.dx * STEP
            self.y += direction.dy * STEP
            

比你真的喜欢写为：

# Written in full to give the idea.
            # Consider using collections.namedtuple
            class Direction(object):
            def __init__(self, dx, dy, name):
            self.dx = dx
            self.dy = dy
            self.name = name
            def __str__(self):
            return name
            UP = Direction(0, 1, "up")
            ...
            RIGHT = Direction(1, 0, "right")
            

，就是这样！

所以，你想要的东西，变成这个实例 ：

class Direction(object):
            pass
            class Up(Direction):
            dx = 0
            dy = 1
            ...
            class Right(Direction):
            dx = 1
            dy = 0
            

或只是类 ：

direction == Up

请记住，在Python中，类也是对象（从任何其他对象不同），你可以对它们进行比较： 等等

一般来说，情况可能更清洁，但如果你列举的概念有一定的层次关系，他们直接与班有时建模是非常好的。

这是简单而有效的：

class Enum(object):
            def __init__(self, *keys):
            self.__dict__.update(zip(keys, range(len(keys))))
            

用法：

>>> x = Enum('foo', 'bar', 'baz', 'bat')
            >>> x.baz
            2
            >>> x.bat
            3