Nichtlokales Schlüsselwort in Python 2.x.

Ich versuche, einen Abschluss in Python 2.6 zu implementieren, und ich muss auf eine nicht lokale Variable zugreifen, aber es scheint, dass dieses Schlüsselwort in Python 2.x nicht verfügbar ist. Wie sollte man in Abschlüssen in diesen Python-Versionen auf nichtlokale Variablen in Closures zugreifen?

Innere Funktionen können nichtlokale Variablen in 2.x lesen , aber nicht erneut binden . Das ist ärgerlich, aber Sie können es umgehen. Erstellen Sie einfach ein Wörterbuch und speichern Sie Ihre Daten als Elemente darin. Innere Funktionen dürfen die Objekte, auf die sich nichtlokale Variablen beziehen, nicht mutieren .

So verwenden Sie das Beispiel aus Wikipedia:

def outer():
    d = {'y' : 0}
    def inner():
        d['y'] += 1
        return d['y']
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Die folgende Lösung ist von der Antwort von Elias Zamaria inspiriert , behandelt jedoch im Gegensatz zu dieser Antwort mehrere Aufrufe der äußeren Funktion korrekt. Die "Variable" inner.yist lokal für den aktuellen Aufruf von outer. Nur ist es keine Variable, da dies verboten ist, sondern ein Objektattribut (das Objekt ist die Funktion innerselbst). Dies ist sehr hässlich (beachten Sie, dass das Attribut erst erstellt werden kann, nachdem die innerFunktion definiert wurde), scheint jedoch effektiv zu sein.

def outer():
    def inner():
        inner.y += 1
        return inner.y
    inner.y = 0
    return inner

f = outer()
g = outer()
print(f(), f(), g(), f(), g()) #prints (1, 2, 1, 3, 2)

Anstelle eines Wörterbuchs gibt es weniger Unordnung in einer nichtlokalen Klasse . Beispiel von @ ChrisB ändern :

def outer():
    class context:
        y = 0
    def inner():
        context.y += 1
        return context.y
    return inner

Dann

f = outer()
assert f() == 1
assert f() == 2
assert f() == 3
assert f() == 4

Jeder äußere () Aufruf ruft eine neue und eindeutige Klasse namens Kontext auf (nicht nur eine neue Instanz). So wird vermieden, dass @ Nathaniel sich vor dem gemeinsamen Kontext hütet .

g = outer()
assert g() == 1
assert g() == 2

assert f() == 5

Ich denke, der Schlüssel hier ist, was Sie unter "Zugang" verstehen. Es sollte kein Problem beim Lesen einer Variablen außerhalb des Schließungsbereichs geben, z.

x = 3
def outer():
    def inner():
        print x
    inner()
outer()

sollte wie erwartet funktionieren (Drucken 3). Das Überschreiben des Werts von x funktioniert jedoch nicht, z.

x = 3
def outer():
    def inner():
        x = 5
    inner()
outer()
print x

wird weiterhin gedruckt 3. Nach meinem Verständnis von PEP-3104 ist dies das, was das nichtlokale Schlüsselwort abdecken soll. Wie im PEP erwähnt, können Sie eine Klasse verwenden, um dasselbe zu erreichen (etwas chaotisch):

class Namespace(object): pass
ns = Namespace()
ns.x = 3
def outer():
    def inner():
        ns.x = 5
    inner()
outer()
print ns.x

Es gibt eine andere Möglichkeit, nichtlokale Variablen in Python 2 zu implementieren, falls eine der Antworten hier aus irgendeinem Grund unerwünscht ist:

def outer():
    outer.y = 0
    def inner():
        outer.y += 1
        return outer.y
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Es ist überflüssig, den Namen der Funktion in der Zuweisungsanweisung der Variablen zu verwenden, aber es sieht für mich einfacher und sauberer aus, als die Variable in ein Wörterbuch aufzunehmen. Der Wert wird von einem Anruf zum anderen gespeichert, genau wie in der Antwort von Chris B.

Hier ist etwas, das von einem Vorschlag inspiriert wurde, den Alois Mahdal in einem Kommentar zu einer anderen Antwort gemacht hat :

class Nonlocal(object):
    """ Helper to implement nonlocal names in Python 2.x """
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)


def outer():
    nl = Nonlocal(y=0)
    def inner():
        nl.y += 1
        return nl.y
    return inner

f = outer()
print(f(), f(), f()) # -> (1 2 3)

Aktualisieren

Nachdem ich kürzlich darauf zurückgeblickt hatte, war ich beeindruckt, wie dekoratorisch es war - als mir klar wurde, dass die Implementierung als solche es allgemeiner und nützlicher machen würde (obwohl dies die Lesbarkeit in gewissem Maße beeinträchtigt).

# Implemented as a decorator.

class Nonlocal(object):
    """ Decorator class to help implement nonlocal names in Python 2.x """
    def __init__(self, **kwargs):
        self._vars = kwargs

    def __call__(self, func):
        for k, v in self._vars.items():
            setattr(func, k, v)
        return func


@Nonlocal(y=0)
def outer():
    def inner():
        outer.y += 1
        return outer.y
    return inner


f = outer()
print(f(), f(), f()) # -> (1 2 3)

Beachten Sie, dass beide Versionen sowohl in Python 2 als auch in Python 3 funktionieren.

Die Scoping-Regeln von Python enthalten eine Warze. Durch die Zuweisung wird eine Variable lokal für den unmittelbar umschließenden Funktionsumfang. Für eine globale Variable würden Sie dies mit dem globalSchlüsselwort lösen .

Die Lösung besteht darin, ein Objekt einzuführen, das von den beiden Bereichen gemeinsam genutzt wird und veränderbare Variablen enthält, auf das jedoch selbst über eine nicht zugewiesene Variable verwiesen wird.

def outer(v):
    def inner(container = [v]):
        container[0] += 1
        return container[0]
    return inner

Eine Alternative ist einige Bereiche Hackery:

def outer(v):
    def inner(varname = 'v', scope = locals()):
        scope[varname] += 1
        return scope[varname]
    return inner

Möglicherweise können Sie einige Tricks herausfinden, um den Namen des Parameters zu ermitteln outer, und ihn dann als Variablennamen übergeben, ohne sich jedoch auf den Namen verlassen zu outermüssen, müssen Sie einen Y-Kombinator verwenden.

Ein anderer Weg, dies zu tun (obwohl es zu ausführlich ist):

import ctypes

def outer():
    y = 0
    def inner():
        ctypes.pythonapi.PyCell_Set(id(inner.func_closure[0]), id(y + 1))
        return y
    return inner

x = outer()
x()
>> 1
x()
>> 2
y = outer()
y()
>> 1
x()
>> 3

Die Erweiterung der eleganten Lösung von Martineau oben auf einen praktischen und etwas weniger eleganten Anwendungsfall, den ich bekomme:

class nonlocals(object):
""" Helper to implement nonlocal names in Python 2.x.
Usage example:
def outer():
     nl = nonlocals( n=0, m=1 )
     def inner():
         nl.n += 1
     inner() # will increment nl.n

or...
    sums = nonlocals( { k:v for k,v in locals().iteritems() if k.startswith('tot_') } )
"""
def __init__(self, **kwargs):
    self.__dict__.update(kwargs)

def __init__(self, a_dict):
    self.__dict__.update(a_dict)

Verwenden Sie eine globale Variable

def outer():
    global y # import1
    y = 0
    def inner():
        global y # import2 - requires import1
        y += 1
        return y
    return inner

f = outer()
print(f(), f(), f()) #prints 1 2 3

Persönlich mag ich die globalen Variablen nicht. Mein Vorschlag basiert jedoch auf der Antwort https://stackoverflow.com/a/19877437/1083704

def report():
        class Rank: 
            def __init__(self):
                report.ranks += 1
        rank = Rank()
report.ranks = 0
report()

Hier muss der Benutzer ranksjedes Mal eine globale Variable deklarieren , wenn Sie die aufrufen müssen report. Durch meine Verbesserung muss der Benutzer die Funktionsvariablen nicht mehr initialisieren.