нелокальне ключове слово в Python 2.x

Я намагаюся реалізувати закриття в Python 2.6, і мені потрібно отримати доступ до нелокальної змінної, але здається, що це ключове слово недоступне в python 2.x. Як слід отримувати доступ до нелокальних змінних у закриттях у цих версіях python?

Внутрішні функції можуть читати нелокальні змінні в 2.x, лише не відновлювати їх. Це дратує, але можна обійтись. Просто створіть словник і зберігайте свої дані як елементи в ньому. Внутрішні функції не забороняють мутувати об'єкти, на які посилаються нелокальні змінні.

Щоб використовувати приклад з Вікіпедії:

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

Наступне рішення натхнене відповіддю Еліаса Замарії , але всупереч цій відповіді правильно обробляти кілька викликів зовнішньої функції. "Змінна" inner.yє локальною для поточного виклику outer. Тільки це не змінна, оскільки це заборонено, а атрибут об'єкта (об'єктом є сама функція inner). Це дуже некрасиво (зауважте, що атрибут можна створити лише після визначення innerфункції), але здається ефективним.

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)

Замість словника, до нелокального класу є менше скупчення . Зміна @ ChrisB в прикладі :

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

Тоді

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

Кожен зовнішній () виклик створює новий і чіткий клас, який називається контекстом (а не лише новим екземпляром). Таким чином, це уникає побоювання @ Nathaniel про спільний контекст.

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

assert f() == 5

Я думаю, тут ключовим є те, що ви маєте на увазі під "доступом". Не повинно виникнути проблем з читанням змінної за межами області закриття, наприклад,

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

має працювати як очікувалося (друк 3). Однак перевизначення значення x не працює, наприклад,

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

все одно буде надруковано 3. З мого розуміння PEP-3104, саме це має на увазі нелокальне ключове слово. Як згадувалося в PEP, ви можете використовувати клас, щоб виконати те ж саме (безладно):

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

Є ще один спосіб реалізації нелокальних змінних в Python 2, якщо будь-який із відповідей тут небажаний з будь-якої причини:

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

Зайвим є використання назви функції в операторі присвоєння змінної, але для мене це виглядає більш простим і чистішим, ніж розміщення змінної у словнику. Значення запам'ятовується від одного дзвінка до іншого, як і у відповіді Кріса Б.

Ось щось, натхнене пропозицією Алоїза Магдала, зробленої в коментарі щодо іншої відповіді :

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)

Оновлення

Нещодавно озираючись на це, мене вразило те, наскільки це було декоративно - коли мені зрозуміло, що реалізація цього як одного зробить його більш загальним та корисним (хоча, мабуть, це певною мірою погіршує читабельність).

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

Зауважте, що обидві версії працюють в обох Python 2 та 3.

Існує бородавка в правилах розміщення python - присвоєння робить змінну локальною для її прямо огороджувальної області функцій. Для глобальної змінної ви вирішите це за допомогоюglobal ключового слова.

Рішення полягає в тому, щоб ввести об'єкт, який розділяється між двома областями, який містить змінні змінні, але сам посилається через змінну, яка не призначена.

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

Альтернативою є кілька областей хакерства:

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

Можливо, вам вдасться розібратися в хитрість, щоб отримати ім'я параметра outer, а потім передати його як varname, але не покладаючись на ім'я, яке outerвам потрібно використовувати Y-комбінатор.

Ще один спосіб зробити це (хоча це занадто багатослівно):

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

Розширюючи вишукане рішення Martineau вище до практичного та дещо менш елегантного випадку використання, я отримую:

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)

Використовуйте глобальну змінну

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

Особисто мені не подобаються глобальні змінні. Але моя пропозиція заснована на https://stackoverflow.com/a/19877437/1083704 відповіді

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

де користувачеві потрібно оголосити глобальну змінну ranks, кожен раз, коли вам потрібно викликати report. Моє вдосконалення усуває необхідність ініціалізувати змінні функції у користувача.