Чтение/запись замыканий Python

Чтобы расширить ответ Игнасио:

def counter():
    count = 0
    def c():
        nonlocal count
        count += 1
        return count
    return c

x = counter()
print([x(),x(),x()])

дает [1,2,3] в Python 3; вызовы counter() дают независимые счетчики. Другие решения, особенно с использованием itertools/yield, более идиоматичны.

Вы можете сделать это, и это будет работать примерно так же:

class counter(object):
    def __init__(self, count=0):
        self.count = count
    def __call__(self):
        self.count += 1
        return self.count    

Или немного хака:

def counter():
    count = [0]
    def incr(n):
        n[0] += 1
        return n[0]
    return lambda: incr(count)

Я бы пошел с первым решением.

РЕДАКТИРОВАТЬ: Это то, что я получаю за то, что не читаю большой текстовый блог.

В любом случае, причина, по которой замыкания Python довольно ограничены, заключается в том, что «потому что Гвидо так захотел». Python был разработан в начале 90-х, в период расцвета объектно-ориентированного программирования. Замыкания были довольно низкими в списке языковых функций, которые нужны людям. По мере того, как функциональные идеи, такие как функции первого класса, замыкания и другие вещи, становятся все более популярными, такие языки, как Python, вынуждены их добавлять, поэтому их использование может быть немного неудобным, потому что это не то, для чего язык был разработан.

<rant on="Python scoping">

Кроме того, Python (2.x) имеет довольно странные (на мой взгляд) идеи об области видимости, которые, среди прочего, мешают разумной реализации замыканий. Меня всегда смущает вот это:

new = [x for x in old]

Оставляет нас с именем x, определенным в области, в которой мы его использовали, поскольку это (на мой взгляд) концептуально меньшая область. (Хотя Python получает баллы за согласованность, поскольку выполнение того же действия с циклом for имеет такое же поведение. Единственный способ избежать этого — использовать map.)

В любом случае, </rant>

nonlocal в 3.x должен исправить это.

Я бы использовал генератор:

>>> def counter():
    count = 0
    while True:
        count += 1
        yield(count)
        
>>> c = counter()
>>> c.next()
1
>>> c.next()
2
>>> c.next()
3

EDIT: я считаю, что окончательный ответ на ваш вопрос: PEP- 3104:

В большинстве языков, поддерживающих вложенные области, код может ссылаться или повторно связывать (назначать) любое имя в ближайшей охватывающей области. В настоящее время код Python может ссылаться на имя в любой объемлющей области, но он может перепривязывать имена только в двух областях: локальной области (посредством простого присваивания) или глобальной области модуля (с использованием глобального объявления).

Это ограничение много раз поднималось в списке рассылки Python-Dev и в других местах, что привело к расширенному обсуждению и множеству предложений по устранению этого ограничения. В этом PEP обобщаются различные предложенные альтернативы вместе с преимуществами и недостатками, упомянутыми для каждой из них.

До версии 2.1 обработка областей в Python напоминала стандартную C: в файле было только два уровня области: глобальный и локальный. В C это естественное следствие того, что определения функций не могут быть вложенными. Но в Python, хотя функции обычно определяются на верхнем уровне, определение функции может быть выполнено где угодно. Это дало Python синтаксический вид вложенной области видимости без семантики и привело к несоответствиям, которые удивили некоторых программистов — например, рекурсивная функция, которая работала на верхнем уровне, переставала работать при перемещении внутрь другой функции, потому что рекурсивная функция собственное имя больше не будет отображаться в области его тела. Это нарушает интуитивное представление о том, что функция должна вести себя последовательно, когда ее помещают в разные контексты.

Функции также могут иметь атрибуты, так что это тоже сработает:

def counter():
    def c():
        while True:
            yield c.count
            c.count += 1
    c.count = 0
    return c

Однако в этом конкретном примере я бы использовал генератор, предложенный jbochi.

Что касается почему, я не могу сказать наверняка, но я предполагаю, что это не явный выбор дизайна, а скорее пережиток иногда странных правил области видимости Python (и особенно несколько странная эволюция его правила масштабирования).

Такое поведение довольно подробно объяснено в официальном руководстве по Python. а также в модели исполнения Python. В частности, из учебника:

Особая особенность Python заключается в том, что если ни один глобальный оператор не действует, присваивание имен всегда происходит в самой внутренней области видимости.

Однако это ничего не говорит о том, почему он ведет себя таким образом.

Дополнительная информация взята из PEP 3104, который пытается исправить эту ситуацию для Python. 3.0.
Здесь вы можете видеть, что это так, потому что в определенный момент времени это считалось лучшим решением вместо введения классических статических вложенных областей (см. Re: Scoping (была ли решена привязка Re: Lambda?)).

Тем не менее, у меня есть и собственная интерпретация.
Python реализует пространства имен как словари; когда поиск переменной не удается выполнить во внутренней, то она пытается выполнить ее во внешней и т. д., пока не дойдет до встроенной.
Однако связывание переменной совершенно разные вещи, потому что вам нужно указать конкретное пространство имен — оно всегда будет самым внутренним (если вы не установите «глобальный» флаг, это означает, что это всегда глобальное пространство имен).
В конце концов, используются разные алгоритмы. для поиска и связывания переменных являются причиной того, что замыкания доступны только для чтения в Python.
Но, опять же, это только мое предположение :-)

Дело не в том, что они доступны только для чтения, поскольку область действия более строгая, чем вы понимаете. Если вы не можете nonlocal в Python 3+, вы можете, по крайней мере, использовать явную область видимости. Python 2.6.1 с явной областью видимости на уровне модуля:

>>> def counter():
...     sys.modules[__name__].count = 0
...     def c():
...         sys.modules[__name__].count += 1
...         return sys.modules[__name__].count
...     sys.modules[__name__].c = c
...     
>>> counter()
>>> c()
1
>>> c()
2
>>> c()
3

Требуется немного больше работы, чтобы иметь более ограниченную область действия для переменной count вместо использования псевдоглобальной переменной модуля (все еще Python 2.6.1):

>>> def counter():
...     class c():
...         def __init__(self):
...             self.count = 0
...     cinstance = c()
...     def iter():
...         cinstance.count += 1
...         return cinstance.count
...     return iter
... 
>>> c = counter()
>>> c()
1
>>> c()
2
>>> c()
3
>>> d = counter()
>>> d()
1
>>> c()
4
>>> d()
2

Чтобы расширить ответ sdcvvc для передачи параметра в закрытие.

def counter():
    count = 0
    def c(delta=1):
        nonlocal count
        count += delta
        return count
    return c

x = counter()
print([x(), x(100), x(-99)])

Поточно-безопасная версия:

import threading

def counter():
    count = 0
    _lock = threading.Lock()
    def c(delta=1):
        nonlocal count
        with _lock:
            count += delta
            return count
    return c