How do I test if int value exists in Python Enum without using try/catch?


Python Problem Overview

Using the Python Enum class, is there a way to test if an Enum contains a specific int value without using try/catch?

With the following class:

from enum import Enum

class Fruit(Enum):
    Apple = 4
    Orange = 5
    Pear = 6

How can I test for the value 6 (returning true), or the value 7 (returning false)?

Python Solutions

Solution 1 - Python

test for values

variant 1

note that an Enum has a member called _value2member_map_ (which is undocumented and may be changed/removed in future python versions):

# {4: <Fruit.Apple: 4>, 5: <Fruit.Orange: 5>, 6: <Fruit.Pear: 6>}

you can test if a value is in your Enum against this map:

5 in Fruit._value2member_map_  # True
7 in Fruit._value2member_map_  # False
variant 2

if you do not want to rely on this feature this is an alternative:

values = [item.value for item in Fruit]  # [4, 5, 6]

or (probably better): use a set; the in operator will be more efficient:

values = set(item.value for item in Fruit)  # {4, 5, 6}

then test with

5 in values  # True
7 in values  # False
add has_value to your class

you could then add this as a method to your class:

class Fruit(Enum):
    Apple = 4
    Orange = 5
    Pear = 6

    def has_value(cls, value):
        return value in cls._value2member_map_ 

print(Fruit.has_value(5))  # True
print(Fruit.has_value(7))  # False

test for keys

if you want to test for the names (and not the values) i would use _member_names_:

'Apple' in Fruit._member_names_  # True
'Mango' in Fruit._member_names_  # False

Solution 2 - Python

There is a way to have all the enums be able to check if an item is present:

import enum 

class MyEnumMeta(enum.EnumMeta): 
    def __contains__(cls, item): 
        return item in [v.value for v in cls.__members__.values()] 

class MyEnum(enum.Enum, metaclass=MyEnumMeta): 
   FOO = "foo" 
   BAR = "bar"

Now you can do an easy check:

>>> "foo" in MyEnum

It can even be made simpler if all the enum's values will always be the same type -- for example strings:

import enum 
class MyEnumMeta(enum.EnumMeta):  
    def __contains__(cls, item): 
        return item in cls.__members__.values()

class MyEnum(str, enum.Enum, metaclass=MyEnumMeta): 
    FOO = "foo" 
    BAR = "bar"

Edit: Yet another version, technically the most correct one:

import enum 

class MyEnumMeta(enum.EnumMeta): 
    def __contains__(cls, item): 
        except ValueError:
            return False
            return True

class MyEnum(enum.Enum, metaclass=MyEnumMeta): 
   FOO = "foo" 
   BAR = "bar"

Solution 3 - Python

You could use Enum.__members__ - an ordered dictionary mapping names to members:

In [12]: 'Apple' in Fruit.__members__
Out[12]: True

In [13]: 'Grape' in Fruit.__members__
Out[13]: False

Solution 4 - Python

Building on what Reda Maachi started:

6 in Fruit.__members__.values() 

returns True

7 in Fruit.__members__.values()  

returns False

Solution 5 - Python

If the enum has many members, this approach can be faster because it doesn't make a new list and stops walking the enum when the given value is found:

any(x.value == 5 for x in Fruit)  # True
any(x.value == 7 for x in Fruit)  # False

Solution 6 - Python

I just convert an IntEnum to a list and test it normally:

from enum import IntEnum
class Foo(IntEnum):
    ONE = 1
    TWO = 2
    THREE = 3

print(1 in list(Foo))
print(4 in list(Foo))

Solution 7 - Python

Just check whether it's in Enum. _value2member_map_

In[15]: Fruit._value2member_map_
Out[15]: {4: <Fruit.Apple: 4>, 5: <Fruit.Orange: 5>, 6: <Fruit.Pear: 6>}

In[16]: 6 in Fruit._value2member_map_
Out[16]: True

In[17]: 7 in Fruit._value2member_map_
Out[17]: False

Solution 8 - Python


If you are using Enum, you can test for enum with

     if isinstance(key, Fruit):

But otherwise, try.. is the pythonic way to test for enum. Indeed, for any break in the duck-typing paradigm.

The correct, and pythonic, way of testing for an int in an IntEnum is to give it a go and to catch a ValueError if there's a failure.

Many of the solutions proposed above are actively deprecated and will be disallowed by 3.8 ( "DeprecationWarning: using non-Enums in containment checks will raise TypeError in Python 3.8" )

If you are really disinterested in keeping your code modern, then you can just use

if key in Fruit:

Solution 9 - Python

An EAFP version of the answer:

    return True
except ValueError:
    return False

Solution 10 - Python

You could use __members__ special attribute to iterate over members:

from enum import Enum

class Fruit(Enum):
    Apple = 4
    Orange = 5
    Pear = 6

    def has_value(item):
        return item in [v.value for v in Fruit.__members__.values()]

Solution 11 - Python

There's another one liner solution nobody has mentioned yet:

is_value_in_fruit = any(f.value == value_to_check for f in Fruit)

Also, if you use IntEnum instead of Enum, (class Fruit(IntEnum)) you can just do this

is_value_in_fruit = any(f == value_to_check for f in Fruit) 

Solution 12 - Python

how about this?

from enum import Enum

class Fruit(Enum):
    Apple = 4
    Orange = 5
    Pear = 6

has_apples = 4 in [n.value for n in Fruit]

This would let you also do:

has_apples = "Apple" in [ for n in Fruit]

Solution 13 - Python

IntEnum + __members__

You could use IntEnum and __members__ to achieve required behaviour:

from enum import IntEnum

class Fruit(IntEnum):
    Apple = 4
    Orange = 5
    Pear = 6

>>> 6 in Fruit.__members__.values()
>>> 7 in Fruit.__members__.values()

Enum + list comprehension + .value

If you must/want stick to Enum, you can do:

>>> 6 in [f.value for f in Fruit]
>>> 7 in [f.value for f in Fruit]

EAPF + ValueError

Or you can use easier to ask for forgiveness than permission method:

except ValueError:
    return False
    return True

Solution 14 - Python

class MyEnumMixin:

    raw_values = None  # for IDE autocomplete

    def __new__(cls, value):
        if 'raw_values' not in cls.__dict__:
            cls.raw_values = set()
        if cls.__bases__[0] is MyEnumMixin:
            member = object().__new__(cls)
            member = super().__new__(cls, value)
        member._value_ = value
        return member

class MyEnum(MyEnumMixin, Enum):
    FOO = 1
    BAR = 'bar'

print(1 in MyEnum.raw_values)
print('bar' in MyEnum.raw_values)

class MyStrEnumMixin(MyEnumMixin, str):

class MyStrEnum(MyStrEnumMixin, Enum):
    FOO = 'foo'
    BAR = 'bar'

print('foo' in MyStrEnum.raw_values)
print('bar' in MyStrEnum.raw_values)


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionNathan KovnerView Question on Stackoverflow
Solution 1 - Pythonhiro protagonistView Answer on Stackoverflow
Solution 2 - PythonBerislav LopacView Answer on Stackoverflow
Solution 3 - PythonReda MaachiView Answer on Stackoverflow
Solution 4 - Pythonmanu3dView Answer on Stackoverflow
Solution 5 - PythonFinesseView Answer on Stackoverflow
Solution 6 - PythonRay SalemiView Answer on Stackoverflow
Solution 7 - PythonJianWeiView Answer on Stackoverflow
Solution 8 - PythonKonchogView Answer on Stackoverflow
Solution 9 - PythonComeOnGetMeView Answer on Stackoverflow
Solution 10 - PythonAlex JoligView Answer on Stackoverflow
Solution 11 - PythonJoshua RyanView Answer on Stackoverflow
Solution 12 - PythonJubairView Answer on Stackoverflow
Solution 13 - PythonmaciekView Answer on Stackoverflow
Solution 14 - PythonVal KView Answer on Stackoverflow