scared about refrences...

[SpreadTooThin]

I'm really worried that python may is doing some things I wasn't
expecting... but lets see...

if I pass a list to a function def fn(myList):

and in that function I modify an element in the list, then does the
callers list get modied as well.

def fn(list):
list[1] = 0

myList = [1, 2, 3]
print myList
fn(myList)
print myList

>>[1,2,3]
[1,0,3]

How can I avoid this? In this case this is a really simplified example
but the effects are the same...
How do I specify or create deep copies of objects that may contain
other objects that may contain other
object that may contain other objects....

[Bruno Desthuilliers]

Nick Vatamaniuc a écrit :
(snip)

In Python all the primitives are copied and all other entities are
references.

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

[SpreadTooThin]

Bruno Desthuilliers wrote:

Nick Vatamaniuc a écrit :
(snip)

In Python all the primitives are copied and all other entities are
references.

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

[Diez B. Roggisch]

SpreadTooThin schrieb:

Bruno Desthuilliers wrote:

>Nick Vatamaniuc a écrit :
(snip)

>>In Python all the primitives are copied and all other entities are
references.

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

It appears so, but it still is a truth - all objects, even the numbers,
are objects. No copying.

Diez

[Fredrik Lundh]

SpreadTooThin wrote:

>Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

Python uses neither "call by value" nor "call by reference", but that's
irrelevant: the result you're seeing has nothing to do with the calling
model, but with how assignment works. Gabriel already posted this link;
I suggest you read it again:

http://www.effbot.org/zone/python-objects.htm

</F>

[Inyeol Lee]

On Wed, Nov 01, 2006 at 12:20:36PM -0800, SpreadTooThin wrote:

>
Bruno Desthuilliers wrote:

Nick Vatamaniuc a écrit :
(snip)

In Python all the primitives are copied and all other entities are
references.

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

What you're confused with is assignment. Check this example;

>>def f(x):

... print id(x)
... x = x + 1
... print id(x)
...

>>f(1234)

1617596
1617608

>>a = 5678
id(a)

1617596

>>f(a)

1617596
1617620

>>>

You can assume id() as a memory address. Is it call-by-value?

-- Inyeol Lee

[Bruno Desthuilliers]

SpreadTooThin a écrit :

Bruno Desthuilliers wrote:

>>Nick Vatamaniuc a écrit :
(snip)

>>>In Python all the primitives are copied and all other entities are
references .

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

It's not passed by value. when in fn(), the *local* name 'x' is bound to
(IOW:references ) the exact same object you passed to fn(). Then you
rebind this (local) name to *another* object.

def fn((x):
print id(x)
x = x + 1
print id(x)

n = 1256
print id(n)
fn(n)

def fn2(alist):
print id(alist)
alist.append(42 )

mylist = []
print id(mylist)
fn2(mylist)
print mylist
print id(mylist)
There's nothing like "pass by value" or "pass by reference" in Python
(and you'll notice I didn't claimed anything about this - just that the
'argument passing scheme' was the same for all objects).

What we call "variables" in Python are name=>object bindings. When
passing a "variable" to a function, the reference to the objet is bound
to the name of the argument in the function's namespace. So the *name*
is local to the function (hence rebinding the name to another objet
doesn't impact the name=>object binding in the caller's namespace), but
this name really refers to the same object (Python doesn't copy anything
unless explicitely told to do so).

HTH

[SpreadTooThin]

Bruno Desthuilliers wrote:

SpreadTooThin a écrit :

Bruno Desthuilliers wrote:

>Nick Vatamaniuc a écrit :
(snip)

In Python all the primitives are copied and all other entities are
references.

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.

so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

It's not passed by value. when in fn(), the *local* name 'x' is bound to
(IOW:references ) the exact same object you passed to fn(). Then you
rebind this (local) name to *another* object.

def fn((x):
print id(x)
x = x + 1
print id(x)

n = 1256
print id(n)
fn(n)

def fn2(alist):
print id(alist)
alist.append(42 )

mylist = []
print id(mylist)
fn2(mylist)
print mylist
print id(mylist)
There's nothing like "pass by value" or "pass by reference" in Python
(and you'll notice I didn't claimed anything about this - just that the
'argument passing scheme' was the same for all objects).

What we call "variables" in Python are name=>object bindings. When
passing a "variable" to a function, the reference to the objet is bound
to the name of the argument in the function's namespace. So the *name*
is local to the function (hence rebinding the name to another objet
doesn't impact the name=>object binding in the caller's namespace), but
this name really refers to the same object (Python doesn't copy anything
unless explicitely told to do so).

HTH

I realize I may be beating a dead horse here... but...

a = 2
fn(a)

>>3

print a

>>2

So in some cases the it is safe to assume that your variables to
function will not
change in other cases it is not.. but they are all the same...

[Steve Holden]

SpreadTooThin wrote:

Bruno Desthuilliers wrote:

>>SpreadTooTh in a écrit :

>>>Bruno Desthuilliers wrote:
Nick Vatamaniuc a écrit :
(snip)
>In Python all the primitives are copied and all other entities are
>references .

Plain wrong. There's no "primitives " (ie : primitive data types) in
Python, only objects. And they all get passed the same way.
so..
def fn(x):
x = x + 1
print x

a = 2
fn(a)
fn(2)

Wouldn't you say that this is being passed by value rather than by
refrence?

It's not passed by value. when in fn(), the *local* name 'x' is bound to
(IOW:referenc es) the exact same object you passed to fn(). Then you
rebind this (local) name to *another* object.

def fn((x):
print id(x)
x = x + 1
print id(x)

n = 1256
print id(n)
fn(n)

def fn2(alist):
print id(alist)
alist.append(42 )

mylist = []
print id(mylist)
fn2(mylist)
print mylist
print id(mylist)
There's nothing like "pass by value" or "pass by reference" in Python
(and you'll notice I didn't claimed anything about this - just that the
'argument passing scheme' was the same for all objects).

What we call "variables" in Python are name=>object bindings. When
passing a "variable" to a function, the reference to the objet is bound
to the name of the argument in the function's namespace. So the *name*
is local to the function (hence rebinding the name to another objet
doesn't impact the name=>object binding in the caller's namespace), but
this name really refers to the same object (Python doesn't copy anything
unless explicitely told to do so).

HTH

I realize I may be beating a dead horse here... but...

You are!

a = 2
fn(a)

>>>>3

print a

>>>>2

So in some cases the it is safe to assume that your variables to
function will not
change in other cases it is not.. but they are all the same...

Mutable values can be mutated. Immutable ones can't.

Please stop worrying and start enjoying Python. Once you have started
cutting code you will wonder why you ever bothered to spend so much time
on this issue.

regards
Steve
--
Steve Holden [phone] [phone]
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://holdenweb.blogspot.com
Recent Ramblings http://del.icio.us/steve.holden

[Gabriel Genellina]

At Thursday 2/11/2006 19:23, SpreadTooThin wrote:

>I realize I may be beating a dead horse here... but...

def fn(x):
x = x + 1
print x
a = 2
fn(a)

>3

print a

>2

So in some cases the it is safe to assume that your variables to
function will not
change in other cases it is not.. but they are all the same...

Forget about variables!
In Python you have objects. Objects don't have a name, but you may
use a name to refer to them.
In the code above, `a` is not a variable, neither an object; it's
just a name referring to an object (a name bound to an object); such
object is an instance of type int, with value 2, to be precise.
fn(a) calls function fn [in fact, "the object bound to the name fn"]
passing an object -the object referenced by the name `a`- as its only argument.
Inside function fn, it gets a single argument bound to the name x.
You do some math and bind the resulting object to the local name `x`.
Now x refers to another instance of type int, with value 3. The
original int object is not modified - and never could have been,
since int's are immutable, you cant change them (a 2 will always be a
2: if you get a 3, it's ANOTHER object).
After function fn finishes, execution continues with the `print a`
statement. Nobody has changed the object pointed by the name `a`, so
it's still the int with value 2, and that's what you get.

All objects have identity. You can test identity using the `is`
operator: `a is b` returns True iff both objects are identical (both
are "the same object" just being referred by another name). The
function id() returns the object identity.

Some objects (by example, containers like lists and dicts) are
mutable. That means that you can change it's value, but the remain
being the same object. By example:

--- begin test.py ---
def g(x):
print 'x[1], in:', x[1]
x[1] = 10
print 'x[1], out:', x[1]

a1=1
a2=2
a3=3
foo=[a1,a2,a3]
print "before, foo=",foo,"id(f oo)=",id(foo)
print "a2=",a2,"id(a2 )=",id(a2)
g(foo)
print "after, foo=",foo,"id(f oo)=",id(foo)
print "a2=",a2,"id(a2 )=",id(a2)
--- end test.py ---
Output:

before, foo= [1, 2, 3] id(foo)= 12350728
a2= 2 id(a2)= 11163404
x[1], in: 2
x[1], out: 10
after, foo= [1, 10, 3] id(foo)= 12350728
a2= 2 id(a2)= 11163404

Function g modifies the second "slot" in the list - it does not
modify the object already in that place, it just makes the second
item in the list to refer to another object (the int 10). The
previous reference (the int 2) is lost.
Anyway, the list remains "the same" (look at id(foo)).
The name a2 still refers to the int 2 (because nobody changed that).

It's really easy once you get it - and then, just enjoy writing Python code!
--
Gabriel Genellina
Softlab SRL

_______________ _______________ _______________ _____
Correo Yahoo!
Espacio para todos tus mensajes, antivirus y antispam ¡gratis!
¡Abrí tu cuenta ya! - http://correo.yahoo.com.ar