In diesem Artikel wird detailliert beschrieben, wie Sie verschiedene Eingabewerte elegant verarbeiten k?nnen, indem Sie die Klassenmethode _missing_ in der Python-Klasse enum.Enum überschreiben. Selbst wenn der interne Wert eines Aufz?hlungselements festgelegt ist, k?nnen wir dafür sorgen, dass es mehrere externe Darstellungen akzeptiert (z. B. ?wahr“, ?ja“ usw.) und es dem richtigen Aufz?hlungselement zuordnen, w?hrend der ursprüngliche interne Wert unver?ndert bleibt, wodurch die Robustheit und Benutzerfreundlichkeit der Aufz?hlung verbessert wird.

In der Python-Entwicklung bietet enum.Enum eine leistungsstarke M?glichkeit, eine Sammlung von Konstanten zu definieren. In praktischen Anwendungen stehen wir jedoch oft vor einer Herausforderung: Wie kann man es Aufz?hlungen erm?glichen, mehrere Eingabeformen zu akzeptieren und diese einheitlich bestimmten Aufz?hlungsmitgliedern zuzuordnen, w?hrend die internen Werte der Aufz?hlungsmitglieder selbst unver?ndert bleiben? Beispielsweise k?nnen die internen Werte einer Aufz?hlung, die ?Ja/Nein“ darstellt, als ?Y“ und ?N“ definiert sein. Beim Empfang externer Eingaben müssen jedoch m?glicherweise mehrere Formen wie ?wahr“, ?Ja“ oder sogar ?T“ als Bedeutung von ?Ja“ erkannt werden.

In diesem Artikel wird anhand eines konkreten Falls detailliert vorgestellt, wie die Klassenmethode _missing_ von enum.Enum verwendet wird, um dieses Problem zu l?sen und eine flexible Eingabeverarbeitung zu erreichen.

1. Anf?ngliche Probleme und Herausforderungen

Angenommen, wir definieren eine YesOrNo-Enumeration, um ?ja“ oder ?nein“ darzustellen:

 Enumeration importieren

Klasse YesOrNo(enum.Enum):
  JA = ?J“
  NEIN = ?N“

Wir hoffen, dass das entsprechende Aufz?hlungsmitglied direkt erstellt werden kann, wenn die externe Eingabe ?Y“ oder ?N“ ist. Beispielsweise kann YesOrNo("Y") YesOrNo.YES erhalten. Dieser Teil der Funktionalit?t wird standardm??ig von enum.Enum unterstützt.

Was aber, wenn unser System einen gr??eren Bereich von Eingaben, wie etwa ?wahr“ oder ?falsch“, akzeptieren und diese auf ?YesOrNo.YES“ und ?YesOrNo.NO“ abbilden muss, w?hrend ?YesOrNo.YES.value“ weiterhin ?Y“ und ?YesOrNo.NO.value“ weiterhin ?N“ sein muss? Wenn Sie YesOrNo("true") direkt versuchen, wird ein ValueError ausgegeben, da ?true“ nicht zu den Werten von YES oder NO geh?rt.

Ein intuitiver, aber unerwünschter Ansatz besteht darin, die Aufz?hlungsdefinition zu ?ndern:

 # Eine ?nderung wird nicht empfohlen, da dadurch der interne Wert der Aufz?hlungsklasse YesOrNo(enum.Enum) ge?ndert wird:
  JA = ?wahr“
  NEIN = ?falsch“

Obwohl diese ?nderung dafür sorgt, dass YesOrNo("true") funktioniert, wird YesOrNo.YES.value wie erwartet zu "true" statt zu "Y", was im Widerspruch zu unserer Notwendigkeit steht, den internen Wert unver?ndert zu lassen.

2. L?sung: _fehlende_ Methode

enum.Enum stellt eine spezielle Klassenmethode namens _missing_ bereit, die für Situationen konzipiert ist, in denen der an den Aufz?hlungskonstruktor übergebene Wert nicht direkt mit einem Aufz?hlungsmitglied übereinstimmen kann. Durch überschreiben dieser Methode k?nnen wir eine benutzerdefinierte Suchlogik implementieren, um nicht standardm??ige Eingaben den richtigen Aufz?hlungsmitgliedern zuzuordnen.

Die Signatur einer _missing_-Methode lautet normalerweise _missing_(cls, value), wobei cls die Aufz?hlungsklasse selbst und value der nicht übereinstimmende Wert ist, der an den Konstruktor übergeben wurde. Die Methode muss das entsprechende Enumerationsmitglied zurückgeben und sollte ein Standardverhalten zulassen (ValueError ausl?sen) oder explizit eine Ausnahme ausl?sen, wenn keine übereinstimmung gefunden werden kann.

3. Implementieren Sie die Methode _missing_

Hier ist die vollst?ndige Implementierung mit der Methode _missing_ zur L?sung des oben genannten Problems:

 Enumeration importieren

Klasse YesOrNo(enum.Enum):
    JA = ?J“
    NEIN = ?N“

    @classmethod
    def _missing_(cls, value):
        ?““
        Diese Methode wird aufgerufen, wenn der übergebene Wert nicht direkt mit einem Enumerationsmitglied übereinstimmt.
        Es wird versucht, verschiedene Eingabeformen YES- oder NO-Enumerationsmitgliedern zuzuordnen.
        ?““
        # Eingabewert für Vergleich ohne Berücksichtigung der Gro?- und Kleinschreibung in Kleinbuchstaben konvertieren normalized_value = str(value).lower()

        if normalized_value in ('y', 'yes', 'true', 't'):
            return cls.YES
        elif normalized_value in ('n', 'no', 'false', 'f'):
            return cls.NO

        # Lassen Sie Enum standardm??ig ValueError ausl?sen, wenn kein bekanntes Formular übereinstimmt
        # Oder Sie k?nnen andere auszul?sende Ausnahmen anpassen # raise ValueError(f"'{value}' is not a valid YesOrNo value.")

Code-Analyse:

1. @classmethod decorator : _missing_ muss eine Klassenmethode sein, da sie auf der Aufz?hlungsklasse selbst und nicht auf einer Instanz ausgeführt wird.
2. cls-Parameter : Stellt die YesOrNo-Enumerationsklasse dar. Auf Aufz?hlungsmitglieder kann über cls.YES und cls.NO zugegriffen werden.
3. Wertparameter : Dies ist der Wert, der an den YesOrNo()-Konstruktor übergeben wird, aber nicht direkt mit einem Mitglied übereinstimmt, zum Beispiel ?true“.
4. normalized_value = str(value).lower() : Um die Matching-Logik robuster zu machen, konvertieren wir den Eingabewert in einen String und schreiben ihn in Kleinbuchstaben. Dies kann Eingaben mit unterschiedlichen F?llen wie ?True“ und ?YES“ verarbeiten.
5. Bedingtes Urteil :
   • Wenn normalized_value zu einem von ('y', 'yes', 'true', 't') geh?rt, geben Sie cls.YES zurück.
   • Wenn normalized_value einer von ('n', 'no', 'false', 'f') ist, geben Sie cls.NO zurück.
6. Behandlung fehlender übereinstimmungen : Wenn die _missing_-Methode intern keine übereinstimmung findet und ein Enumerationsmitglied zurückgibt, l?st enum.Enum standardm??ig ValueError aus. Im Beispiel werfen wir nicht explizit aus, sondern verlassen uns auf dieses Standardverhalten. Wenn Sie spezifischere Fehlerinformationen ben?tigen, k?nnen Sie ValueError(...) manuell ausl?sen.

4. Nutzung und überprüfung

Jetzt k?nnen wir diese erweiterte YesOrNo-Enumeration testen:

 # Verschiedene Eingaben testen print(f"YesOrNo('Y'): {YesOrNo('Y')}")
print(f"YesOrNo('y'): {YesOrNo('y')}")
print(f"YesOrNo('YES'): {YesOrNo('YES')}")
print(f"YesOrNo('true'): {YesOrNo('true')}")
print(f"YesOrNo('T'): {YesOrNo('T')}")
print(f"YesOrNo('N'): {YesOrNo('N')}")
print(f"YesOrNo('false'): {YesOrNo('false')}")
print(f"YesOrNo('no'): {YesOrNo('no')}")

# Stellen Sie sicher, dass die internen Werte der Aufz?hlungsmitglieder unver?ndert bleiben print(f"YesOrNo.YES.value: {YesOrNo.YES.value}")
print(f"YesOrNo.NO.value: {YesOrNo.NO.value}")

# Versuchen Sie es mit einer ungültigen Eingabe:
    JaOderNein("unbekannt")
au?er ValueError als e:
    print(f"Fehler für 'unbekannt': {e}")

Ausgabebeispiel:

 YesOrNo('Y'): YesOrNo.YES
YesOrNo('y'): YesOrNo.YES
YesOrNo('YES'): YesOrNo.YES
YesOrNo('true'): YesOrNo.YES
YesOrNo('T'): YesOrNo.YES
YesOrNo('N'): YesOrNo.NO
YesOrNo('false'): YesOrNo.NO
YesOrNo('no'): YesOrNo.NO
YesOrNo.YES.value: Y
YesOrNo.NO.value: N
Fehler für ?unbekannt“: ?unbekannt“ ist kein gültiges Ja oder Nein

Aus der Ausgabe ist ersichtlich, dass die Zuordnung zu YesOrNo.YES unabh?ngig davon, ob sie ?wahr“, ?ja“ oder ?J“ ist, erfolgreich ist. Unterdessen ist YesOrNo.YES.value immer noch ?Y“, was alle unsere Anforderungen erfüllt.

5. Vorsichtsma?nahmen und bew?hrte Vorgehensweisen

• _missing_ wird nur aufgerufen, wenn keine direkte übereinstimmung vorliegt : Wenn der übergebene Wert direkt mit dem Wert eines Aufz?hlungsmitglieds übereinstimmen kann, wird die Methode _missing_ nicht aufgerufen. Beispielsweise gibt YesOrNo("Y") direkt YesOrNo.YES zurück.
• Rückgabetyp : Die Methode _missing_ muss ein Aufz?hlungsmitglied zurückgeben (d. h. in der Form cls.MEMBER), andernfalls wird ein Typfehler ausgegeben.
• Ausnahmebehandlung : Es sollte enum.Enum erm?glichen, einen ValueError auszul?sen, wenn _missing_ den übergebenen Wert nicht erkennt, oder eine spezifischere Ausnahme basierend auf der Gesch?ftslogik. Geben Sie weder None noch andere Werte zurück, die keine Mitglieder der Aufz?hlung sind.
• Leistungsüberlegungen : Bei sehr gro?en Aufz?hlungen oder hochfrequenten Aufrufszenarien sollte die Logik in _missing_ so effizient wie m?glich sein. Wenn die Zuordnungsbeziehung komplex ist, sollten Sie die Verwendung eines W?rterbuchs zur Vorberechnung oder zum Zwischenspeichern in Betracht ziehen.
• Typkonvertierung : Innerhalb von _missing_ wird im Allgemeinen empfohlen, den Wert in einen einheitlichen Typ (z. B. Zeichenfolge) zu konvertieren und ihn zu normalisieren (z. B. .lower()), um verschiedene Eingaben zu verarbeiten.
• Hinweis zur Dokumentation : Beim Definieren einer Aufz?hlung, die eine _fehlende_ Methode enth?lt, wird empfohlen, die Eingabetypen und Zuordnungsregeln, die sie verarbeitet, klar in der Klassen- oder Methodendokumentzeichenfolge anzugeben, damit andere Entwickler sie verstehen und verwenden k?nnen.

Zusammenfassen

Durch das überschreiben der Klassenmethode _missing_ von enum.Enum erhalten wir ein leistungsstarkes Tool, das verschiedene Eingabewerte flexibel verarbeiten und zuordnen kann, ohne die internen Werte der Aufz?hlung zu ?ndern. Dies erh?ht die Robustheit und Benutzerfreundlichkeit von Aufz?hlungen erheblich und erm?glicht es unserem Code, sich besser an ?nderungen in der externen Eingabe anzupassen und gleichzeitig die Konsistenz und Klarheit des internen Datenmodells beizubehalten. Die _missing_-Methode ist zweifellos eine erw?genswerte L?sung beim Entwerfen von Aufz?hlungen, die mehrere Eingabeformen verarbeiten müssen.

Das obige ist der detaillierte Inhalt vonFlexible Eingabeverarbeitung in Python Enum: Ein tieferes Verst?ndnis der _missing_-Methode. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!