How can I represent an Enum in Python

Question

I m mainly a C  developer  but I m currently working on a project in Python   How can I represent the equivalent of an Enum in Python

User · Answer

Hmmm    I suppose the closest thing to an enum would be a dictionary  defined either like this   months          January   1       February   2              or  months   dict      January 1      February 2              Then  you can use the symbolic name for the constants like this   mymonth   months  January     There are other options  like a list of tuples  or a tuple of tuples  but the dictionary is the only one that provides you with a  symbolic   constant string  way to access the  value   Edit  I like Alexandru s answer too

User · Answer

While the original enum proposal  PEP 354  was rejected years ago  it keeps coming back up  Some kind of enum was intended to be added to 3 2  but it got pushed back to 3 3 and then forgotten  And now there s a PEP 435 intended for inclusion in Python 3 4  The reference implementation of PEP 435 is flufl enum   As of April 2013  there seems to be a general consensus that something should be added to the standard library in 3 4   as long as people can agree on what that  something  should be  That s the hard part  See the threads starting here and here  and a half dozen other threads in the early months of 2013   Meanwhile  every time this comes up  a slew of new designs and implementations appear on PyPI  ActiveState  etc   so if you don t like the FLUFL design  try a PyPI search

User · Answer

def enum   names                 Makes enum      Usage          E   enum   YOUR    KEYS    HERE            print  E HERE                class Enum            pass     for index  name in enumerate  names            setattr  Enum  name  index       return Enum

User · Answer

If you need the numeric values  here s the quickest way   dog  cat  rabbit   range 3    In Python 3 x you can also add a starred placeholder at the end  which will soak up all the remaining values of the range in case you don t mind wasting memory and cannot count   dog  cat  rabbit  horse       range 100

User · Answer

This solution is a simple way of getting a class for the enumeration defined as a list  no more annoying integer assignments    enumeration py   import new  def create class name  names       return new classobj          class name   object    dict  y  x  for x  y in enumerate names           example py   import enumeration  Colors   enumeration create  Colors          red        orange        yellow        green        blue        violet

User · Answer

def M add class attribs attribs       def foo name  bases  dict            for v  k in attribs              dict  k    v         return type name  bases  dict       return foo  def enum  names       class Foo object             metaclass     M add class attribs enumerate names           def   setattr   self  name  value      this makes it read-only             raise NotImplementedError     return Foo     Use it like this     Animal   enum  DOG    CAT   Animal DOG   returns 0 Animal CAT   returns 1 Animal DOG   2   raises NotImplementedError   if you just want unique symbols and don t care about the values  replace this line       metaclass     M add class attribs enumerate names     with this     metaclass     M add class attribs  object    name  for name in names

User · Answer

This is the best one I have seen   First Class Enums in Python   http   code activestate com recipes 413486   It gives you a class  and the class contains all the enums  The enums can be compared to each other  but don t have any particular value  you can t use them as an integer value   I resisted this at first because I am used to C enums  which are integer values  But if you can t use it as an integer  you can t use it as an integer by mistake so overall I think it is a win   Each enum is a unique value  You can print enums  you can iterate over them  you can test that an enum value is  in  the enum  It s pretty complete and slick   Edit  cfi   The above link is not Python 3 compatible  Here s my port of enum py to Python 3   def cmp a b      if a  lt  b  return -1    if b  lt  a  return 1    return 0   def Enum  names        assert names   Empty enums are not supported     lt - Don t like empty enums  Uncomment      class EnumClass object           slots     names       def   iter   self          return iter constants        def   len   self           return len constants        def   getitem   self  i    return constants i        def   repr   self          return  Enum    str names        def   str   self           return  enum     str constants      class EnumValue object           slots         value         def   init   self  value   self   value   value       Value   property lambda self  self   value        EnumType   property lambda self  EnumType        def   hash   self          return hash self   value        def   cmp   self  other              C fans might want to remove the following assertion            to make all enums comparable by ordinal value               assert self EnumType is other EnumType   Only values from the same enum are comparable           return cmp self   value  other   value        def   lt   self  other     return self   cmp   other   lt  0       def   eq   self  other     return self   cmp   other     0       def   invert   self        return constants maximum - self   value        def   nonzero   self       return bool self   value        def   repr   self          return str names self   value       maximum   len names  - 1    constants    None    len names     for i  each in enumerate names         val   EnumValue i        setattr EnumClass  each  val        constants i    val    constants   tuple constants     EnumType   EnumClass      return EnumType   if   name         main        print    n    Enum Demo          print   --- Days of week ---      Days   Enum  Mo    Tu    We    Th    Fr    Sa    Su      print  Days     print  Days Mo     print  Days Fr     print  Days Mo  lt  Days Fr     print  list Days      for each in Days        print   Day    each     print   --- Yes No ---      Confirmation   Enum  No    Yes      answer   Confirmation No    print   Your answer is not    answer

User · Answer

davidg recommends using dicts   I d go one step further and use sets   months   set  January    February         December     Now you can test whether a value matches one of the values in the set like this   if m in months    like dF  though  I usually just use string constants in place of enums

User · Answer

Here is a variant on Alec Thomas s solution   def enum  args    kwargs       return type  Enum       dict  y  x  for x  y in enumerate args     kwargs     x   enum  POOH    TIGGER    EEYORE    ROO    PIGLET    RABBIT    OWL   assert x POOH    0 assert x TIGGER    1

User · Answer

The best solution for you would depend on what you require from your fake enum   Simple enum   If you need the enum as only a list of names identifying different items  the solution by Mark Harrison  above  is great   Pen  Pencil  Eraser   range 0  3    Using a range also allows you to set any starting value   Pen  Pencil  Eraser   range 9  12    In addition to the above  if you also require that the items belong to a container of some sort  then embed them in a class   class Stationery      Pen  Pencil  Eraser   range 0  3    To use the enum item  you would now need to use the container name and the item name   stype   Stationery Pen   Complex enum   For long lists of enum or more complicated uses of enum  these solutions will not suffice  You could look to the recipe by Will Ware for Simulating Enumerations in Python published in the Python Cookbook  An online version of that is available here   More info   PEP 354  Enumerations in Python has the interesting details of a proposal for enum in Python and why it was rejected

User · Answer

On 2013-05-10  Guido agreed to accept PEP 435 into the Python 3 4 standard library  This means that Python finally has builtin support for enumerations   There is a backport available for Python 3 3  3 2  3 1  2 7  2 6  2 5  and 2 4   It s on Pypi as enum34   Declaration    gt  gt  gt  from enum import Enum  gt  gt  gt  class Color Enum           red   1         green   2         blue   3   Representation    gt  gt  gt  print Color red  Color red  gt  gt  gt  print repr Color red    lt Color red  1 gt    Iteration    gt  gt  gt  for color in Color        print color      Color red Color green Color blue   Programmatic access    gt  gt  gt  Color 1  Color red  gt  gt  gt  Color  blue   Color blue   For more information  refer to the proposal  Official documentation will probably follow soon

User · Answer

I prefer to define enums in Python like so   class Animal    class Dog  pass   class Cat  pass  x   Animal Dog   It s more bug-proof than using integers since you don t have to worry about ensuring that the integers are unique  e g  if you said Dog   1 and Cat   1 you d be screwed    It s more bug-proof than using strings since you don t have to worry about typos  e g  x     catt  fails silently  but x    Animal Catt is a runtime exception

User · Answer

Keep it simple   class Enum object        def   init   self  tupleList               self tupleList   tupleList      def   getattr   self  name               return self tupleList index name    Then   DIRECTION   Enum   UP    DOWN    LEFT    RIGHT    DIRECTION DOWN 1

User · Answer

From Python 3 4 there will be official support for enums  You can find documentation and examples here on Python 3 4 documentation page      Enumerations are created using the class syntax  which makes them easy   to read and write  An alternative creation method is described in   Functional API  To define an enumeration  subclass Enum as follows    from enum import Enum class Color Enum        red   1      green   2      blue   3

User · Answer

The new standard in Python is PEP 435  so an Enum class will be available in future versions of Python    gt  gt  gt  from enum import Enum   However to begin using it now you can install the original library that motivated the PEP     pip install flufl enum   Then you can use it as per its online guide    gt  gt  gt  from flufl enum import Enum  gt  gt  gt  class Colors Enum           red   1         green   2         blue   3  gt  gt  gt  for color in Colors  print color Colors red Colors green Colors blue

User · Answer

Use the following   TYPE     EAN13     u EAN-13            CODE39    u Code 39            CODE128   u Code 128            i25       u Interleaved 2 of 5      gt  gt  gt  TYPE items      EAN13   u EAN-13      i25   u Interleaved 2 of 5      CODE39   u Code 39      CODE128   u Code 128     gt  gt  gt  TYPE keys     EAN13    i25    CODE39    CODE128    gt  gt  gt  TYPE values    u EAN-13   u Interleaved 2 of 5   u Code 39   u Code 128     I used that for Django model choices  and it looks very pythonic  It is not really an Enum  but it does the job

User · Answer

I like to use lists or sets as enumerations  For example    gt  gt  gt  packet types     INIT    FINI    RECV    SEND    gt  gt  gt  packet types index  INIT   0  gt  gt  gt  packet types index  FINI   1  gt  gt  gt

User · Answer

Didn t see this one in the list of answers  here is the one I whipped up  It allows the use of  in  keyword and len   method   class EnumTypeError TypeError       pass  class Enum object               Minics enum type from different languages     Usage      Letters   Enum list  abc        a   Letters a     print a in Letters    True     print 54 in Letters    False             def   init   self  enums           if isinstance enums  dict               self   dict   update enums          elif isinstance enums  list  or isinstance enums  tuple               self   dict   update   dict  v k  for k v in enumerate enums            else              raise EnumTypeError      def   contains   self  key           return key in self   dict   values        def   len   self           return len self   dict   values      if   name         main         print  Using a dictionary to create Enum        Letters   Enum dict  v k  for k v in enumerate list  abcde          a   Letters a     print   tIs a in e    a in Letters      print   tIs 54 in e    54 in Letters      print   tLength of Letters enum    len Letters        print   nUsing a list to create Enum        Letters   Enum list  abcde        a   Letters a     print   tIs a in e    a in Letters      print   tIs 54 in e    54 in Letters      print   tLength of Letters enum    len Letters        try            make sure we raise an exception if we pass an invalid arg         Failure   Enum  This is a Failure           print  Failure       except EnumTypeError          print  Success      Output   Using a dictionary to create Enum          Is a in e  True         Is 54 in e  False         Length of Letters enum  5  Using a list to create Enum          Is a in e  True         Is 54 in e  False         Length of Letters enum  5 Success

User · Answer

What I use   class Enum object       def   init   self  names  separator None           self names   names split separator          for value  name in enumerate self names               setattr self  name upper    value      def tuples self           return tuple enumerate self names     How to use    gt  gt  gt  state   Enum  draft published retracted    gt  gt  gt  state DRAFT 0  gt  gt  gt  state RETRACTED 2  gt  gt  gt  state FOO Traceback  most recent call last      File   lt stdin gt    line 1  in  lt module gt  AttributeError   Enum  object has no attribute  FOO   gt  gt  gt  state tuples     0   draft     1   published     2   retracted      So this gives you integer constants like state PUBLISHED and the two-tuples to use as choices in Django models

User · Answer

Python 2 7 and find name    Here is an easy-to-read implementation of the chosen idea with some helper methods  which perhaps are more Pythonic and cleaner to use than  reverse mapping   Requires Python    2 7    To address some comments below  Enums are quite useful to prevent spelling mistakes in code  e g  for state machines  error classifiers  etc   def Enum  sequential    named        Generate a new enum type  Usage example     ErrorClass   Enum  STOP   GO     print ErrorClass find name ErrorClass STOP         STOP    print ErrorClass find val  STOP         0   ErrorClass FOO       Raises AttributeError         enums     v k for k v in enumerate sequential    if not named else named     classmethod   def find name cls  val       result     k for k v in cls   dict   iteritems   if v    val       if not len result           raise ValueError  Value  s not found in Enum    val      return result 0      classmethod   def find val cls  n       return getattr cls  n     enums  find val     find val   enums  find name     find name   return type  Enum       enums

User · Answer

def enum  sequential    named       enums   dict zip sequential   object   for   in range len sequential        named      return type  Enum       enums    If you name it  is your problem  but if not creating objects instead of values allows you to do this    gt  gt  gt  DOG   enum  BARK    WALK    SIT    gt  gt  gt  CAT   enum  MEOW    WALK    SIT    gt  gt  gt  DOG WALK    CAT WALK False   When using other implementations sited here  also when using named instances in my example  you must be sure you never try to compare objects from different enums  For here s a possible pitfall    gt  gt  gt  DOG   enum  BARK  1   WALK  2   SIT  3   gt  gt  gt  CAT   enum  WALK  1   SIT  2   gt  gt  gt  pet1 state   DOG BARK  gt  gt  gt  pet2 state   CAT WALK  gt  gt  gt  pet1 state    pet2 state True   Yikes

User · Answer

An Enum class can be a one-liner   class Enum tuple     getattr     tuple index   How to use it  forward and reverse lookup  keys  values  items  etc     gt  gt  gt  State   Enum   Unclaimed    Claimed     gt  gt  gt  State Claimed 1  gt  gt  gt  State 1   Claimed   gt  gt  gt  State   Unclaimed    Claimed    gt  gt  gt  range len State    0  1   gt  gt  gt    k  State k   for k in range len State      0   Unclaimed     1   Claimed     gt  gt  gt    k  getattr State  k   for k in State     Unclaimed   0     Claimed   1

User · Answer

Before PEP 435  Python didn t have an equivalent but you could implement your own   Myself  I like keeping it simple  I ve seen some horribly complex examples on the net   something like this      class Animal      DOG   1     CAT   2  x   Animal DOG     In Python 3 4  PEP 435   you can make Enum the base class   This gets you a little bit of extra functionality  described in the PEP   For example  enum members are distinct from integers  and they are composed of a name and a value    class Animal Enum       DOG   1     CAT   2  print Animal DOG     lt Animal DOG  1 gt   print Animal DOG value    1  print Animal DOG name     DOG      If you don t want to type the values  use the following shortcut   class Animal Enum       DOG  CAT   range 2      Enum implementations can be converted to lists and are iterable  The order of its members is the declaration order and has nothing to do with their values  For example    class Animal Enum       DOG   1     CAT   2     COW   0  list Animal      lt Animal DOG  1 gt    lt Animal CAT  2 gt    lt Animal COW  0 gt     animal value for animal in Animal     1  2  0   Animal CAT in Animal   True

User · Answer

So  I agree  Let s not enforce type safety in Python  but I would like to protect myself from silly mistakes  So what do we think about this   class Animal object       values     Horse   Dog   Cat        class   metaclass   type           def   getattr   self  name               return self values index name    It keeps me from value-collision in defining my enums    gt  gt  gt  Animal Cat 2   There s another handy advantage  really fast reverse lookups   def name of self  i       return self values i

User · Answer

It s funny  I just had a need for this the other day and I couldnt find an implementation worth using    so I wrote my own   import functools  class EnumValue object       def   init   self name value type           self   value value         self   name name         self Type type     def   str   self           return self   name     def   repr   self   2 6 only    so change to what ever you need            return   cls   0 r   1 r   2    format self   name self   value self Type   name   cls type self    name         def   hash   self           return hash self   value      def   nonzero   self           return bool self   value      def   cmp   self other           if isinstance other EnumValue               return cmp self   value other   value          else              return cmp self   value other  hopefully their the same type    but who cares      def   or   self other           if other is None              return self         elif type self  is not type other               raise TypeError           return EnumValue   0 Name     1 Name   format self other  self Value other Value self Type      def   and   self other           if other is None              return self         elif type self  is not type other               raise TypeError           return EnumValue   0 Name   amp   1 Name   format self other  self Value amp other Value self Type      def   contains   self other           if self Value  other Value              return True         return bool self amp other      def   invert   self           enumerables self Type   enumerables           return functools reduce EnumValue   or    enum for enum in enumerables itervalues   if enum not in self         property     def Name self           return self   name       property     def Value self           return self   value  class EnumMeta type        staticmethod     def   addToReverseLookup rev value newKeys nextIter force True           if value in rev              forced items rev get value  force                   if forced and force   value was forced  so just append                 rev value   True items newKeys              elif not forced  move it to a new spot                 next nextIter next                   EnumMeta   addToReverseLookup rev next items nextIter False                  rev value   force newKeys              else   not forcing this value                 next   nextIter next                   EnumMeta   addToReverseLookup rev next newKeys nextIter False                  rev value   force newKeys          else  set it and forget it             rev value   force newKeys          return value      def   init   cls name bases atts           classVars vars cls          enums   classVars get    enumerables    None          nextIter   getattr cls    nextitr    itertools count            reverseLookup            values             if enums is not None               build reverse lookup             for item in enums                  if isinstance item  tuple list                        items list item                      value items pop                       EnumMeta   addToReverseLookup reverseLookup value tuple map str items   nextIter                  else                      value nextIter next                       value EnumMeta   addToReverseLookup reverseLookup value  str item    nextIter False  add it to the reverse lookup  but don t force it to that value               build values and clean up reverse lookup             for value fkeys in reverseLookup iteritems                    f keys fkeys                 for key in keys                      enum EnumValue key value cls                      setattr cls key enum                      values key  enum                 reverseLookup value  tuple val for val in values itervalues   if val Value    value          setattr cls    reverseLookup    reverseLookup          setattr cls    enumerables    values          setattr cls   Max  max  key for key in reverseLookup  or  0            return super EnumMeta cls    init   name bases atts       def   iter   cls           for enum in cls   enumerables   itervalues                yield enum     def GetEnumByName cls name           return cls   enumerables   get name None      def GetEnumByValue cls value           return cls   reverseLookup   get value  None    0   class Enum object         metaclass   EnumMeta       enumerables   None  class FlagEnum Enum        staticmethod     def   nextitr              yield 0         for val in itertools count                yield 2  val  def enum name  args       return EnumMeta name  Enum   dict   enumerables   args     Take it or leave it  it did what I needed it to do     Use it like   class Air FlagEnum         enumerables     None   Oxygen   Nitrogen   Hydrogen    class Mammals Enum         enumerables     Bat   Whale    Dog   Puppy  1   Cat   Bool   enum  Bool   Yes    No  0

User · Answer

Another  very simple  implementation of an enum in Python  using namedtuple  from collections import namedtuple  def enum  keys       return namedtuple  Enum   keys   keys   MyEnum   enum  FOO    BAR    BAZ    or  alternatively    With sequential number values def enum  keys       return namedtuple  Enum   keys   range len keys       From a dict   keyword args def enum   kwargs       return namedtuple  Enum   kwargs keys     kwargs values          Example for dictionary param  values     quot Salad quot   20   quot Carrot quot   99   quot Tomato quot    quot No i m not quot    Vegetables  enum   values      gt  gt  gt  print Vegetables Tomato          No i m not      Example for keyworded params   Fruits   enum Apple  quot Steve Jobs quot   Peach 1  Banana 2      gt  gt  gt  print Fruits Apple               Steve Jobs   Like the method above that subclasses set  this allows   FOO  in MyEnum other   MyEnum FOO assert other    MyEnum FOO  But has more flexibility as it can have different keys and values  This allows MyEnum FOO  lt  MyEnum BAR  to act as is expected if you use the version that fills in sequential number values

User · Answer

Here s an approach with some different characteristics I find valuable    allows   and  lt  comparison based on order in enum  not lexical order can address item by name  property or index  x a  x  a   or x 0  supports slicing operations like     or  -1    and most importantly prevents comparisons between enums of different types   Based closely on http   code activestate com recipes 413486-first-class-enums-in-python   Many doctests included here to illustrate what s different about this approach   def enum  names           SYNOPSIS     Well-behaved enumerated type  easier than creating custom classes  DESCRIPTION     Create a custom type that implements an enumeration   Similar in concept     to a C enum but with some additional capabilities and protections   See     http   code activestate com recipes 413486-first-class-enums-in-python    PARAMETERS     names       Ordered list of names   The order in which names are given                 will be the sort order in the enum type   Duplicate names                 are not allowed   Unicode names are mapped to ASCII   RETURNS     Object of type enum  with the input names and the enumerated values   EXAMPLES      gt  gt  gt  letters   enum  a   e   i   o   u   b   c   y   z        gt  gt  gt  letters a  lt  letters e     True         index by property      gt  gt  gt  letters a     a         index by position      gt  gt  gt  letters 0      a         index by name  helpful for bridging string inputs to enum      gt  gt  gt  letters  a       a         sorting by order in the enum   create  not character value      gt  gt  gt  letters u  lt  letters b     True         normal slicing operations available      gt  gt  gt  letters -1      z         error since there are not 100 items in enum      gt  gt  gt  letters 99      Traceback  most recent call last                   IndexError  tuple index out of range         error since name does not exist in enum      gt  gt  gt  letters  ggg       Traceback  most recent call last                   ValueError  tuple index x   x not in tuple         enums must be named using valid Python identifiers      gt  gt  gt  numbers   enum 1 2 3 4      Traceback  most recent call last                   AssertionError  Enum values must be string or unicode       gt  gt  gt  a   enum  -a   -b       Traceback  most recent call last                   TypeError  Error when calling the metaclass bases           slots   must be identifiers         create another enum      gt  gt  gt  tags   enum  a   b   c        gt  gt  gt  tags a     a      gt  gt  gt  letters a     a         can t compare values from different enums      gt  gt  gt  letters a    tags a     Traceback  most recent call last                   AssertionError  Only values from the same enum are comparable       gt  gt  gt  letters a  lt  tags a     Traceback  most recent call last                   AssertionError  Only values from the same enum are comparable         can t update enum after create      gt  gt  gt  letters a    x      Traceback  most recent call last                   AttributeError   EnumClass  object attribute  a  is read-only         can t update enum after create      gt  gt  gt  del letters u     Traceback  most recent call last                   AttributeError   EnumClass  object attribute  u  is read-only         can t have non-unique enum values      gt  gt  gt  x   enum  a   b   c   a       Traceback  most recent call last                   AssertionError  Enums must not repeat values         can t have zero enum values      gt  gt  gt  x   enum       Traceback  most recent call last                   AssertionError  Empty enums are not supported         can t have enum values that look like special function names        since these could collide and lead to non-obvious errors      gt  gt  gt  x   enum  a   b   c     cmp         Traceback  most recent call last                   AssertionError  Enum values beginning with    are not supported  LIMITATIONS     Enum values of unicode type are not preserved  mapped to ASCII instead                  must have at least one enum value     assert names   Empty enums are not supported         enum values must be strings     assert len  i for i in names if not isinstance i  types StringTypes  and not           isinstance i  unicode       0   Enum values must be string or unicode         enum values must not collide with special function names     assert len  i for i in names if i startswith            0            Enum values beginning with    are not supported         each enum value must be unique from all others     assert names    uniquify names    Enums must not repeat values       class EnumClass object               See parent function for explanation                slots     names          def   iter   self               return iter constants           def   len   self               return len constants           def   getitem   self  i                  this makes xx  name   possible             if isinstance i  types StringTypes                   i   names index i                 handles the more normal xx 0              return constants i           def   repr   self               return  enum    str names           def   str   self               return  enum     str constants           def index self  i               return names index i       class EnumValue object               See parent function for explanation                slots         value            def   init   self  value               self   value   value          value   property lambda self  self   value           enumtype   property lambda self  enumtype           def   hash   self               return hash self   value           def   cmp   self  other               assert self enumtype is other enumtype   Only values from the same enum are comparable              return cmp self value  other value           def   invert   self               return constants maximum - self value           def   nonzero   self                  return bool self value                 Original code led to bool x 0    False  not correct             return True          def   repr   self               return str names self value        maximum   len names  - 1     constants    None    len names      for i  each in enumerate names           val   EnumValue i          setattr EnumClass  each  val          constants i    val     constants   tuple constants      enumtype   EnumClass       return enumtype

User · Answer

A variant  with support to get an enum value s name  to Alec Thomas s neat answer   class EnumBase type       def   init   self  name  base  fields           super EnumBase  self    init   name  base  fields          self   mapping   dict  v  k  for k  v in fields iteritems        def   getitem   self  val           return self   mapping val   def enum  seq    named       enums   dict zip seq  range len seq       named      return EnumBase  Enum       enums   Numbers   enum ONE 1  TWO 2  THREE  three   print Numbers TWO print Numbers Numbers ONE  print Numbers 2  print Numbers  three

User · Answer

I like the Java enum  that s how I do it in Python   def enum clsdef       class Enum object             slots   tuple  var for var in clsdef   dict   if isinstance  getattr clsdef  var    tuple  and not var startswith                  def   new   cls   args    kwargs               if not   the instance  in cls   dict                    cls  the instance   object   new   cls   args    kwargs              return cls  the instance          def   init   self               clsdef values lambda cls  e Enum  e values               clsdef valueOf lambda cls  n  e self  e valueOf n              for ordinal  key in enumerate self   class     slots                     args getattr clsdef  key                  instance clsdef  args                  instance  name key                 instance  ordinal ordinal                 setattr self  key  instance            classmethod         def values cls               if not hasattr cls    values                    cls  values  getattr cls  name  for name in cls   slots                return cls  values          def valueOf self  name               return getattr self  name           def   repr   self               return    join    lt class Enum     clsdef   name       at    str hex id self       gt          return Enum     Sample use   i 2  enum class Test object       A   a  1      B   b        C   c  2      D tuple       E   e  3       while True          try              F  G  H  I  J  K  L  M  N  O  tuple   for   in range i               break          except ValueError              i  1      def   init   self  name  default   aparam 0           self name name         self avalue aparam   All class variables are defined as a tuple  just like the constructor  So far  you can t use named arguments

User · Answer

The enum package from PyPI provides a robust implementation of enums  An earlier answer mentioned PEP 354  this was rejected but the proposal was implemented  http   pypi python org pypi enum   Usage is easy and elegant    gt  gt  gt  from enum import Enum  gt  gt  gt  Colors   Enum  red    blue    green    gt  gt  gt  shirt color   Colors green  gt  gt  gt  shirt color   Colors 2   gt  gt  gt  shirt color  gt  Colors red True  gt  gt  gt  shirt color index 2  gt  gt  gt  str shirt color   green

User · Answer

Python doesn t have a built-in equivalent to enum  and other answers have ideas for implementing your own  you may also be interested in the over the top version in the Python cookbook    However  in situations where an enum would be called for in C  I usually end up just using simple strings  because of the way objects attributes are implemented   C Python is optimized to work very fast with short strings anyway  so there wouldn t really be any performance benefit to using integers  To guard against typos   invalid values you can insert checks in selected places   ANIMALS     cat    dog    python    def take for a walk animal       assert animal in ANIMALS            One disadvantage compared to using a class is that you lose the benefit of autocomplete

User · Answer

The solution that I usually use is this simple function to get an instance of a dynamically created class   def enum names        Create a simple enumeration having similarities to C       return type  enum       dict map reversed  enumerate          names replace           split        slots            Using it is as simple as calling the function with a string having the names that you want to reference   grade   enum  A B C D F   state   enum  awake  sleeping  dead     The values are just integers  so you can take advantage of that if desired  just like in the C language     gt  gt  gt  grade A 0  gt  gt  gt  grade B 1  gt  gt  gt  grade F    4 True  gt  gt  gt  state dead    2 True

User · Answer

Alexandru s suggestion of using class constants for enums works quite well    I also like to add a dictionary for each set of constants to lookup a human-readable string representation    This serves two purposes  a  it provides a simple way to pretty-print your enum and b  the dictionary logically groups the constants so that you can test for membership   class Animal        TYPE DOG   1   TYPE CAT   2    type2str         TYPE DOG   dog       TYPE CAT   cat         def   init   self  type        assert type  in self type2str keys       self  type   type     def   repr   self       return   lt  s type  s gt               self   class     name    self type2str self  type  upper

User · Answer

I had need of some symbolic constants in pyparsing to represent left and right associativity of binary operators   I used class constants like this     an internal class  not intended to be seen by client code class  Constants object       pass     an enumeration of constants for operator associativity opAssoc    Constants   opAssoc LEFT   object   opAssoc RIGHT   object     Now when client code wants to use these constants  they can import the entire enum using   import opAssoc from pyparsing   The enumerations are unique  they can be tested with  is  instead of       they don t take up a big footprint in my code for a minor concept  and they are easily imported into the client code   They don t support any fancy str   behavior  but so far that is in the YAGNI category

User · Answer

I have had occasion to need of an Enum class  for the purpose of decoding a binary file format  The features I happened to want is concise enum definition  the ability to freely create instances of the enum by either integer value or string  and a useful representation   Here s what I ended up with    gt  gt  gt  class Enum int           def   new   cls  value               if isinstance value  str                   return getattr cls  value              elif isinstance value  int                   return cls   index value          def   str   self   return self   name         def   repr   self   return   s  s     type self    name    self   name          class   metaclass   type               def   new   mcls  name  bases  attrs                   attrs    slots          Enum  name                   cls   type   new   mcls  name  bases  attrs                  cls  Enum  index    index                      for base in reversed bases                       if hasattr base    Enum  index                             index update base  Enum  index                    create all of the instances of the new class                 for attr in attrs keys                        value   attrs attr                      if isinstance value  int                           evalue   int   new   cls  value                          evalue  Enum  name   attr                          index value    evalue                         setattr cls  attr  evalue                  return cls        A whimsical example of using it    gt  gt  gt  class Citrus Enum           Lemon   1         Lime   2       gt  gt  gt  Citrus Lemon Citrus Lemon  gt  gt  gt    gt  gt  gt  Citrus 1  Citrus Lemon  gt  gt  gt  Citrus 5  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 6  in   new   KeyError  5  gt  gt  gt  class Fruit Citrus           Apple   3         Banana   4       gt  gt  gt  Fruit Apple Fruit Apple  gt  gt  gt  Fruit Lemon Citrus Lemon  gt  gt  gt  Fruit 1  Citrus Lemon  gt  gt  gt  Fruit 3  Fruit Apple  gt  gt  gt    d  s  r      Fruit Apple   3   3 Apple Fruit Apple   gt  gt  gt  Fruit 1  is Citrus Lemon True   Key features    str    int   and repr   all produce the most useful output possible  respectively the name of the enumartion  its integer value  and a Python expression that evaluates back to the enumeration  Enumerated values returned by the constructor are limited strictly to the predefined values  no accidental enum values  Enumerated values are singletons  they can be strictly compared with is

User · Answer

The typesafe enum pattern which was used in Java pre-JDK 5 has a number of advantages  Much like in Alexandru s answer  you create a class and class level fields are the enum values  however  the enum values are instances of the class rather than small integers  This has the advantage that your enum values don t inadvertently compare equal to small integers  you can control how they re printed  add arbitrary methods if that s useful and make assertions using isinstance   class Animal     def   init   self  name          self name   name     def   str   self          return self name     def   repr   self          return   lt Animal   s gt     self  Animal DOG   Animal  dog   Animal CAT   Animal  cat     gt  gt  gt  x   Animal DOG  gt  gt  gt  x  lt Animal  dog gt   gt  gt  gt  x    1 False     A recent thread on python-dev pointed out there are a couple of enum libraries in the wild  including    flufl enum lazr enum     and the imaginatively named enum

User · Answer

I really like Alec Thomas  solution  http   stackoverflow com a 1695250    def enum   enums          simple constant  enums         return type  Enum    object    enums    It s elegant and clean looking  but it s just a function that creates a class with the specified attributes   With a little modification to the function  we can get it to act a little more  enumy       NOTE  I created the following examples by trying to reproduce the   behavior of pygtk s new style  enums   like Gtk MessageType WARNING    def enum base t    enums          enums with a base class        T   type  Enum    t            for key val in enums items            setattr T  key  T val        return T   This creates an enum based off a specified type  In addition to giving attribute access like the previous function  it behaves as you would expect an Enum to with respect to types   It also inherits the base class   For example  integer enums    gt  gt  gt  Numbers   enum base int  ONE 1  TWO 2  THREE 3   gt  gt  gt  Numbers ONE 1  gt  gt  gt  x   Numbers TWO  gt  gt  gt  10   x 12  gt  gt  gt  type Numbers   lt type  type  gt   gt  gt  gt  type Numbers ONE   lt class  Enum  gt   gt  gt  gt  isinstance x  Numbers  True   Another interesting thing that can be done with this method is customize specific behavior by overriding built-in methods   def enum repr t    enums          enums with a base class and repr   output        class Enum t           def   repr   self               return   lt enum  0  of type Enum  1   gt   format self  name  t   name         for key val in enums items            i   Enum val          i  name   key         setattr Enum  key  i       return Enum     gt  gt  gt  Numbers   enum repr int  ONE 1  TWO 2  THREE 3   gt  gt  gt  repr Numbers ONE    lt enum ONE of type Enum int  gt    gt  gt  gt  str Numbers ONE   1

User · Answer

Enums have been added to Python 3 4 as described in PEP 435   It has also been backported to 3 3  3 2  3 1  2 7  2 6  2 5  and 2 4 on pypi  For more advanced Enum techniques try the aenum library  2 7  3 3   same author as enum34  Code is not perfectly compatible between py2 and py3  e g  you ll need   order   in python 2    To use enum34  do   pip install enum34 To use aenum  do   pip install aenum  Installing enum  no numbers  will install a completely different and incompatible version   from enum import Enum       for enum34  or the stdlib version   from aenum import Enum    for the aenum version Animal   Enum  Animal    ant bee cat dog    Animal ant    returns  lt Animal ant  1 gt  Animal  ant      returns  lt Animal ant  1 gt   string lookup  Animal ant name    returns  ant   inverse lookup   or equivalently  class Animal Enum       ant   1     bee   2     cat   3     dog   4   In earlier versions  one way of accomplishing enums is  def enum   enums       return type  Enum       enums   which is used like so   gt  gt  gt  Numbers   enum ONE 1  TWO 2  THREE  three    gt  gt  gt  Numbers ONE 1  gt  gt  gt  Numbers TWO 2  gt  gt  gt  Numbers THREE  three   You can also easily support automatic enumeration with something like this  def enum  sequential    named       enums   dict zip sequential  range len sequential       named      return type  Enum       enums   and used like so   gt  gt  gt  Numbers   enum  ZERO    ONE    TWO    gt  gt  gt  Numbers ZERO 0  gt  gt  gt  Numbers ONE 1  Support for converting the values back to names can be added this way  def enum  sequential    named       enums   dict zip sequential  range len sequential       named      reverse   dict  value  key  for key  value in enums iteritems        enums  reverse mapping     reverse     return type  Enum       enums   This overwrites anything with that name  but it is useful for rendering your enums in output   It will throw KeyError if the reverse mapping doesn t exist   With the first example   gt  gt  gt  Numbers reverse mapping  three    THREE    If you are using mypy another way to express  quot enums quot  is with Literal  For example from typing import Literal  python  gt  3 8 from typing extensions import Literal  python 2 7  3 4-3 7   Animal   Literal  ant    bee    cat    dog    def hello animal animal  Animal       print f quot hello  animal  quot    hello animal  rock     error hello animal  bee     passes

User · Answer

Here is a nice Python recipe that I found here  http   code activestate com recipes 577024-yet-another-enum-for-python   def enum typename  field names        Create a new enumeration type       if isinstance field names  str           field names   field names replace           split       d   dict  reversed nv  for nv in enumerate field names      slots             return type typename   object    d      Example Usage   STATE   enum  STATE    GET QUIZ  GET VERSE  TEACH     More details can be found on the recipe page

User · Answer

Here is one implementation   class Enum set       def   getattr   self  name           if name in self              return name         raise AttributeError   Here is its usage   Animals   Enum   DOG    CAT    HORSE     print Animals DOG

User · Answer

Following the Java like enum implementation proposed by Aaron Maenpaa  I came out with the following  The idea was to make it generic and parseable   class Enum                Java like implementation for enums             Usage       class Tool Enum   name    Tool       Tool DRILL   Tool register  drill        Tool HAMMER   Tool register  hammer        Tool WRENCH   Tool register  wrench                 name    Enum       Enum name      reg   dict         Enum registered values       classmethod     def register cls  value                         Registers a new value in this enum                      param value  New enum value                      return  New value wrapper instance                       inst   cls value          cls  reg value    inst         return inst       classmethod     def parse cls  value                         Parses a value  returning the enum instance                      param value  Enum value                      return  Value corresp instance                               return cls  reg get value           def   init   self  value                         Constructor  only for internal use                        self value   value      def   str   self                         str   overload                       return self value      def   repr   self                         repr   overload                       return   lt     self name          self value     gt

User · Answer

I use a metaclass to implement an enumeration  in my thought  it is a const   Here is the code   class ConstMeta type               Metaclass for some class that store constants             def   init   cls  name  bases  dct                       init class instance                     def static attrs                                 rtype   static attrs  static val set               return  Static attributes in dict format and static value set                             import types             attrs                  val set   set                Maybe more             filter names   set     doc        init        metaclass        module        main                  for key  value in dct iteritems                    if type value     types FunctionType and key not in filter names                      if len value     2                          raise NotImplementedError  not support for values that is not 2 elements                         Check value 0  duplication                      if value 0  not in val set                          val set add value 0                       else                          raise KeyError   s  s key   s is duplicated      dict   key  value     value 0                        attrs key    value             return attrs  val set          attrs  val set   static attrs            Set STATIC ATTRS to class instance so that can reuse         setattr cls   STATIC ATTRS   attrs          setattr cls   static val set   val set          super ConstMeta  cls    init   name  bases  dct       def   getattribute   cls  name                       Rewrite the special function so as to get correct attribute value                     static attrs   object   getattribute   cls   STATIC ATTRS           if name in static attrs              return static attrs name  0          return object   getattribute   cls  name       def static values cls                       Put values in static attribute into a list  use the function to validate value           return  Set of values                     return cls static val set      def   getitem   cls  key                       Rewrite to make syntax SomeConstClass key  works  and return desc string of related static value           return  Desc string of related static value                     for k  v in cls STATIC ATTRS iteritems                if v 0     key                  return v 1          raise KeyError  Key   s does not exists in  s       str key   repr cls      class Const object               Base class for constant class        usage       Definition   must inherit from Const class           gt  gt  gt  class SomeConst Const            gt  gt  gt    STATUS NAME 1    1   desc for the status1            gt  gt  gt    STATUS NAME 2    2   desc for the status2        Invoke base upper SomeConst class       1  SomeConst STATUS NAME 1 returns 1     2  SomeConst 1  returns  desc for the status1      3  SomeConst STATIC ATTRS returns   STATUS NAME 1    1   desc for the status1     STATUS NAME 2    2   desc for the status2        4  SomeConst static values   returns set  1  2        Attention      SomeCosnt s value 1  2 can not be duplicated      If WrongConst is like this  it will raise KeyError      class WrongConst Const           STATUS NAME 1    1   desc for the status1           STATUS NAME 2    1   desc for the status2                 metaclass     ConstMeta                                                                     Const Base Class ends                                                                      def main        class STATUS Const           ERROR    -3                OK    0             print STATUS ERROR     print STATUS static values       print STATUS STATIC ATTRS       Usage sample      user input   1      Validate input      print user input in STATUS static values        Template render like      print   lt select gt       for key  value in STATUS STATIC ATTRS items            print   lt option value   s  gt  s lt  option gt      value 0   value 1       print   lt  select gt     if   name         main         main

User · Answer

Why must enumerations be ints  Unfortunately  I can t think of any good looking construct to produce this without changing the Python language  so I ll use strings   class Enumerator object       def   init   self  name           self name   name      def   eq   self  other           if self name    other              return True         return self is other      def   ne   self  other           if self name    other              return False         return self is other      def   repr   self           return  Enumerator  0    format self name       def   str   self           return self name  class Enum object       def   init   self   enumerators           for e in enumerators              setattr self  e  Enumerator e       def   getitem   self  key           return getattr self  key    Then again maybe it s even better now that we can naturally test against strings  for the sake of configuration files or other remote input   Example   class Cow object       State   Enum           standing            walking            eating            mooing            sleeping            dead            dying            state   State standing  In  1   from enum import Enum  In  2   c   Cow    In  3   c2   Cow    In  4   c state  c2 state Out 4    Enumerator standing   Enumerator standing    In  5   c state    c2 state Out 5   True  In  6   c State mooing Out 6   Enumerator mooing   In  7   c State  mooing   Out 7   Enumerator mooing   In  8   c state   Cow State dead  In  9   c state    c2 state Out 9   False  In  10   c state    Cow State dead Out 10   True  In  11   c state     dead  Out 11   True  In  12   c state    Cow State  dead   Out 11   True

[python] How can I represent an 'Enum' in Python?

Examples related to python

Examples related to python-3.x

Examples related to enums