Cet article explique comment gérer diverses valeurs d'entrée avec élégance en rempla?ant la méthode de classe _missing_ dans la classe Python enum.Enum. Même si la valeur interne d'un membre d'énumération est fixe, nous pouvons lui faire accepter plusieurs représentations externes (telles que "vrai", "oui", etc.) et le mapper au bon membre d'énumération tout en gardant la valeur interne d'origine inchangée, améliorant ainsi la robustesse et la convivialité de l'énumération.

Dans le développement Python, enum.Enum fournit un moyen puissant de définir une collection de constantes. Cependant, dans les applications pratiques, nous sommes souvent confrontés à un défi : comment permettre aux énumérations d'accepter plusieurs formes d'entrée et de les mapper uniformément à des membres spécifiques de l'énumération tout en gardant inchangées les valeurs internes des membres de l'énumération eux-mêmes. Par exemple, une énumération représentant ? oui/non ? peut avoir ses valeurs internes définies comme ? Y ? et ? N ?, mais lors de la réception d'une entrée externe, elle peut avoir besoin de reconna?tre plusieurs formes telles que ? vrai ?, ? oui ? ou même ? T ? comme signification de ? oui ?.

Cet article utilisera un cas spécifique pour présenter en détail comment utiliser la méthode de classe _missing_ d'enum.Enum pour résoudre ce problème et obtenir un traitement d'entrée flexible.

1. Premiers enjeux et défis

Supposons que nous définissions une énumération YesOrNo pour représenter ? oui ? ou ? non ??:

 importer une énumération

classe OuiOuNon(enum.Enum):
  OUI = "O"
  NON = "N"

Nous espérons que lorsque l'entrée externe est "Y" ou "N", le membre d'énumération correspondant pourra être créé directement. Par exemple, YesOrNo("Y") peut obtenir YesOrNo.YES. Cette partie de la fonctionnalité est prise en charge par enum.Enum par défaut.

Cependant, que se passe-t-il si notre système doit accepter un plus large éventail d'entrées, telles que "vrai" ou "faux", et les mapper à YesOrNo.YES et YesOrNo.NO, tout en exigeant que YesOrNo.YES.value soit toujours "Y" et YesOrNo.NO.value soit toujours "N". Essayer directement YesOrNo("true") générera une ValueError car "true" ne fait pas partie des valeurs de OUI ou de NON.

Une approche intuitive mais indésirable consiste à modifier la définition de l’énumération?:

 # La modification n'est pas recommandée car elle changera la valeur interne de la classe d'énumération YesOrNo(enum.Enum)?:
  OUI = "vrai"
  NON = "faux"

Bien que cette modification fasse fonctionner YesOrNo("true"), YesOrNo.YES.value deviendra "true" au lieu de "Y" comme prévu, ce qui entre en conflit avec notre besoin de conserver la valeur interne inchangée.

2. Solution?: méthode _missing_

enum.Enum fournit une méthode de classe spéciale appelée _missing_, con?ue pour gérer les situations dans lesquelles la valeur transmise au constructeur d'énumération ne peut correspondre directement à aucun membre de l'énumération. En rempla?ant cette méthode, nous pouvons implémenter une logique de recherche personnalisée pour mapper les entrées non standard aux membres d'énumération corrects.

La signature d'une méthode _missing_ est généralement _missing_(cls, value), où cls est la classe d'énumération elle-même et value est la valeur sans correspondance qui a été transmise au constructeur. La méthode doit renvoyer le membre d'énumération correspondant et doit autoriser le comportement par défaut (lancer ValueError) ou lancer explicitement une exception si une correspondance ne peut pas être trouvée.

3. Implémentez la méthode _missing_

Voici l'implémentation complète utilisant la méthode _missing_ pour résoudre le problème ci-dessus?:

 importer une énumération

classe OuiOuNon(enum.Enum):
    OUI = "O"
    NON = "N"

    @méthodeclasse
    def _missing_(cls, valeur)?:
        """
        Cette méthode est appelée lorsque la valeur transmise ne correspond directement à aucun membre de l’énumération.
        Il tente de mapper diverses formes d'entrée sur les membres de l'énumération OUI ou NON.
        """
        # Convertir la valeur d'entrée en minuscules pour une comparaison insensible à la casse normalized_value = str(value).lower()

        si valeur_normalisée dans ('y', 'oui', 'true', 't')?:
            retourner cls.OUI
        elif valeur_normalisée dans ('n', 'non', 'false', 'f')?:
            retourner cls.NO

        # Faire enum lancer ValueError par défaut si aucune forme connue ne correspond
        # Ou vous pouvez personnaliser d'autres exceptions à lever # raise ValueError(f"'{value}' n'est pas une valeur YesOrNo valide.")

Analyse des codes?:

1. @classmethod decorator : _missing_ doit être une méthode de classe car elle opère sur la classe d'énumération elle-même, pas sur une instance.
2. Paramètre cls : représente la classe d'énumération YesOrNo. Les membres de l’énumération sont accessibles via cls.YES et cls.NO.
3. paramètre value?: il s'agit de la valeur transmise au constructeur YesOrNo() mais ne correspond directement à aucun membre, par exemple "true".
4. normalized_value = str(value).lower() : Pour rendre la logique de correspondance plus robuste, nous convertissons la valeur d'entrée en cha?ne et la mettons en minuscule. Cela peut gérer les entrées avec différents cas tels que "Vrai" et "OUI".
5. Jugement conditionnel :
   • Si normalized_value appartient à l'un des ('y', 'yes', 'true', 't'), renvoyez cls.YES.
   • Si normalized_value est l'un des ('n', 'no', 'false', 'f'), renvoyez cls.NO.
6. Gestion des correspondances manquantes?: si la méthode _missing_ ne trouve pas de correspondance en interne et renvoie un membre d'énumération, alors enum.Enum lancera ValueError par défaut. Dans l'exemple, nous ne lan?ant pas explicitement mais nous nous appuyons sur ce comportement par défaut. Si vous avez besoin d'informations d'erreur plus spécifiques, vous pouvez augmenter ValueError(...) manuellement.

4. Utilisation et vérification

Maintenant, nous pouvons tester cette énumération YesOrNo améliorée?:

 # Tester diverses entrées print(f"YesOrNo('Y'): {YesOrNo('Y')}")
print(f"OuiOuNon('y'): {OuiOuNon('y')}")
print(f"OuiOuNon('OUI'): {OuiOuNon('OUI')}")
print(f"OuiOuNon('vrai'): {OuiOuNon('vrai')}")
print(f"OuiOuNon('T'): {OuiOuNon('T')}")
print(f"OuiOuNon('N'): {OuiOuNon('N')}")
print(f"OuiOuNon('false'): {OuiOuNon('faux')}")
print(f"OuiOuNon('non'): {OuiOuNon('non')}")

# Vérifiez que les valeurs internes des membres de l'énumération restent inchangées print(f"YesOrNo.YES.value: {YesOrNo.YES.value}")
print(f"OuiOuNo.NO.value?: {OuiOuNo.NO.value}")

# Essayez une entrée invalide?:
    OuiOuNon("inconnu")
sauf ValueError comme e?:
    print(f"Erreur pour 'inconnu'?: {e}")

Exemple de sortie?:

 OuiOuNon('Y'): OuiOuNon.OUI
OuiOuNon('y'): OuiOuNon.OUI
OuiOuNon('OUI'): OuiOuNon.OUI
OuiOuNon('true'): OuiOuNon.OUI
OuiOuNon('T'): OuiOuNon.OUI
OuiOuNon('N'): OuiOuNon.NON
OuiOuNon('faux'): OuiOuNon.NON
OuiOuNon('non'): OuiOuNon.NON
OuiOuNon.OUI.valeur?:?Oui
OuiOuNon.NO.valeur?:?N
Erreur pour ??inconnu???: ??inconnu?? n'est pas un OuiOuNon valide

Il ressort de la sortie que, que ce soit ? vrai ?, ? oui ? ou ? Y ?, il est mappé avec succès à YesOrNo.YES. Pendant ce temps, YesOrNo.YES.value est toujours "Y", ce qui répond à tous nos besoins.

5. Précautions et bonnes pratiques

• _missing_ n'est appelé que lorsqu'il n'y a pas de correspondance directe : si la valeur transmise peut correspondre directement à la valeur d'un membre de l'énumération, la méthode _missing_ ne sera pas appelée. Par exemple, YesOrNo("Y") renverra directement YesOrNo.YES.
• Type de retour : La méthode _missing_ doit renvoyer un membre d'énumération (c'est-à-dire sous la forme cls.MEMBER), sinon une erreur de type sera générée.
• Gestion des exceptions?: cela devrait permettre à enum.Enum de lever une ValueError si le _missing_ ne reconna?t pas la valeur transmise, ou une exception plus spécifique basée sur la logique métier. Ne renvoyez pas None ou d'autres valeurs qui ne sont pas membres de l'énumération.
• Considérations sur les performances?: pour les très grandes énumérations ou les scénarios d'appels à haute fréquence, la logique dans _missing_ doit être aussi efficace que possible. Si la relation de mappage est complexe, envisagez d'utiliser un dictionnaire pour le précalcul ou la mise en cache.
• Conversion de type?: dans _missing_, il est généralement recommandé de convertir la valeur en un type uniforme (comme une cha?ne) et de la normaliser (comme .lower()) pour gérer diverses entrées.
• Note de documentation : lors de la définition d'une énumération contenant une méthode _missing_, il est recommandé que les types d'entrée et les règles de mappage qu'elle gère soient clairement indiqués dans la docstring de la classe ou de la méthode afin que les autres développeurs puissent les comprendre et les utiliser.

Résumer

En rempla?ant la méthode de classe _missing_ d'enum.Enum, nous obtenons un outil puissant qui peut gérer et mapper de manière flexible diverses valeurs d'entrée sans modifier les valeurs internes de l'énumération. Cela améliore considérablement la robustesse et la convivialité des énumérations, permettant à notre code de mieux s'adapter aux changements dans les entrées externes, tout en conservant la cohérence et la clarté du modèle de données interne. La méthode _missing_ est sans aucun doute une solution à considérer lors de la conception d'énumérations devant gérer plusieurs formes d'entrée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!