Functions as Objects, and persisting values

[Falcolas]

Please help me understand the mechanics of the following behavior.
header = 'I am in front of '
def e(something):
print header + something
return e
I am in front of this

The way I understand it, function d is an object, as is e. However I
don't quite grok the exact relationship between e and d. Is e
considered to be a subclass of 'd', so that it has access to it's
parent's __dict__ object, in order to access the value of 'header'? Or
is this persistence managed in a different fashion?

 

[Diez B. Roggisch]

Please help me understand the mechanics of the following behavior.

header = 'I am in front of '
def e(something):
print header + something
return e

I am in front of this

The way I understand it, function d is an object, as is e. However I
don't quite grok the exact relationship between e and d. Is e
considered to be a subclass of 'd', so that it has access to it's
parent's __dict__ object, in order to access the value of 'header'? Or
is this persistence managed in a different fashion?

The "thing" you observe here is a called a closure. It consists of the
local variables surrounding e. So as long as you keep a reference to e,
you keep one to the variables of d itself.

Diez

 

[Rich Harkins]

[snip]

The "thing" you observe here is a called a closure. It consists of the
local variables surrounding e. So as long as you keep a reference to e,
you keep one to the variables of d itself.

Diez

More specifically though it keeps references to the requested variables
only:


def closed():
x = global_x
y = "Y_VAR"
def inner():
return y
return inner

class Destroyable(object):
def __del__(self):
print "DESTROYED"

global_x = Destroyable()
inner = closed()
print inner()
del global_x
print inner()
print "HERE"

You will get:

Y_VAR
DESTROYED
Y_VAR
HERE

If the entire dict of closed() was kept you would have seen:

Y_VAR
Y_VAR
HERE
DESTROYED

Since closed hadn't been destroyed yet: thus there was only one
reference remaining to global_x after closed() and inner() were called.

Rich

 

[Bruno Desthuilliers]

Falcolas a écrit :

Please help me understand the mechanics of the following behavior.



header = 'I am in front of '
def e(something):
print header + something
return e



I am in front of this


I am in front of this

The way I understand it, function d is an object,
Right.

as is e.
Right.

However I
don't quite grok the exact relationship between e and d.
>
Is e
considered to be a subclass of 'd',
Nope.

so that it has access to it's
parent's __dict__ object, in order to access the value of 'header'? Or
is this persistence managed in a different fashion?

As Diez said, it's called a lexical closure. A lexical closure is a
function that captures and carries the lexical scope it was defined in
with it - it 'closes over' it's environnement. Each time you call d, it
returns a new function object (using the same code object) with a
different environnement. You'll find this environement in f.func_closure.