evaluated function defaults: stored where?

0 views
Skip to first unread message

David Isaac

unread,
May 25, 2005, 11:33:32 PM5/25/05
to
Default parameter values are evaluated once when the function definition is
executed.
Where are they stored? (A guess: in a dictionary local to the function.)
Where is this documented?

As a Python newbie I found this behavior quite surprising.
Is it common in many other languages?
Is it unsurprising if I look at it right?

Thanks,
Alan Isaac


Raymond Hettinger

unread,
May 26, 2005, 1:05:25 AM5/26/05
to
[Alan Isaac]

> Default parameter values are evaluated once when the function definition is
> executed. Where are they stored?


>>> def f(a, b=10, c=20):
. pass
>>> f.func_defaults
(10, 20)


> Where is this documented?

http://docs.python.org/ref/types.html#l2h-78

Raymond Hettinger

alex23

unread,
May 26, 2005, 2:14:10 AM5/26/05
to
David Isaac wrote:
> As a Python newbie I found this behavior quite surprising.

It can be even more surprising if a default value is mutable:

>>> def foo(a, b=[]):
... b.append(a)
... return b

>>> foo(3,[1,2])
[1, 2, 3]

>>> foo('c',['a','b'])
['a', 'b', 'c']

>>> foo(1)
[1]

So far, everything is behaving much as you'd expect, but then:

>>> foo(2)
[1, 2]

>>> foo(3)
[1, 2, 3]

The parameter is bound to the list at creation time and, being mutable,
is modifiable each time the function is called.

This can be avoided by modifying your function slightly:

>>> foo(3, [1,2])
[1, 2, 3]

>>> foo('c', ['a','b'])
['a', 'b', 'c']

>>> foo(1)
[1]

>>> foo(2)
[2]

>>> foo(3)
[3]

-alex23

alex23

unread,
May 26, 2005, 2:16:07 AM5/26/05
to
I wrote: (some guff on default parameters)

Of course, it helps if I actually include the alternative function's
code:

>>> def foo(a, b = None):
... if b == None: b = []


... b.append(a)
... return b

Sorry about that :)

-alex23

John Machin

unread,
May 26, 2005, 2:33:25 AM5/26/05
to David Isaac
David Isaac wrote:
> Default parameter values are evaluated once when the function definition is
> executed.
> Where are they stored?

A good bet for where to start looking for the storage would be as an
attribute of the function object. From this point, there are two paths:

(a) Make a function and inspect it:

>>> def fun(a,b=42,c=666):
... pass
...
>>> dir(fun)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__',
'__get__', '__getattribute__', '__hash__', '__init__', '__module__',
'__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__str__', 'func_closure', 'func_code', 'func_defa
ults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> fun.func_defaults
(42, 666)
>>>


(b) Become familiar with the general structure of the manuals.
By process of elimination, the Python Reference Manual would be a good
place to start for a question of this type.
Inside that manual, this is a likely candidate:
"""
3.2 The standard type hierarchy
Below is a list of the types that are built into Python.
"""

I'll leave you to read further ...

> (A guess: in a dictionary local to the function.)

As you've seen the default values are contained in a tuple. So where are
the keys of the mapping {'b': 42, 'c': 666} that you expected? Suppose
*you* do the extra research and report back ...

> Where is this documented?

See above.

>
> As a Python newbie I found this behavior quite surprising.

Surprisingly good, bad or just different? Do you have alternate
non-surprising behaviours in mind?

> Is it common in many other languages?

That makes two of us who don't know and haven't done any research :-)
My impression based on a limited number of different languages that I've
worked with or looked at is that Python's apparatus is the best I've
seen; YMMV.

> Is it unsurprising if I look at it right?

Yes; in general this is true across many domains for a very large number
of referents of "it" :-)

Cheers,
John

Raymond Hettinger

unread,
May 26, 2005, 3:39:33 AM5/26/05
to
> > Is it unsurprising if I look at it right?

[John Machin's QOTW]


> Yes; in general this is true across many domains for a very large number
> of referents of "it" :-)

There's a Quote of the Week in there somewhere.

David Isaac

unread,
May 27, 2005, 5:07:56 PM5/27/05
to
Alan Isaac wrote:
> Default parameter values are evaluated once when the function definition
is
> executed. Where are they stored? ... Where is this documented?

Forgive any poor phrasing: I'm not a computer science type.
At http://www.network-theory.co.uk/docs/pytut/tut_26.html we read:
"The execution of a function introduces a new symbol table
used for the local variables of the function. More precisely,
all variable assignments in a function store the value in the local
symbol table; whereas variable references first look in the local
symbol table, then in the global symbol table, and then in the table of
built-in names."

But the default values of function parameters seem rather like a static
attributes of a class.
Is that a good way to think of them?
If so, are they somehow accessible?
How? Under what name?

Thanks,
Alan Isaac


Jp Calderone

unread,
May 27, 2005, 5:13:22 PM5/27/05
to pytho...@python.org

The inspect module will get them for you:

exarkun@boson:~$ python
Python 2.4.1 (#2, Mar 30 2005, 21:51:10)
[GCC 3.3.5 (Debian 1:3.3.5-8ubuntu2)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def f(x='y'): pass
...
>>> import inspect
>>> inspect.getargspec(f)
(['x'], None, None, ('y',))
>>>

As to where they are actually stored, this should be considered an implementation detail, but you can look at inspect.py to see how it pulls the values out (they're just in an attribute on the function object).

Jp

Reply all
Reply to author
Forward
0 new messages