Четене/запис на затваряния на 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-те, в разцвета на OO. Затварянията бяха доста ниско в списъка с езикови функции, които хората искаха. Тъй като функционални идеи като първокласни функции, затваряния и други неща си проправят път към масовата популярност, езици като 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

РЕДАКТИРАНЕ: Вярвам, че крайният отговор на вашия въпрос е 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: Обхват (решено ли е Re: Lambda обвързване?)).

Въпреки това, аз също имам своя собствена интерпретация.
Python имплементира пространствата от имена като речници; когато търсене за променлива е неуспешно във вътрешния, след това се опитва във външния и така нататък, докато стигне до вградените.
Въпреки това, свързването на променлива е напълно различни неща, защото трябва да посочите определено пространство от имена - че то винаги е най-вътрешното (освен ако не зададете флага "global", това означава, че винаги е глобалното пространство от имена).
В крайна сметка различните използвани алгоритми за търсене и обвързване на променливи са причината затварянията да бъдат само за четене в 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

Необходима е малко повече работа, за да имате по-ограничен обхват за променливата за броене, вместо да използвате променлива на псевдоглобален модул (все още 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 за предаване на param на затваряне.

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