Ablehnungsbescheid

Eine ähnliche PEP für Python 3000, PEP 3103, wurde bereits abgelehnt, daher hat dieser Vorschlag auch keine Chance, akzeptiert zu werden.

Zusammenfassung

Diese PEP schlägt Strategien zur Verbesserung der Python-Leistung bei der Handhabung von Umschaltungen auf eine einzelne Variable mit einem von mehreren möglichen Werten vor.

Problem

Bis Python 2.5 war die übliche Art, Mehrfachwert-Schalter zu schreiben, die Verwendung langer Schalterkonstrukte des folgenden Typs

if x == 'first state':
    ...
elif x == 'second state':
    ...
elif x == 'third state':
    ...
elif x == 'fourth state':
    ...
else:
    # default handling
    ...

Dies funktioniert gut für kurze Schalterkonstrukte, da der Overhead des wiederholten Ladens eines lokalen Wertes (hier die Variable x) und dessen Vergleich mit einer Konstante gering ist (er hat im Durchschnitt eine Komplexität von O(n)). Wenn jedoch ein solches Konstrukt verwendet wird, um einen Zustandsautomaten zu schreiben, wie er für das Schreiben von Parsern benötigt wird, kann die Anzahl der möglichen Zustände leicht 10 oder mehr Fälle erreichen.

Die aktuelle Lösung für dieses Problem liegt in der Verwendung einer Dispatch-Tabelle, um die Methode des zugehörigen Falls zu finden, die je nach Wert der Schaltervariablen ausgeführt werden soll (dies kann auf eine durchschnittliche Komplexität von O(1) optimiert werden, z. B. durch die Verwendung von perfekten Hash-Tabellen). Dies funktioniert gut für Zustandsautomaten, die komplexe und langwierige Verarbeitungen in den verschiedenen Fallmethoden erfordern. Für solche, die nur eine oder zwei Anweisungen pro Fall verarbeiten, ist dies nicht performant, z. B.

def handle_data(self, data):
    self.stack.append(data)

Ein schönes Beispiel dafür ist der Zustandsautomat, der in pickle.py implementiert ist und zum Serialisieren von Python-Objekten verwendet wird. Weitere prominente Fälle sind XML SAX-Parser und Internetprotokoll-Handler.

Vorgeschlagene Lösungen

Diese PEP schlägt zwei verschiedene, aber nicht unbedingt widersprüchliche Lösungen vor

1. Hinzufügen einer Optimierung für den Python-Compiler und die VM, die das obige if-elif-else-Konstrukt erkennt und spezielle Opcodes dafür generiert, die ein schreibgeschütztes Dictionary zum Speichern von Sprungadressen verwenden.
2. Hinzufügen einer neuen Syntax zu Python, die die switch-Anweisung im C-Stil nachahmt.

Die erste Lösung hat den Vorteil, dass sie nicht auf das Hinzufügen neuer Schlüsselwörter zur Sprache angewiesen ist, während die zweite sauberer aussieht. Beide beinhalten einen gewissen Laufzeit-Overhead, um sicherzustellen, dass die Umschaltvariable unveränderlich und hashbar ist.

Beide Lösungen verwenden eine Dictionary-Suche, um die richtige Sprungposition zu finden, sodass sie beide denselben Problembereich teilen, da sowohl die Schaltervariable als auch die Konstanten mit der Dictionary-Implementierung kompatibel sein müssen (hashbar, vergleichbar, a==b => hash(a)==hash(b)).

if x == 'first':...
elif x == 'second':...
else:...

switch EXPR:
    case CONSTANT:
        SUITE
    case CONSTANT:
        SUITE
    ...
    else:
        SUITE

def whatis(x):
    switch(x):
        case 'one':
            print '1'
        case 'two':
            print '2'
        case 'three':
            print '3'
        else:
            print "D'oh!"

   6  LOAD_FAST         0 (x)
   9  LOAD_CONST        1 (switch-table-1)
  12  SWITCH            26 (to 38)

  14  LOAD_CONST        2 ('1')
  17  PRINT_ITEM
  18  PRINT_NEWLINE
  19  JUMP 43

  22  LOAD_CONST        3 ('2')
  25  PRINT_ITEM
  26  PRINT_NEWLINE
  27  JUMP 43

  30  LOAD_CONST        4 ('3')
  33  PRINT_ITEM
  34  PRINT_NEWLINE
  35  JUMP 43

  38  LOAD_CONST        5 ("D'oh!")
  41  PRINT_ITEM
  42  PRINT_NEWLINE

>>43  LOAD_CONST        0 (None)
  46  RETURN_VALUE

case EXPR:
    of CONSTANT:
        SUITE
    of CONSTANT:
        SUITE
    else:
        SUITE

case EXPR:
    if CONSTANT:
         SUITE
    if CONSTANT:
        SUITE
    else:
        SUITE

when EXPR:
    in CONSTANT_TUPLE:
        SUITE
    in CONSTANT_TUPLE:
        SUITE
    ...
else:
     SUITE

switch EXPR:                   switch x:
    case CONSTANT:                 case "first":
        SUITE                          print x
    case CONSTANT:                 case "second":
        SUITE                          x = x**2
    ...                                print x
    else:                          else:
        SUITE                          print "whoops!"


case EXPR:                     case x:
    of CONSTANT:                   of "first":
        SUITE                          print x
    of CONSTANT:                   of "second":
        SUITE                          print x**2
    else:                          else:
        SUITE                          print "whoops!"


case EXPR:                     case state:
    if CONSTANT:                   if "first":
         SUITE                         state = "second"
    if CONSTANT:                   if "second":
        SUITE                          state = "third"
    else:                          else:
        SUITE                          state = "first"


when EXPR:                     when state:
    in CONSTANT_TUPLE:             in ("first", "second"):
        SUITE                          print state
    in CONSTANT_TUPLE:                 state = next_state(state)
        SUITE                      in ("seventh",):
    ...                                print "done"
else:                                  break    # out of loop!
     SUITE                     else:
                                   print "middle state"
                                   state = next_state(state)

switch type(x).__name__:
    case 'int':
        SUITE
    case 'string':
        SUITE

Umfang

XXX „from \_\_future\_\_ import switch“ erklären

Danksagungen

• Martin von Löwis (Probleme mit der Optimierungsidee)
• Thomas Wouters (switch-Anweisung + Bytecode-Compiler-Beispiel)
• Skip Montanaro (Dispatching-Ideen, Beispiele)
• Donald Beaudry (switch-Syntax)
• Greg Ewing (switch-Syntax)
• Jack Jansen (Typ-Switching-Beispiele)

Referenzen

Urheberrecht

Dieses Dokument wurde gemeinfrei erklärt.