Spezielle Methoden

Auf Python-Ebene können Objekte die folgenden speziellen Methoden definieren.

Die Methode __not__, falls definiert, implementiert den Operator 'not'. Wenn sie nicht definiert ist oder NotImplemented zurückgibt, werden die bestehenden Semantiken verwendet.

Um Short-Circuiting zu ermöglichen, wird die Verarbeitung der Operatoren 'and' und 'or' in zwei Phasen unterteilt. Phase 1 tritt nach der Auswertung des ersten Operanden, aber vor dem zweiten, auf. Wenn der erste Operand die relevante Phase-1-Methode definiert, wird diese mit dem ersten Operanden als Argument aufgerufen. Wenn diese Methode das Ergebnis bestimmen kann, ohne den zweiten Operanden zu benötigen, gibt sie das Ergebnis zurück und die weitere Verarbeitung wird übersprungen.

Wenn die Phase-1-Methode feststellt, dass der zweite Operand benötigt wird, gibt sie den speziellen Wert NeedOtherOperand zurück. Dies löst die Auswertung des zweiten Operanden und den Aufruf einer relevanten Phase-2-Methode aus. Während Phase 2 funktionieren die Methodenpaare __and2__/__rand2__ und __or2__/__ror2__ wie bei anderen binären Operatoren.

Die Verarbeitung greift auf bestehende Semantiken zurück, wenn zu irgendeinem Zeitpunkt eine relevante spezielle Methode nicht gefunden wird oder NotImplemented zurückgibt.

Als Sonderfall: Wenn der erste Operand eine Phase-2-Methode definiert, aber keine entsprechende Phase-1-Methode, wird der zweite Operand immer ausgewertet und die Phase-2-Methode aufgerufen. Dies ermöglicht es einem Objekt, das keine Short-Circuiting-Semantiken wünscht, einfach die Phase-2-Methoden zu implementieren und Phase 1 zu ignorieren.

Bytecodes

Der Patch fügt vier neue Bytecodes hinzu: LOGICAL_AND_1, LOGICAL_AND_2, LOGICAL_OR_1 und LOGICAL_OR_2. Als Beispiel für ihre Verwendung sieht der für einen 'and'-Ausdruck generierte Bytecode wie folgt aus:

     .
     .
     .
     evaluate first operand
     LOGICAL_AND_1  L
     evaluate second operand
     LOGICAL_AND_2
L:   .
     .
     .

Der LOGICAL_AND_1-Bytecode führt die Verarbeitung der Phase 1 durch. Wenn er feststellt, dass der zweite Operand benötigt wird, belässt er den ersten Operanden auf dem Stack und fährt mit dem folgenden Code fort. Andernfalls entfernt er den ersten Operanden vom Stack, pusht das Ergebnis und springt zu L.

Der LOGICAL_AND_2-Bytecode führt die Verarbeitung der Phase 2 durch, entfernt beide Operanden vom Stack und pusht das Ergebnis.

Typ-Slots

Auf C-Ebene manifestieren sich die neuen speziellen Methoden als fünf neue Slots im Typobjekt. Im Patch werden sie der tp_as_number-Teilstruktur hinzugefügt, da dies die Verwendung einiger bestehender Code zur Behandlung von unären und binären Operatoren ermöglicht. Ihre Existenz wird durch ein neues Typflag, Py_TPFLAGS_HAVE_BOOLEAN_OVERLOAD, signalisiert.

Die neuen Typ-Slots sind:

unaryfunc nb_logical_not;
unaryfunc nb_logical_and_1;
unaryfunc nb_logical_or_1;
binaryfunc nb_logical_and_2;
binaryfunc nb_logical_or_2;

Python/C API-Funktionen

Es gibt auch fünf neue Python/C API-Funktionen, die den neuen Operationen entsprechen.

PyObject *PyObject_LogicalNot(PyObject *);
PyObject *PyObject_LogicalAnd1(PyObject *);
PyObject *PyObject_LogicalOr1(PyObject *);
PyObject *PyObject_LogicalAnd2(PyObject *, PyObject *);
PyObject *PyObject_LogicalOr2(PyObject *, PyObject *);

Reduzierter Satz spezieller Methoden

Der Vollständigkeit halber enthält die vollständige Version dieses Vorschlags einen Mechanismus, mit dem Typen ihr eigenes angepasstes Short-Circuiting-Verhalten definieren können. Der vollständige Mechanismus ist jedoch nicht erforderlich, um die hier dargelegten Hauptanwendungsfälle zu behandeln, und es wäre möglich, eine vereinfachte Version zu definieren, die nur die Phase-2-Methoden enthält. Es gäbe dann nur 5 neue spezielle Methoden (__and2__, __rand2__, __or2__, __ror2__, __not__) mit 3 zugehörigen Typ-Slots und 3 API-Funktionen.

Diese vereinfachte Version könnte bei Bedarf später zur vollständigen Version erweitert werden.

Zusätzliche Bytecodes

Wie hier definiert, wäre die Bytecode-Sequenz für Code, der auf dem Ergebnis eines booleschen Ausdrucks verzweigt, etwas länger als derzeit. Zum Beispiel in Python 2.7:

if a and b:
    statement1
else:
    statement2

generiert

    LOAD_GLOBAL         a
    POP_JUMP_IF_FALSE   false_branch
    LOAD_GLOBAL         b
    POP_JUMP_IF_FALSE   false_branch
    <code for statement1>
    JUMP_FORWARD        end_branch
false_branch:
    <code for statement2>
end_branch:

Unter diesem Vorschlag, wie bisher beschrieben, würde dies etwa so aussehen:

    LOAD_GLOBAL         a
    LOGICAL_AND_1       test
    LOAD_GLOBAL         b
    LOGICAL_AND_2
test:
    POP_JUMP_IF_FALSE   false_branch
    <code for statement1>
    JUMP_FORWARD        end_branch
false_branch:
    <code for statement2>
end_branch:

Dies beinhaltet die Ausführung eines zusätzlichen Bytecodes im Short-Circuiting-Fall und zwei zusätzlichen Bytecodes im Non-Short-Circuiting-Fall.

Durch die Einführung zusätzlicher Bytecodes, die die logischen Operationen mit dem Testen und Verzweigen des Ergebnisses kombinieren, kann dies jedoch auf die gleiche Anzahl von Bytecodes wie das Original reduziert werden.

    LOAD_GLOBAL         a
    AND1_JUMP           true_branch, false_branch
    LOAD_GLOBAL         b
    AND2_JUMP_IF_FALSE  false_branch
true_branch:
    <code for statement1>
    JUMP_FORWARD        end_branch
false_branch:
    <code for statement2>
end_branch:

Hier führt AND1_JUMP die Verarbeitung der Phase 1 wie oben durch und prüft dann das Ergebnis. Wenn ein Ergebnis vorhanden ist, wird es vom Stack entfernt, sein Wahrheitswert getestet und zu einer von zwei Stellen verzweigt.

Andernfalls bleibt der erste Operand auf dem Stack und die Ausführung wird mit dem nächsten Bytecode fortgesetzt. Der AND2_JUMP_IF_FALSE-Bytecode führt die Verarbeitung der Phase 2 durch, entfernt das Ergebnis vom Stack und verzweigt, wenn es falsch ist.

Für den Operator 'or' gäbe es entsprechende OR1_JUMP- und OR2_JUMP_IF_TRUE-Bytecodes.

Wenn die vereinfachte Version ohne Phase-1-Methoden verwendet wird, kann ein früher Ausstieg nur erfolgen, wenn der erste Operand für 'and' falsch und für 'or' wahr ist. Folglich können die Zwei-Ziel-Bytecodes AND1_JUMP und OR1_JUMP durch AND1_JUMP_IF_FALSE und OR1_JUMP_IF_TRUE ersetzt werden, die gewöhnliche Verzweigungsanweisungen mit nur einem Ziel sind.

Optimierung von „not“

Neuere Versionen von Python implementieren eine einfache Optimierung, bei der das Verzweigen auf einem negierten booleschen Ausdruck durch Umkehrung der Verzweigungsrichtung implementiert wird, wodurch ein UNARY_NOT-Opcode eingespart wird.

Streng genommen sollte diese Optimierung nicht mehr durchgeführt werden, da der Operator 'not' überschrieben werden kann, um ganz andere Ergebnisse als üblich zu erzielen. In typischen Anwendungsfällen wird jedoch nicht erwartet, dass Ausdrücke mit angepassten booleschen Operationen zum Verzweigen verwendet werden – es ist viel wahrscheinlicher, dass das Ergebnis auf andere Weise verwendet wird.

Daher würde es wahrscheinlich wenig Schaden anrichten, zu spezifizieren, dass der Compiler die Gesetze der Booleschen Algebra verwenden darf, um jeden Ausdruck zu vereinfachen, der direkt in einem booleschen Kontext erscheint. Wenn dies umständlich ist, kann das Ergebnis immer zuerst einer temporären Variablen zugewiesen werden.

Dies würde es ermöglichen, die bestehende 'not'-Optimierung beizubehalten, und zukünftige Erweiterungen wie die Verwendung der De Morganschen Gesetze zur tieferen Einbettung in den Ausdruck ermöglichen.

Beispiel 1: NumPy-Arrays

#-----------------------------------------------------------------
#
#   This example creates a subclass of numpy array to which
#   'and', 'or' and 'not' can be applied, producing an array
#   of booleans.
#
#-----------------------------------------------------------------

from numpy import array, ndarray

class BArray(ndarray):

    def __str__(self):
        return "barray(%s)" % ndarray.__str__(self)

    def __and2__(self, other):
        return (self & other)

    def __or2__(self, other):
        return (self & other)

    def __not__(self):
        return (self == 0)

def barray(*args, **kwds):
    return array(*args, **kwds).view(type = BArray)

a0 = barray([0, 1, 2, 4])
a1 = barray([1, 2, 3, 4])
a2 = barray([5, 6, 3, 4])
a3 = barray([5, 1, 2, 4])

print "a0:", a0
print "a1:", a1
print "a2:", a2
print "a3:", a3
print "not a0:", not a0
print "a0 == a1 and a2 == a3:", a0 == a1 and a2 == a3
print "a0 == a1 or a2 == a3:", a0 == a1 or a2 == a3

Ausgabe von Beispiel 1

a0: barray([0 1 2 4])
a1: barray([1 2 3 4])
a2: barray([5 6 3 4])
a3: barray([5 1 2 4])
not a0: barray([ True False False False])
a0 == a1 and a2 == a3: barray([False False False  True])
a0 == a1 or a2 == a3: barray([False False False  True])

Beispiel 2: Datenbankabfragen

#-----------------------------------------------------------------
#
#   This example demonstrates the creation of a DSL for database
#   queries allowing 'and' and 'or' operators to be used to
#   formulate the query.
#
#-----------------------------------------------------------------

class SQLNode(object):

    def __and2__(self, other):
        return SQLBinop("and", self, other)

    def __rand2__(self, other):
        return SQLBinop("and", other, self)

    def __eq__(self, other):
        return SQLBinop("=", self, other)


class Table(SQLNode):

    def __init__(self, name):
        self.__tablename__ = name

    def __getattr__(self, name):
        return SQLAttr(self, name)

    def __sql__(self):
        return self.__tablename__


class SQLBinop(SQLNode):

    def __init__(self, op, opnd1, opnd2):
        self.op = op.upper()
        self.opnd1 = opnd1
        self.opnd2 = opnd2

    def __sql__(self):
        return "(%s %s %s)" % (sql(self.opnd1), self.op, sql(self.opnd2))


class SQLAttr(SQLNode):

    def __init__(self, table, name):
        self.table = table
        self.name = name

    def __sql__(self):
        return "%s.%s" % (sql(self.table), self.name)


class SQLSelect(SQLNode):

    def __init__(self, targets):
        self.targets = targets
        self.where_clause = None

    def where(self, expr):
        self.where_clause = expr
        return self

    def __sql__(self):
        result = "SELECT %s" % ", ".join([sql(target) for target in self.targets])
        if self.where_clause:
            result = "%s WHERE %s" % (result, sql(self.where_clause))
        return result


def sql(expr):
    if isinstance(expr, SQLNode):
        return expr.__sql__()
    elif isinstance(expr, str):
        return "'%s'" % expr.replace("'", "''")
    else:
        return str(expr)


def select(*targets):
    return SQLSelect(targets)

#-----------------------------------------------------------------

dishes = Table("dishes")
customers = Table("customers")
orders = Table("orders")

query = select(customers.name, dishes.price, orders.amount).where(
    customers.cust_id == orders.cust_id and orders.dish_id == dishes.dish_id
    and dishes.name == "Spam, Eggs, Sausages and Spam")

print repr(query)
print sql(query)

Ausgabe von Beispiel 2

<__main__.SQLSelect object at 0x1cc830>
SELECT customers.name, dishes.price, orders.amount WHERE
(((customers.cust_id = orders.cust_id) AND (orders.dish_id =
dishes.dish_id)) AND (dishes.name = 'Spam, Eggs, Sausages and Spam'))