Замыкание и декораторы

Функция — это объект
Её можно изготовить внутри другой функции и вернуть
…причём в зависимости от параметров этой другой функции!
…в процессе чего некоторые объекты из ПИ создающей функции «залипают» в ПИ создаваемой
- только они там навсегда должны залипнуть, а не только на время вызова
- ⇒ .__closure__
Это и есть замыкание!

Пример:

   1 def f1(x):
   2     def f2():
   3         return x
   4     return f2

pythontutor this

   1 def f1(x):
   2     def f2():
   3         def f3():
   4             return x
   5         return f3
   6     return f2

pythontutor this

Also: nonlocal name — явное указание брать имя name из внешнего, но не глобального пространства имён

Примеры: 1 и 2

В частности, позднее связывание:

   1 def create_adders():
   2     adders = []
   3     for i in range(10):
   4         def adder(x):
   5             return i + x
   6         adders.append(adder)
   7     return adders
   8 
   9 for adder in create_adders():
  10     print(adder(1))

Поскольку i для сгенерированных функций нелокальное, оно попадает в замыканий, и это один и тот же объект во всех adder-ах:

>>> c = create_adders()
>>> c[1]
<function create_adders.<locals>.adder at 0x7f272d2f93b0>
>>> c[1].__closure__
(<cell at 0x7f272d1c1510: int object at 0x7f272db36660>,)
>>> c[2].__closure__
(<cell at 0x7f272d1c1510: int object at 0x7f272db36660>,)
>>> c[2].__closure__[0].cell_contents
9
>>> c[1].__closure__[0].cell_contents
9

Если мы хотели не этого, надо сделать так, чтобы при создании очередного adder-а его i именовало новый объект:

   1 def create_adders():
   2     adders = []
   3     for i in range(10):
   4         def adder(x, j=i):
   5             return j + x
   6         adders.append(adder)
   7     return adders

При этом никакого замыкания не произойдёт, у каждого adder-а будет своё локальное j, инициализированное соответствующим значением i. (Если бы нам нужно было сильнее запутаться, мы могли бы написать i=i вместо j=i ☺ ).

   1 >>> c = create_adders()
   2 >>> c[1].__closure__
   3 >>> print(c[1].__closure__)
   4 None

Декораторы

Что, если мы хотим «обмазать» все вызовы некоторой функции отладочной информацией?

   1 def fun(a,b):
   2     return a*2+b
   3 
   4 def dfun(f, *args):
   5     print(">", *args)
   6     res = f(*args)
   7     print("<", res)
   8     return res
   9 
  10 
  11 print(fun(2,3))
  12 print(dfun(fun,2,3))

Неудобно! Поиск с заменой fun(a,b) на dfun(fun,a,b).

Создадим обёрнутую функцию вместо старой:

   1 # ...
   2 def genf(f):
   3     def newfun(*args):
   4         print(">", *args)
   5         res = f(*args)
   6         print("<", res)
   7         return res
   8     return newfun
   9 
  10 newf = genf(fun)
  11 print(newf(2,3))

Всё равно поиск с заменой, хотя и попроще. Тогда просто перебьём имя fun!

   1 # ...
   2 fun = genf(fun)
   3 print(fun(2,3))

Вот это и есть декоратор, записывается так:

   1 def genf(f):
   2     def newfun(*args):
   3         print(">", *args)
   4         res = f(*args)
   5         print("<", res)
   6         return res
   7     return newfun
   8 
   9 @genf
  10 def fun(a,b):
  11     return a*2+b
  12 
  13 print(fun(2,3))

Закомментировали @genf — убрали декоратор!

статья на хабре

BTW, Запись вида

   1 @декоратор2
   2 @декоратор1
   3 def функция(…)
   4 …

означает то, что вы подумали: функцию функция(), обмазанную сначала декоратором декоратор1(), а затем — декоратор2().

Параметрические декораторы

Конструкторы декораторов!

вместо объекта-функции мы пишем вызов этого объекта, значит, возвращать он должен функцию!

вторая часть статьи (+декораторы методов) примеры

∃ декораторы методов в классах. Но это потом.

Параметрические генераторы

В генератор можно затолкать значение на каждом обороте (оно прочтётся yield-ом).

   1 >>> def biased(init):
   2 ...     bias = yield init
   3 ...     while bias:
   4 ...         init += bias*2+1
   5 ...         bias = yield init
   6 ...
   7 >>> g = biased(10)
   8 >>> next(g) # или, что то же самое, g.send(None)
   9 10
  10 >>> g.send(5)
  11 21
  12 >>> g.send(5)
  13 32
  14 >>> g.send(-1)
  15 31
  16 >>> g.send(100500)
  17 201032
  18 >>> g.send(0)
  19 Traceback (most recent call last):
  20   File "<stdin>", line 1, in <module>
  21 StopIteration

Первый вызов — только next() (ещё ничего не передали), остальные — .send()
- при этом next() означает .send(None)
Зачем это может быть нужно??

Д/З

Прочитать про все эти удивительные вещи по ссылкам и прощёлкать примеры оттуда
- Замыкания: Gabor Laszlo Hajba и Dmitry Soshnikov
- Декораторы хабр и learnpython
- Параметрические декораторы хабр

TODO

EJudge: SimpleDecorator 'Простой декоратор'

Написать функцию-декоратор nonify(func), которая заменяет возвращаемое значение функции func на None, если оно было пустое (и не меняет в противном случае).
Input:
```
@nonify
def aNb(a, n, b):
    return a*n+b

print(aNb(1,2,3), aNb("QWE",0,""))
```
Output:
```
5 None
```
EJudge: FixFloat 'Фиксированная точность'

Написать функцию-параметрический декоратор fix(n), с помощью которой все вещественные (как позиционные, так и именные) параметры произвольной декорируемой функции, а также её возвращаемое значение, округляются до n-го знака после запятой. Если какие-то параметры функции оказались не вещественными, или не вещественно возвращаемое значение, эти объекты не меняются.
Input:
```
@fix(4)
def aver(*args, sign=1):
    return sum(args)*sign

print(aver(2.45675901, 3.22656321, 3.432654345, 4.075463224, sign=-1))
```
Output:
```
-13.1916
```
EJudge: VirtualTurtle 'Примитивная черепашка'

Написать параметрический генератор turtle(coord, direction), описывающий движение «черепахи» по координатной плоскости. coord — это кортеж из двух целочисленных начальных координат, direction описывает первоначальное направление (0 — восток, 1 — север, 2 — запад, 3 — юг). Координаты увеличиваются на северо-восток. Генератор принимает три команды — "f" (переход на 1 шаг вперёд), "l" (поворот против часовой стрелки на 90°) и "r" (поворот по часовой стрелке на 90°) и возвращает текущие координаты черепахи.
Input:
```
   1 robo = turtle((0,0),0)
   2 start = next(robo)
   3 for c in "flfrffrffr":
   4     print(*robo.send(c))
```
Output:
```
1 0
1 0
1 1
1 1
2 1
3 1
3 1
3 0
3 -1
3 -1
```
Исследовательская задача.
EJudge: StatCounter 'Статистика вызовов'

Написать, держитесь крепче, генератор-декоратор statcounter(), который конструирует объекты (назовём один из них stat) со следующим поведением. Первый вызов next(stat) (он же stat.send(None)) возвращает словарь, в котором stat будет хранить информацию вида функция: количество вызовов, где функция — это исходный (не обёрнутый) объект-функция (да, так тоже можно!). Все последующие вызовы stat.send(function) оборачивают вызов произвольной функции function увеличением на 1 соответствующего элемента словаря. Глобальными именами пользоваться нельзя. В примере видны уникальные id объектов, в тестах их не будет (я воспользуюсь function.__name__ или просто не буду их учитывать).
Input:
```
stat = statcounter()
stats = next(stat)

@stat.send
def f1(a): return a+1

@stat.send
def f2(a, b): return f1(a)+f1(b)

print(f1(f2(2,3)+f2(5,6)))
print(stats)
```
Output:
```
21
{<function f2 at 0x7fc3151ebb90>: 2, <function f1 at 0x7fc315283e60>: 5}
```

LecturesCMC/PythonIntro2019/08_ClosureDecorators (последним исправлял пользователь FrBrGeorge 2019-11-08 20:42:28)