Dlaczego funkcje zagnieżdżone w Pythonie nie są nazywane zamknięciami?

Widziałem i użyłem funkcji zagnieżdżonych w Pythonie i pasują one do definicji zamknięcia. Dlaczego więc są nazywane nested functionszamiast closures?

Czy funkcje zagnieżdżone nie są zamknięciami, ponieważ nie są używane przez świat zewnętrzny?

AKTUALIZACJA: Czytałem o zamknięciach i przyszło mi do głowy myśleć o tej koncepcji w odniesieniu do Pythona. Przeszukałem i znalazłem artykuł wymieniony przez kogoś w komentarzu poniżej, ale nie mogłem całkowicie zrozumieć wyjaśnienia w tym artykule, dlatego zadaję to pytanie.

Zamknięcie występuje, gdy funkcja ma dostęp do zmiennej lokalnej z zakresu obejmującego, który zakończył wykonywanie.

def make_printer(msg):
    def printer():
        print msg
    return printer

printer = make_printer('Foo!')
printer()

Po make_printerwywołaniu na stos jest umieszczana nowa ramka ze skompilowanym kodem printerfunkcji jako stałej i wartością msgjako lokalną. Następnie tworzy i zwraca funkcję. Ponieważ funkcja printerodwołuje się do msgzmiennej, jest utrzymywana przy życiu po jej make_printerzwróceniu.

Więc jeśli twoje funkcje zagnieżdżone nie

1. dostęp do zmiennych, które są lokalne dla obejmujących zakresy,
2. rób to, gdy są wykonywane poza tym zakresem,

to nie są zamknięcia.

Oto przykład zagnieżdżonej funkcji, która nie jest zakończeniem.

def make_printer(msg):
    def printer(msg=msg):
        print msg
    return printer

printer = make_printer("Foo!")
printer()  #Output: Foo!

Tutaj wiążymy wartość z wartością domyślną parametru. Dzieje się tak, gdy funkcja printerjest tworzona, więc po powrocie nie trzeba utrzymywać odniesienia do wartości msgzewnętrznego do jest po prostu normalną zmienną lokalną funkcji w tym kontekście.printermake_printermsgprinter

Odpowiedź na to pytanie została już udzielona przez Aaronasterling

Jednak ktoś może być zainteresowany tym, jak zmienne są przechowywane pod maską.

Zanim przejdziesz do fragmentu:

Zamknięcia to funkcje, które dziedziczą zmienne z otaczającego środowiska. Gdy przekażesz funkcję zwrotną jako argument do innej funkcji, która wykona operacje we / wy, ta funkcja zwrotna zostanie wywołana później, a ta funkcja - niemal magicznie - zapamięta kontekst, w którym została zadeklarowana, wraz ze wszystkimi dostępnymi zmiennymi w tym kontekście.

• Jeśli funkcja nie używa wolnych zmiennych, nie tworzy zamknięcia.

• Jeśli istnieje inny poziom wewnętrzny, który używa wolnych zmiennych - wszystkie poprzednie poziomy zapisują środowisko leksykalne (przykład na końcu)

• atrybuty funkcji func_closurew pythonie <3.X lub __closure__w pythonie> 3.X zapisz wolne zmienne.

• Każda funkcja w pythonie ma takie atrybuty zamknięcia, ale nie zapisuje żadnej zawartości, jeśli nie ma wolnych zmiennych.

przykład: atrybutów zamknięcia, ale brak zawartości w środku, ponieważ nie ma wolnej zmiennej.

>>> def foo():
...     def fii():
...         pass
...     return fii
...
>>> f = foo()
>>> f.func_closure
>>> 'func_closure' in dir(f)
True
>>>

NB: DARMOWA ZMIENNA MUSI BYĆ TWORZENIE ZAMKNIĘCIA.

Wyjaśnię, używając tego samego fragmentu kodu jak powyżej:

>>> def make_printer(msg):
...     def printer():
...         print msg
...     return printer
...
>>> printer = make_printer('Foo!')
>>> printer()  #Output: Foo!

Wszystkie funkcje Pythona mają atrybut zamknięcia, więc zbadajmy otaczające zmienne powiązane z funkcją zamknięcia.

Oto atrybut func_closurefunkcjiprinter

>>> 'func_closure' in dir(printer)
True
>>> printer.func_closure
(<cell at 0x108154c90: str object at 0x108151de0>,)
>>>

closureAtrybut zwraca parę obiektów komórkowych, które zawierają dane o zmiennych zdefiniowanych w zakresie okalającego.

Pierwszy element w func_closure, którym może być None lub krotka komórek zawierających powiązania dla wolnych zmiennych funkcji i jest tylko do odczytu.

>>> dir(printer.func_closure[0])
['__class__', '__cmp__', '__delattr__', '__doc__', '__format__', '__getattribute__',
 '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
 '__setattr__',  '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']
>>>

Tutaj w powyższym wyjściu możesz zobaczyć cell_contents, zobaczmy, co przechowuje:

>>> printer.func_closure[0].cell_contents
'Foo!'    
>>> type(printer.func_closure[0].cell_contents)
<type 'str'>
>>>

Tak więc, kiedy wywołaliśmy funkcję printer(), uzyskuje dostęp do wartości przechowywanej wewnątrz cell_contents. W ten sposób otrzymaliśmy wynik jako „Foo!”

Ponownie wyjaśnię użycie powyższego fragmentu z pewnymi zmianami:

 >>> def make_printer(msg):
 ...     def printer():
 ...         pass
 ...     return printer
 ...
 >>> printer = make_printer('Foo!')
 >>> printer.func_closure
 >>>

W powyższym fragmencie nie wypisuję msg wewnątrz funkcji drukarki, więc nie tworzy żadnej wolnej zmiennej. Ponieważ nie ma wolnej zmiennej, wewnątrz zamknięcia nie będzie zawartości. Dokładnie to widzimy powyżej.

Teraz wyjaśnię inny fragment kodu, aby wyczyścić wszystko za Free Variablepomocą Closure:

>>> def outer(x):
...     def intermediate(y):
...         free = 'free'
...         def inner(z):
...             return '%s %s %s %s' %  (x, y, free, z)
...         return inner
...     return intermediate
...
>>> outer('I')('am')('variable')
'I am free variable'
>>>
>>> inter = outer('I')
>>> inter.func_closure
(<cell at 0x10c989130: str object at 0x10c831b98>,)
>>> inter.func_closure[0].cell_contents
'I'
>>> inn = inter('am')

Widzimy więc, że func_closurewłaściwość jest krotką komórek zamykających , możemy odesłać je i ich zawartość jawnie - komórka ma właściwość „cell_contents”

>>> inn.func_closure
(<cell at 0x10c9807c0: str object at 0x10c9b0990>, 
 <cell at 0x10c980f68: str object at   0x10c9eaf30>, 
 <cell at 0x10c989130: str object at 0x10c831b98>)
>>> for i in inn.func_closure:
...     print i.cell_contents
...
free
am 
I
>>>

Tutaj, kiedy zadzwoniliśmy inn, odniesie wszystkie zmienne wolne od zapisu, więc otrzymamyI am free variable

>>> inn('variable')
'I am free variable'
>>>

Python ma słabą obsługę zamykania. Aby zobaczyć, co mam na myśli, weźmy następujący przykład licznika używającego zamknięcia z JavaScript:

function initCounter(){
    var x = 0;
    function counter  () {
        x += 1;
        console.log(x);
    };
    return counter;
}

count = initCounter();

count(); //Prints 1
count(); //Prints 2
count(); //Prints 3

Zamknięcie jest dość eleganckie, ponieważ daje tak napisanym funkcjom możliwość posiadania „pamięci wewnętrznej”. Od wersji Python 2.7 nie jest to możliwe. Jeśli spróbujesz

def initCounter():
    x = 0;
    def counter ():
        x += 1 ##Error, x not defined
        print x
    return counter

count = initCounter();

count(); ##Error
count();
count();

Pojawi się błąd informujący, że x nie jest zdefiniowane. Ale jak to możliwe, jeśli inni pokazali, że można go wydrukować? Wynika to z tego, jak Python zarządza zmiennym zakresem funkcji. Chociaż funkcja wewnętrzna może odczytać zmienne funkcji zewnętrznej, nie może ich zapisać .

To naprawdę szkoda. Ale po zamknięciu tylko do odczytu można przynajmniej zaimplementować wzorzec dekoratora funkcji, dla którego Python oferuje cukier syntaktyczny.

Aktualizacja

Jak już wspomniano, istnieją sposoby radzenia sobie z ograniczeniami zakresu Pythona, a niektóre z nich ujawnię.

1. Użyj globalsłowa kluczowego (generalnie niezalecane).

2. W Pythonie 3.x użyj nonlocalsłowa kluczowego (sugerowanego przez @unutbu i @leewz)

3. Zdefiniuj prostą modyfikowalną klasęObject

class Object(object):
    pass

i utwórz Object scopewewnątrz, initCounteraby przechowywać zmienne

def initCounter ():
    scope = Object()
    scope.x = 0
    def counter():
        scope.x += 1
        print scope.x

    return counter

Ponieważ scopetak naprawdę jest tylko odniesieniem, działania podejmowane z jego polami tak naprawdę nie modyfikują scopesię, więc nie powstaje błąd.

4. Alternatywnym sposobem, jak wskazał @unutbu, byłoby zdefiniowanie każdej zmiennej jako tablicy ( x = [0]) i zmodyfikowanie jej pierwszego elementu ( x[0] += 1). Ponownie nie powstaje błąd, ponieważ xsam nie jest modyfikowany.

5. Jak sugeruje @raxacoricofallapatorius, możesz zrobić xwłasnośćcounter

def initCounter ():

    def counter():
        counter.x += 1
        print counter.x

    counter.x = 0
    return counter

Python 2 nie miał zamknięć - miał obejścia, które przypominały zamknięcia.

W podanych już odpowiedziach jest wiele przykładów - kopiowanie zmiennych do funkcji wewnętrznej, modyfikowanie obiektu w funkcji wewnętrznej itp.

W Pythonie 3 obsługa jest bardziej wyraźna i zwięzła:

def closure():
    count = 0
    def inner():
        nonlocal count
        count += 1
        print(count)
    return inner

Stosowanie:

start = closure()
start() # prints 1
start() # prints 2
start() # prints 3

nonlocalKluczowe wiąże funkcji wewnętrznej do zewnętrznej zmiennej wyraźnie wspomniano, w efekcie zamykając go. Stąd bardziej precyzyjnie „zamknięcie”.

Miałem sytuację, w której potrzebowałem osobnej, ale trwałej przestrzeni nazw. Korzystałem z zajęć. Ja inaczej nie. Segregowane, ale trwałe nazwy są zamknięciami.

>>> class f2:
...     def __init__(self):
...         self.a = 0
...     def __call__(self, arg):
...         self.a += arg
...         return(self.a)
...
>>> f=f2()
>>> f(2)
2
>>> f(2)
4
>>> f(4)
8
>>> f(8)
16

# **OR**
>>> f=f2() # **re-initialize**
>>> f(f(f(f(2)))) # **nested**
16

# handy in list comprehensions to accumulate values
>>> [f(i) for f in [f2()] for i in [2,2,4,8]][-1] 
16

def nested1(num1): 
    print "nested1 has",num1
    def nested2(num2):
        print "nested2 has",num2,"and it can reach to",num1
        return num1+num2    #num1 referenced for reading here
    return nested2

Daje:

In [17]: my_func=nested1(8)
nested1 has 8

In [21]: my_func(5)
nested2 has 5 and it can reach to 8
Out[21]: 13

To jest przykład tego, czym jest zamknięcie i jak można go użyć.

Chciałbym zaoferować inne proste porównanie między pythonem a przykładem JS, jeśli to pomoże wyjaśnić sprawę.

JS:

function make () {
  var cl = 1;
  function gett () {
    console.log(cl);
  }
  function sett (val) {
    cl = val;
  }
  return [gett, sett]
}

i wykonywanie:

a = make(); g = a[0]; s = a[1];
s(2); g(); // 2
s(3); g(); // 3

Pyton:

def make (): 
  cl = 1
  def gett ():
    print(cl);
  def sett (val):
    cl = val
  return gett, sett

i wykonywanie:

g, s = make()
g() #1
s(2); g() #1
s(3); g() #1

Powód: Jak wielu innych powiedziało powyżej, w pythonie, jeśli w wewnętrznym zakresie jest przypisane do zmiennej o tej samej nazwie, tworzone jest nowe odniesienie w wewnętrznym zakresie. Nie dotyczy to JS, chyba że jednoznacznie zadeklarujesz go varsłowem kluczowym.