如何定义作为函数的枚举值？

问题描述

我遇到一种情况，我需要强制执行并为用户提供多种选择功能之一的选项，并将其作为参数传递给另一个功能：

I have a situation where I need to enforce and give the user the option of one of a number of select functions, to be passed in as an argument to another function:

我真的想实现以下目标：

I really want to achieve something like the following:

from enum import Enum

#Trivial Function 1
def functionA():
    pass

#Trivial Function 2
def functionB():
    pass

#This is not allowed (as far as i can tell the values should be integers)
#But pseudocode for what I am after
class AvailableFunctions(Enum):
    OptionA = functionA
    OptionB = functionB

因此可以执行以下操作：

So the following can be executed:

def myUserFunction(theFunction = AvailableFunctions.OptionA):
   #Type Check
   assert isinstance(theFunction,AvailableFunctions)

   #Execute the actual function held as value in the enum or equivalent
   return theFunction.value()

推荐答案

您的假设是错误。值可以是任意的，不限于整数。来自：

Your assumption is wrong. Values can be arbitrary, they are not limited to integers. From the documentation:

但是，函数的问题在于它们被认为是方法定义而不是属性！

However the issue with functions is that they are considered to be method definitions instead of attributes!

In [1]: from enum import Enum

In [2]: def f(self, *args):
   ...:     pass
   ...:

In [3]: class MyEnum(Enum):
   ...:     a = f
   ...:     def b(self, *args):
   ...:         print(self, args)
   ...:

In [4]: list(MyEnum)  # it has no values
Out[4]: []

In [5]: MyEnum.a
Out[5]: <function __main__.f>

In [6]: MyEnum.b
Out[6]: <function __main__.MyEnum.b>

您可以通过使用包装类或仅使用 functools.partial解决此问题。 或（仅在Python2中） staticmethod ：

You can work around this by using a wrapper class or just functools.partial or (only in Python2) staticmethod:

from functools import partial

class MyEnum(Enum):
    OptionA = partial(functionA)
    OptionB = staticmethod(functionB)

示例运行：

In [7]: from functools import partial

In [8]: class MyEnum2(Enum):
   ...:     a = partial(f)
   ...:     def b(self, *args):
   ...:         print(self, args)
   ...:

In [9]: list(MyEnum2)
Out[9]: [<MyEnum2.a: functools.partial(<function f at 0x7f4130f9aae8>)>]

In [10]: MyEnum2.a
Out[10]: <MyEnum2.a: functools.partial(<function f at 0x7f4130f9aae8>)>

或使用包装类：

In [13]: class Wrapper:
    ...:     def __init__(self, f):
    ...:         self.f = f
    ...:     def __call__(self, *args, **kwargs):
    ...:         return self.f(*args, **kwargs)
    ...:

In [14]: class MyEnum3(Enum):
    ...:     a = Wrapper(f)
    ...:

In [15]: list(MyEnum3)
Out[15]: [<MyEnum3.a: <__main__.Wrapper object at 0x7f413075b358>>]

---

还请注意，如果需要，可以在枚举类中定义 __ call __ 方法使值可调用：

In [1]: from enum import Enum

In [2]: def f(*args):
   ...:     print(args)
   ...:

In [3]: class MyEnum(Enum):
   ...:     a = partial(f)
   ...:     def __call__(self, *args):
   ...:         self.value(*args)
   ...:

In [5]: MyEnum.a(1,2,3)   # no need for MyEnum.a.value(1,2,3)
(1, 2, 3)

这篇关于如何定义作为函数的枚举值？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！