Associez Python Enum à une fonction pour la rendre appelable

Lorsque vous souhaitez sélectionner un algorithme parmi plusieurs options, vous pouvez associer une fonction à chaque valeur du type d'énumération.

En Java, vous pouvez définir une méthode pour chaque valeur d'un type d'énumération, mais en Python, vous ne pouvez pas. Réfléchissons à la façon de l'écrire proprement dans le sens de rendre Enum lui-même Callable.

Si la valeur n'a pas d'importance

La valeur d'Enum en Python peut être définie librement. Par conséquent, la valeur elle-même doit être transformée en fonction.

Cependant, la fonction définie dans la classe qui hérite Enum est considérée comme une méthode et n'est pas incluse dans les valeurs répertoriées.

class Dame(Enum):
    #Vous n'avez pas défini la valeur, vous avez défini la méthode
    A = lambda: print("A")

list(Dame)
#Liste vide

Alors, j'ai emprunté cette idée de stackoverflow et j'ai décidé d'utiliser le taple contenant la fonction comme valeur.

from enum import Enum

class CallableEnum(Enum):
    """
Hériter de cette classe pour créer une énumération appelable
    """
    def __call__(self, *args,**kwargs):
        return self.value[0](*args,**kwargs)

def register(func):
    """
Décorateur pour définir facilement le tuple qui contient la fonction
    """
    return func,

Voici comment l'utiliser.

class Test(CallableEnum):
    @register
    def A():
        print("A")
    
    @register
    def B():
        print("B")

Test.A()
# A

Si vous souhaitez définir la valeur librement

Donnez à la classe T qui hérite Enum un dictionnaire de T à la fonction, et faites-y référence dans __call__.

Cependant, si «« T »au dictionnaire de fonctions» est inclus en tant qu'attribut de «T» dans la définition de classe, ce sera également l'une des valeurs énumérées. Vous devez l'ajouter après que T soit terminé en tant que classe.

Par conséquent, c'est une manière d'écrire pour ajouter une fonction une fois la définition de classe terminée.

from enum import Enum

class Dnum(Enum):
    """
Dispatching Enum. Hériter de ce gars
    """
    @classmethod
    def register(cls, key):
        if not hasattr(cls, "table"):
            cls.table = {}
        def registration(func):
            cls.table[key] = func
        return registration
    
    def __call__(self, *args,**kwargs):
        return self.__class__.table[self](*args,**kwargs)


def register(enum):
    def ret(func):
        enum.__class__.register(enum)(func)
    return ret

Utilisez-le comme ça.

from enum import auto

class Test(Dnum):
    A = "A"
    B = "B"

@register(Test.A)
def _A():
    print("A")

@register(Test.B)
def _B():
    print("B")

Test.A()
# A

Existe-t-il une astuce pour écrire une fonction dans la définition de classe tout en définissant la valeur librement?