shithon 2

[ex0_planet]

Дивные проектные решения принятые разработчиками сабжа по накурке не перестают удивлять.

Как, оказывается, связываются свободные переменные в питоновских лямбдах!? По ссылке? По значению? Мимо! ПО ИМЕНИ и SCOPE !!!! То есть вот это работает:

>>> i=3
>>> add=lambda x:i+x
>>> add(3)
6
>>> i=[1,2]
>>> add([3])
[1,2,3]

По неопытности можно себе как-нибудь все волосы изорвать.

Comments

[juan_gandhi]

Ну я б не спешил критиковать. Таков уж у них scope. Closure, чо.

[ex0_planet]

Меня просто немного бесед вот этот подход, когда мы типа взрослые:у нас есть и мапредьюс, и кложи, которые на самом деле не кложи, а хуйня на палочке, но вы не рефлексируйте, пользуйтесь.

[juan_gandhi]

var i = 3
let plus = x => i + x
println(plus(2))
i="3"
println(plus(2))

---

5
32

[ex0_planet]

Ну, этот язык приводят в пример как образец странного дизайна. Чему там равно null+"3" ?

[juan_gandhi]

null3

[ircicq]

Так в большинстве динамических языков

Переменные с лексическим Scope связываются в Lexical environment.
Глобальные, как в данном случае остаются таковыми, т.е. по имени.

[ex0_planet]

Что приводит к тому что если я хочу именно _замыкание_ с захватом окружения, то я должен написать функцию make_closure(): return lambda ...., так? А если я хочу анонимное замыкание, то я слишком много хочу.

[ircicq]

Если в Python локальные переменные есть только у функций, то - да.
в Лисп бы это было:

(setq add
  (let ((i 3)) (lambda (x) (+ i x))))

[chaource]

Я бы понималъ этотъ кодъ такъ:

i = 3 # Ввели новую переменную `i`.
add = lambda x : i + x # Запомнили ссылку на `i`.
i = [1, 2] # Модифицировали опредѣленную выше `i`. Это не новая перемѣнная.
add([3]) # [1, 2] + [3] потому что `add` содержитъ ссылку на `i`.

[ex0_planet]

Примерно так, да. Но! В норме присваивание переменной просто отвязывает имя от объекта, на который переменная показывала и она начинает показывать на новый объект. Т.е. если я напишу нечто вроде:

D={}
L=[1,2,3]
D['foo']=L
print(D)
print(L)
L=[4,5,6]
print(D)
print(L)

то получу

{'foo':[1,2,3]}
[1,2,3]
{'foo':[1,2,3]}
[4,5,6]

Т.е. мы видим что L пошла своей дорогой, а то что мы отдали в D — своей.

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

[chaource]

А съ обычными функцiями (не лямбдами) не то же самое?

$ python3
>>> i=1
>>> def f():
... return i
...
>>> f()
1
>>> i=2
>>> f()
2

[ex0_planet]

От "просто функции" несколько другие ожидания. От неё ждешь что она работает с текущим состоянием и это нормально. Ментальная модель лямбды (в моей голове по крайней мере) — это мы консервируем вычисления на потом, и когда наступает это "потом" мы работаем с законсервированным состоянием плюс параметры.