function with list argument defaulting to [] - what's going on here???

[Mike]

While trying to write a recursive function involving lists, I came
across some (to me) odd behavior which I don't quite understand. Here's
a trivial function showing the problem.

>>def f(l, r = []):

for itm in l:
r.append(itm)
print r

>>a = [1,2,3]
f(a)

[1, 2, 3]

>>f(a)

[1, 2, 3, 1, 2, 3]

>>f(a)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

I know the function is quite artificial, but it's for illustration only.
Why is "r" not being reset to the empty list on subsequent calls? It
seems like it should be reinitialized when not explicitly provided.

Thanks in advance.
Mike

[Troy Melhase]

On 4/14/07, Mike <mm***@woh.rr.c omwrote:

While trying to write a recursive function involving lists, I came
across some (to me) odd behavior which I don't quite understand. Here's
a trivial function showing the problem.

from http://docs.python.org/ref/function.html :

Default parameter values are evaluated when the function definition is
executed. This means that the expression is evaluated once, when the
function is defined, and that that same ``pre-computed'' value is used
for each call. This is especially important to understand when a
default parameter is a mutable object, such as a list or a dictionary:
if the function modifies the object (e.g. by appending an item to a
list), the default value is in effect modified.

[Mike]

Thanks, Troy. I never cease to be amazed at what can be discovered by
reading the manual! <self bangs head on wall>

Mike

Troy Melhase wrote:

On 4/14/07, Mike <mm***@woh.rr.c omwrote:

>While trying to write a recursive function involving lists, I came
across some (to me) odd behavior which I don't quite understand. Here's
a trivial function showing the problem.

from http://docs.python.org/ref/function.html :

Default parameter values are evaluated when the function definition is
executed. This means that the expression is evaluated once, when the
function is defined, and that that same ``pre-computed'' value is used
for each call. This is especially important to understand when a
default parameter is a mutable object, such as a list or a dictionary:
if the function modifies the object (e.g. by appending an item to a
list), the default value is in effect modified.

[Steven D'Aprano]

On Sat, 14 Apr 2007 17:33:11 -0800, Troy Melhase wrote:

On 4/14/07, Mike <mm***@woh.rr.c omwrote:

>While trying to write a recursive function involving lists, I came
across some (to me) odd behavior which I don't quite understand. Here's
a trivial function showing the problem.

from http://docs.python.org/ref/function.html :

Default parameter values are evaluated when the function definition is
executed. This means that the expression is evaluated once, when the
function is defined, and that that same ``pre-computed'' value is used
for each call. This is especially important to understand when a
default parameter is a mutable object, such as a list or a dictionary:
if the function modifies the object (e.g. by appending an item to a
list), the default value is in effect modified.

This comes up so often that I wonder whether Python should issue a warning
when it sees [] or {} as a default argument.
What do people think? A misuse or good use of warnings?

--
Steven.

[Alex Martelli]

Mike <mm***@woh.rr.c omwrote:
...

Why is "r" not being reset to the empty list on subsequent calls? It
seems like it should be reinitialized when not explicitly provided.

<http://www.python.org/doc/faq/genera...lues-shared-be
tween-objects>
Alex

[Paddy]

On Apr 15, 3:58 am, Steven D'Aprano
<[e-mail] IS.cybersource. com.auwrote:

On Sat, 14 Apr 2007 17:33:11 -0800, Troy Melhase wrote:

On 4/14/07, Mike <[e-mail] mwrote:

While trying to write a recursive function involving lists, I came
across some (to me) odd behavior which I don't quite understand. Here's
a trivial function showing the problem.

fromhttp://docs.python.org/ref/function.html:

Default parameter values are evaluated when the function definition is
executed. This means that the expression is evaluated once, when the
function is defined, and that that same ``pre-computed'' value is used
for each call. This is especially important to understand when a
default parameter is a mutable object, such as a list or a dictionary:
if the function modifies the object (e.g. by appending an item to a
list), the default value is in effect modified.

This comes up so often that I wonder whether Python should issue a warning
when it sees [] or {} as a default argument.

What do people think? A misuse or good use of warnings?

--
Steven.

I wonder if it is a check done by Pylint or PyChecker?

- Paddy.

[=?ISO-8859-1?Q?BJ=F6rn_Lindqvist?=]

This comes up so often that I wonder whether Python should issue a warning

when it sees [] or {} as a default argument.
What do people think? A misuse or good use of warnings?

I think Python should reevaluate the default values.

--
mvh Björn

[Steven D'Aprano]

On Sun, 15 Apr 2007 05:29:01 +0200, BJörn Lindqvist wrote:

>This comes up so often that I wonder whether Python should issue a warning
when it sees [] or {} as a default argument.
What do people think? A misuse or good use of warnings?

I think Python should reevaluate the default values.

That would break code that relies on the current behaviour. That makes it
a "maybe" for Python 3.0, and an absolute "NO!!!" for Python 2.x.

--
Steven.

[Alex Martelli]

Steven D'Aprano <st***@REMOVE.T HIS.cybersource .com.auwrote:

On Sun, 15 Apr 2007 05:29:01 +0200, BJörn Lindqvist wrote:

This comes up so often that I wonder whether Python should issue a warning
when it sees [] or {} as a default argument.
What do people think? A misuse or good use of warnings?

I think Python should reevaluate the default values.

That would break code that relies on the current behaviour. That makes it
a "maybe" for Python 3.0, and an absolute "NO!!!" for Python 2.x.

If you hope to get any change in Python 3.0, your PEP had better be in
before the end of April -- that's the 3.0 deadline for PEPs.
Alex

[Tim Leslie]

On 14 Apr 2007 20:20:42 -0700, Paddy <pa*******@goog lemail.comwrote :

On Apr 15, 3:58 am, Steven D'Aprano
<[e-mail] IS.cybersource. com.auwrote:

On Sat, 14 Apr 2007 17:33:11 -0800, Troy Melhase wrote:

On 4/14/07, Mike <[e-mail] mwrote:
>While trying to write a recursive function involving lists, I came
>across some (to me) odd behavior which I don't quite understand. Here's
>a trivial function showing the problem.

fromhttp://docs.python.org/ref/function.html:

Default parameter values are evaluated when the function definition is
executed. This means that the expression is evaluated once, when the
function is defined, and that that same ``pre-computed'' value is used
for each call. This is especially important to understand when a
default parameter is a mutable object, such as a list or a dictionary:
if the function modifies the object (e.g. by appending an item to a
list), the default value is in effect modified.

This comes up so often that I wonder whether Python should issue a warning
when it sees [] or {} as a default argument.

What do people think? A misuse or good use of warnings?

--
Steven.

I wonder if it is a check done by Pylint or PyChecker?

It is a check done by pylint

Tim

>
- Paddy.

--
http://mail.python.org/mailman/listinfo/python-list