storing references instead of copies in a dictionary

[mk]

Hello everyone,

I'm storing functions in a dictionary (this is basically for cooking up
my own fancy schmancy callback scheme, mainly for learning purpose):

>>def f2(arg):

.... return "f2 " + arg
....

>>>
def f1(arg):

.... return "f1" + arg
....

>>a={'1': f1, '2': f2}

[ x[1](x[0]) for x in a.items() ]

['f11', 'f2 2']

Well, neat. Except if I change function definitions now, old functions
are called. And rightly:

{'1': <function f1 at 0xb7f0ba04>, '2': <function f2 at 0xb7f0b9cc>}

>>f1

<function f1 at 0xb7f0ba04>

>>>
def f1(arg):

.... return "NEW f1 " + arg
....

>>f1

<function f1 at 0xb7f0b994>

The address of function f1 has obviously changed on redefinition.

Storing value copies in a dictionary on assignment is a reasonable
default behaviour.

However, in this particular case I need to specifically store
_references to objects_ (e.g. f1 function), or should I say _labels_
(leading to objects)?

Of course, I can basically update the dictionary with a new function
definition.

But I wonder, is there not a way _in general_ to specifically store
references to functions/variables/first-class objects instead of copies
in a dictionary?

[Uwe Schmitt]

On 17 Jul., 13:45, mk <[e-mail]:

Hello everyone,

I'm storing functions in a dictionary (this is basically for cooking up
my own fancy schmancy callback scheme, mainly for learning purpose):

*>>def f2(arg):
... * * return "f2 " + arg
...
*>>>
*>>def f1(arg):
... * * return "f1" + arg
...

*>>a={'1': f1, '2': f2}
*>>>
*>>[ x[1](x[0]) for x in a.items() ]
['f11', 'f2 2']

Well, neat. Except if I change function definitions now, old functions
are called. And rightly:

{'1': <function f1 at 0xb7f0ba04>, '2': <function f2 at 0xb7f0b9cc>}
*>>f1
<function f1 at 0xb7f0ba04>
*>>>
*>>def f1(arg):
... * * return "NEW f1 " + arg
...
*>>f1
<function f1 at 0xb7f0b994>

The address of function f1 has obviously changed on redefinition.

Storing value copies in a dictionary on assignment is a reasonable
default behaviour.

However, in this particular case I need to specifically store
_references to objects_ (e.g. f1 function), or should I say _labels_
(leading to objects)?

Of course, I can basically update the dictionary with a new function
definition.

But I wonder, is there not a way _in general_ to specifically store
references to functions/variables/first-class objects instead of copies
in a dictionary?

Python stores references in dictionaries and does not copy ! (unless
you explicitly use the copy module) !

In your case the entry in the dictionary is a reference to the same
object which f1 references, that is the object at 0xb7f0ba04.

If you now say "f1=...:" then f1 references a new object
at 0xb7f0b994, and the entry in your dictionary still references
the "old" object at 0xb7f0ba04.

I do not know any method to automatically update your dictionary
as there is no possibility to overload the assignement operator "=".
But may be somebody can teach me a new trick :-)

Greetings, Uwe

[John Machin]

On Jul 17, 9:45 pm, mk <[e-mail]:

Hello everyone,

I'm storing functions in a dictionary (this is basically for cooking up
my own fancy schmancy callback scheme, mainly for learning purpose):

>>def f2(arg):

... return "f2 " + arg
...

>>>
>>def f1(arg):

... return "f1" + arg
...

>>a={'1': f1, '2': f2}
>>>
>>[ x[1](x[0]) for x in a.items() ]

['f11', 'f2 2']

Well, neat. Except if I change function definitions now, old functions
are called. And rightly:

{'1': <function f1 at 0xb7f0ba04>, '2': <function f2 at 0xb7f0b9cc>}

>>f1

<function f1 at 0xb7f0ba04>

>>>
>>def f1(arg):

... return "NEW f1 " + arg
...

>>f1

<function f1 at 0xb7f0b994>

The address of function f1 has obviously changed on redefinition.

I wouldn't put it like that. You have created a new function, with a
different address to the original function, and bound the name "f1" to
that new function. The address of the old function is still stored in
the dictionary.

A function (or any other object) can have 0, 1, or many names:

>>def foo():

.... print "The function formerly known as foo"
....

>>fred = foo # 2 names
del foo # back to one name
fred()

The function formerly known as foo

>>L = [fred]
del fred # 0 names
L[0]() # You can't keep a good function down ...

The function formerly known as foo

>>>

Of course, I can basically update the dictionary with a new function
definition.

Uh-huh ...

>
But I wonder, is there not a way _in general_ to specifically store
references to functions/variables/first-class objects instead of copies
in a dictionary?

Yup, and that's what happens all the time, unless you explicitly make
a copy ... some objects have a copy method, sequences can be copied by
taking a full slice (seq_copy = seq[:]), otherwise read up on the copy
module.

[mk]

Uwe Schmitt wrote:

Python stores references in dictionaries and does not copy ! (unless
you explicitly use the copy module) !

In your case the entry in the dictionary is a reference to the same
object which f1 references, that is the object at 0xb7f0ba04.

If you now say "f1=...:" then f1 references a new object
at 0xb7f0b994, and the entry in your dictionary still references
the "old" object at 0xb7f0ba04.

Erm, I theoretically knews that, I guess I suffered temporary insanity
when I wrote "copies" of objects. To me it seems that Python actually
stores _labels_ referencing _objects_. Here, the problem was that the
label in the dictionary led to the "old" object.

I do not know any method to automatically update your dictionary
as there is no possibility to overload the assignement operator "=".
But may be somebody can teach me a new trick :-)

Theoretically I could define a class inheriting from dictionary and
define a property with a setter (and getter). But I would still have to
update the attribute manually, so plain dictionary is just as good.