Changing argument value

[flyfree]

>>def fooA(y):
y = [3,4]
return y

>>def fooB(y):

y[0] = 3
y[1] = 4
return y

>>x = [1,2]
fooA(x)

[3, 4]

>>x

[1, 2]

>>fooB(x)

[3, 4]

>>x

[3, 4]
===============

From above, the original argument value of fooA is same as before
[1,2]
but the original argument value of fooB is changed from [1,2] to
[3,4].

What is the difference between "y = [3,4]" and "y[0]=3

y[1] =4 "
Thanks,

SC

[Bruno Desthuilliers]

flyfree a écrit :

>>>>def fooA(y):

y = [3,4]
return y

>>>>def fooB(y):

y[0] = 3
y[1] = 4
return y

>>>>x = [1,2]
fooA(x)

[3, 4]

>>>>x

[1, 2]

>>>>fooB(x)

[3, 4]

>>>>x

[3, 4]
===============

From above, the original argument value of fooA is same as before
[1,2]
but the original argument value of fooB is changed from [1,2] to
[3,4].

What is the difference between "y = [3,4]" and "y[0]=3
y[1] =4 "

In the first case, you rebind the local name y to a new list object -
and since the name is local, rebinding it only affects the local
namespace. In the second case, you mutate the list object (bound to the
local name y) passed to the function. The point to remember is that in
Python, all variables are references to objects, but names (including
params) are local.

HTH

[Stargaming]

On Thu, 13 Dec 2007 22:52:56 +0100, Bruno Desthuilliers wrote:

flyfree a écrit :

[snip]

>What is the difference between "y = [3,4]" and "y[0]=3 y[1] =4 "

In the first case, you rebind the local name y to a new list object -
and since the name is local, rebinding it only affects the local
namespace. In the second case, you mutate the list object (bound to the
local name y) passed to the function. The point to remember is that in
Python, all variables are references to objects, but names (including
params) are local.

HTH

Even though you have the assignment operator *in both cases*, it does
**not** issue the same thing.

As Bruno pointed out, in the first case ``y = [3,4]`` it is *rebinding*
the name `y`. When used with slice notation, the assignment operator
tells the object bound to y, "Hey, change your item with name/number 0 to
3, please." This can succeed but it doesn't have to. Raw assignments
always succeed.

(You could also make assignments of y[0] result in whatever you want, a
SystemExit for example; not so with pure assignments of y! The behaviour
of assignments cannot be influenced in any way.)

If you're interested in the special methods Python uses there, `Emulating
container types <http://docs.python.org/ref/sequence-
types.html#l2h-232>`_ might be interesting for you.

To sum up, the assignment operator has multiple meanings depending on its
left-hand-side operand.

HTH,

[Tim Roberts]

Stargaming <st********@gmail.comwrote:

>
Even though you have the assignment operator *in both cases*, it does
**not** issue the same thing.

As Bruno pointed out, in the first case ``y = [3,4]`` it is *rebinding*
the name `y`.

There have been two good replies to this, but I would like to present the
"mental model" I use to understand this. The term "rebinding" is not one
that folks encounter very often, and so doesn't bring up an image.

In Python, you have objects (which do not have names), and you have names.
Names get "bound" to objects. For example:

x = [1,2,3]

This statement creates an anonymous object out in space. The object is a
list, containing three numbers. It also creates a name "x" in a namespace,
and binds it to that anonymous list.

Now, let's say I do this:

x = [1,2,6]

This creates a NEW anonymous object out in space -- a list containing three
numbers -- and binds the name "x" to it. For a short time, we now have TWO
three-element lists in our object space. The old list ([1,2,3]) now has
nothing bound to it, so it will eventually be cleaned up by the garbage
collector. x is now bound to an entirely different object.

But, if I did this INSTEAD of that:

x[2] = 6

This does NOT create a new list. Instead, it changes one element in that
first anonymous list object we created. x is still bound to that same
list.

So, consider your example:

def fooA(y):
y = [3,4]
return y

def fooB(y):
y[0] = 3
y[1] = 4
return y

x = [1,2]
fooA(x)

"x" is just a name in the global namespace. We don't really pass "x" to
the function. Instead, we pass that anonymous list object with
two-elements. As the function is called, that list gets bound to the name
"y" inside fooA. This list now has TWO names bound to it, "x" in the
global namespace, and "y" in the fooA function.

When you execute
y = [3,4]
you are creating a brand-new list with two elements, and bunding that to
the local name "y". The old list STILL EXISTS, and since it is still bound
to the global "x", it won't be cleaned up. When the function returns, the
name "y" goes away, so it gets unbound. Since you don't store the function
result anywhere, the [3,4] list now has no names bound to it, and will get
cleaned up.

fooB(x)

Like before, this is passing the two-element [1,2] list into fooB, where it
gets bound to "y" inside fooB. Again, it has two names bound to it. Then,
when you do
y[0] = 3
you are changing an element in that list. Since that same list is bound to
both the global "x" and the local "y", the effect of the changes WILL be
seen when you exit from function.
--
Tim Roberts, ti**@probo.com
Providenza & Boekelheide, Inc.