nonlocal słowo kluczowe w Pythonie 2.x.

Próbuję zaimplementować zamknięcie w Pythonie 2.6 i muszę uzyskać dostęp do zmiennej nielokalnej, ale wygląda na to, że to słowo kluczowe nie jest dostępne w Pythonie 2.x. Jak uzyskać dostęp do zmiennych nielokalnych w domknięciach w tych wersjach Pythona?

Funkcje wewnętrzne mogą odczytywać zmienne nielokalne w wersji 2.x, ale nie wiążą ich ponownie. To denerwujące, ale możesz to obejść. Po prostu utwórz słownik i przechowuj w nim swoje dane jako elementy. Wewnętrzne funkcje nie mają zakazu mutowania obiektów, do których odnoszą się zmienne nielokalne.

Aby skorzystać z przykładu z Wikipedii:

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

Poniższe rozwiązanie jest inspirowane odpowiedzią Eliasa Zamarii , ale w przeciwieństwie do tej odpowiedzi poprawnie obsługuje wielokrotne wywołania funkcji zewnętrznej. „Zmienna” inner.yjest lokalna dla bieżącego wywołania outer. Tyle tylko, że nie jest to zmienna, ponieważ jest to zabronione, ale atrybut obiektu (obiekt jest innersamą funkcją ). Jest to bardzo brzydkie (zauważ, że atrybut można utworzyć dopiero po innerzdefiniowaniu funkcji), ale wydaje się skuteczne.

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)

Zamiast słownika jest mniej bałaganu w klasie nielokalnej . Modyfikowanie przykładu @ ChrisB :

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

Następnie

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

Każde wywołanie external () tworzy nową i odrębną klasę o nazwie context (a nie tylko nową instancję). Dzięki temu unika się ostrożności @ Nathaniel na temat współdzielonego kontekstu.

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

assert f() == 5

Myślę, że kluczem jest tutaj to, co rozumiesz przez „dostęp”. Nie powinno być problemu z odczytem zmiennej spoza zakresu zamknięcia, np.

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

powinien działać zgodnie z oczekiwaniami (drukowanie 3). Jednak przesłanianie wartości x nie działa, np.

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

będzie nadal drukować 3. Z mojego zrozumienia PEP-3104 właśnie to ma obejmować słowo kluczowe nonlocal. Jak wspomniano w PEP, możesz użyć klasy, aby osiągnąć to samo (trochę bałagan):

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

Istnieje inny sposób implementacji zmiennych nielokalnych w Pythonie 2, na wypadek gdyby którakolwiek z odpowiedzi tutaj była niepożądana z jakiegokolwiek powodu:

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

Używanie nazwy funkcji w instrukcji przypisania zmiennej jest zbędne, ale wydaje mi się to prostsze i czystsze niż umieszczenie zmiennej w słowniku. Wartość jest zapamiętywana z jednego wezwania do drugiego, tak jak w odpowiedzi Chrisa B.

Oto coś zainspirowanego sugestią, którą Alois Mahdal poczynił w komentarzu dotyczącym innej odpowiedzi :

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)

Aktualizacja

Kiedy ostatnio spojrzałem na to wstecz, uderzyło mnie to, jak wygląda dekorator - kiedy dotarło do mnie, że wdrożenie go w taki sposób, aby było bardziej ogólne i użyteczne (chociaż prawdopodobnie w pewnym stopniu obniża to jego czytelność).

# 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)

Zauważ, że obie wersje działają zarówno w Pythonie 2, jak i 3.

W regułach określania zakresu Pythona jest brodawka - przypisanie powoduje, że zmienna jest lokalna dla jej bezpośrednio obejmującego zakres funkcji. W przypadku zmiennej globalnej można to rozwiązać za pomocą globalsłowa kluczowego.

Rozwiązaniem jest wprowadzenie obiektu, który jest współdzielony między dwoma zakresami, który zawiera zmienne modyfikowalne, ale do niego odwołuje się zmienna, która nie jest przypisana.

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

Alternatywą jest hakowanie niektórych zakresów:

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

Być może będziesz w stanie wymyślić jakąś sztuczkę, aby uzyskać nazwę parametru outer, a następnie przekazać ją jako nazwę zmiennej, ale bez polegania na nazwie, outerktórej chciałbyś użyć kombinatora Y.

Inny sposób, aby to zrobić (chociaż jest zbyt szczegółowy):

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

Rozszerzając eleganckie rozwiązanie Martineau powyżej o praktyczny i nieco mniej elegancki przypadek użycia otrzymuję:

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)

Użyj zmiennej globalnej

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

Osobiście nie lubię zmiennych globalnych. Ale moja propozycja jest oparta na odpowiedzi https://stackoverflow.com/a/19877437/1083704

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

gdzie użytkownik musi zadeklarować zmienną globalną ranks, za każdym razem, gdy musisz wywołać metodę report. Moje ulepszenie eliminuje potrzebę inicjowania zmiennych funkcji od użytkownika.