two quick questions

[Elaine Jackson]

Two quick newbie questions:

1) Does Python have passing-by-reference?
2) In ordinary parlance, "deep" implies "shallow" but not conversely. In the
Python "copy" module (if I understand correctly), the implication goes the other
way. Do you find this a nuisance?

Peace,
EJ

[Erik Max Francis]

Elaine Jackson wrote:

1) Does Python have passing-by-reference?
It depends on exactly what you mean by that. In a sense all Python
objects are passed by reference, but only in the sense that the
reference is passed by value. (Say that three times fast.)

If you want to get the equivalent of a C++ reference on an immutable
object, you can do it with containment. Pass the function a mutable
container containing your object, and then manipulate/change the
contained object. In the caller's scope, the container will have
mutated.
2) In ordinary parlance, "deep" implies "shallow" but not conversely.
In the
Python "copy" module (if I understand correctly), the implication goes
the other
way. Do you find this a nuisance?

I'm not sure what about the copy's modules semantics you're thinking are
reversed, but the terminology used in the copy module is common in
computer science. A shallow copy means that the object is copied, but
it will retain the same references to contained objects; a deep copy
means that the object is copied, as well as the objects it contains (and
so on, recursively). A deep copy always does the same thing as a
shallow copy, and more.

--
Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
__ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
/ \ I always entertain great hopes.
\__/ Robert Frost

[Ganesan R]

>>>>> "Elaine" == Elaine Jackson <el************ ***@home.com> writes:

Two quick newbie questions:
1) Does Python have passing-by-reference?
Python only has "passing-by-value". However, in Python you always work with
references to objects. So in Python function calls pass references by
value. Hope that makes sense :-).
2) In ordinary parlance, "deep" implies "shallow" but not conversely. In
the Python "copy" module (if I understand correctly), the implication goes
the other way. Do you find this a nuisance?

If I understand you correctly, "deep" does imply "shallow" in the "copy"
module. Perhaps you can point to documentation that led you believe it
"goes the other way".

Ganesan

--
Ganesan R

[Terry Reedy]

"Elaine Jackson" <el************ ***@home.com> wrote in message
news:uz******** *************** @news1.calgary. shaw.ca...

Two quick newbie questions:

1) Does Python have passing-by-reference?
Python no. Arg passing is by object binding. CPython uses *PyObject
passing to implement this. Human readers do what they do. For more,
try to find long thread on function calls/arg passing earlier this
year (via Google).

You should ask yourself why you ask this, and you might get answer
more directly relevant to you.
2) In ordinary parlance, "deep" implies "shallow" but not conversely. In the Python "copy" module (if I understand correctly), the implication goes the other way. Do you find this a nuisance?

I believe deep copy does shallow copy + more copy so that 'deep'
*does* imply 'shallow'. For this sort of question, start interpreter
in interactive mode (or use IDE that simulates this mode), make up
simple example, import copy module, and interactively experiment.
This is best way to learn actual behavior. Ability to do so is great
feature of Python.

Terry J. Reedy

[Michael Peuser]

The following examples might clear the more rheoretical elaborations .....
def noUse(a):
a=(4,5,6)

def tricky(a):
a[0]=(7,8,9)

# case 1
x=[1,2,3]
print x
tricky(x)

x=(1,2,3)
# case 2
noUse ([x])
print x

# case 3
tricky([x])
print x

# case 4
y=[x]
tricky (y)
print x
print y[0]

# case 5
tricky(x)
print x
Kindly
Michael Peuser

"Erik Max Francis" <ma*@alcyone.co m> schrieb im Newsbeitrag
news:3F******** *******@alcyone .com...

Elaine Jackson wrote:

1) Does Python have passing-by-reference?

It depends on exactly what you mean by that. In a sense all Python
objects are passed by reference, but only in the sense that the
reference is passed by value. (Say that three times fast.)

If you want to get the equivalent of a C++ reference on an immutable
object, you can do it with containment. Pass the function a mutable
container containing your object, and then manipulate/change the
contained object. In the caller's scope, the container will have
mutated.

2) In ordinary parlance, "deep" implies "shallow" but not conversely.
In the
Python "copy" module (if I understand correctly), the implication goes
the other
way. Do you find this a nuisance?

I'm not sure what about the copy's modules semantics you're thinking are
reversed, but the terminology used in the copy module is common in
computer science. A shallow copy means that the object is copied, but
it will retain the same references to contained objects; a deep copy
means that the object is copied, as well as the objects it contains (and
so on, recursively). A deep copy always does the same thing as a
shallow copy, and more.

--
Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
__ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
/ \ I always entertain great hopes.
\__/ Robert Frost

[Hans Nowak]

Elaine Jackson wrote:

Two quick newbie questions:

1) Does Python have passing-by-reference?

There have been lots of interesting discussions about this in the past. Here's
one such thread:

http://groups.google.com/groups?thre...ost.accu.uu.nl

HTH,

[Chad Netzer]

On Tue, 2003-08-12 at 23:06, Elaine Jackson wrote:

1) Does Python have passing-by-reference?
Yes. But the references you are passing are references to objects (not
memory locations), and objects themselves can be changeable (mutable) or
not. When you pass objects, copies are not automatically made (so
assignment is very speedy).

I prefer to say that these concepts should be put aside when thinking
about python.

Python has names that refer to objects. Objects are created, and can be
assigned one or more names (using assignment). Some objects can mutate
(like objects made by user defined classes), some cannot (like strings
or integers).

When you supply function arguments, copies of the object are not
automatically made. If you pass a mutable object, the callee has a name
for that (actual) object, and can mutate it. If you pass an immutable
object, they cannot.

When you use assignment, a copy of the object is not made. It simply
gets another name that refers to it.

Globals can confuse the issue, since they allow you to change the names
used in the global scope (ie. they can allow your function to modify a
non-local namespace, rather than just the objects passed in to the local
namespace.

Examples:

1) Without using globals:

a = 1 # Create the immutable 1 integer object and name it 'a'
b = [] # Create a mutable list

def f( c, d ):
c = 3 # Reassign name 'c' to the 3 integer object
d.append( "foo" ) # modify the list that is named 'd'

f( a, b ) # Copies of 'a', and 'b' are NOT made.
# when you call f(), c is a, and d is b.
# ie. The names in the function refer to the same
# objects as the (different) names outside the function

a == 1
b == ['foo']

Discussion:
The f() function changed 'b' because the object itself was changeable.
The a object is still 1, because the 1 object cannot
be changed at all, and f() couldn't reassign a because it gets a name
that refers to the object, not access to the namespace itself.
2) similar example using globals to pervert namespace

a = 1

def g():
global a # This says that 'a' refers to the global 'a' name
a = 2 # Since I have access to the name 'a', I can change
# the object that the global 'a' refers to.

g()
a == 2 # After calling g, the global name 'a' was changed.
The point of the globals example, was that it can be used to confuse
your understanding. So ignore it for now, and think of objects as
free-standing entities that can have multiple names, in multiple scopes,
it is easier to understand that you are passing around access to those
objects, and you can manipulate them if they are mutable. But,
pass-by-value and pass-by-reference, at least as they are typically
discussed in the 'C' programming world, are less applicable concepts.

As you get more advanced, you will see that Python uses dictionaries to
hold namespaces, and you can pass thos dictionaries (and thus the
namespaces) around as well.

2) In ordinary parlance, "deep" implies "shallow" but not conversely. In the
Python "copy" module (if I understand correctly), the implication goes the other
way. Do you find this a nuisance?

Not sure what you mean.

--
Chad Netzer

[Elaine Jackson]

Thanks to everyone who responded about this, both for the info regarding
question (1) and for the tact in not balaboring the sheer stupidity behind
question (2). That whole business got inverted somehow on its way to (whatever
passes for) my brain. Sorry about that. On the up side, it may turn out to have
been an instructive mistake: both questions are special cases of a single
underlying question or problem that I've been harboring for some time. I may
eventually start a thread about it (here or elsewhere), but for now I'm still
trying to mould it into a sensible question. I think it could be an interesting
topic for people concerned with computer-science pedagogy. So far I don't even
know if there's anyone like that around here.

In any case, mucho appreciado for the help.

ej

=============== =============== ==

Elaine Jackson <el************ ***@home.com> wrote in message
news:uz******** *************** @news1.calgary. shaw.ca...
| Two quick newbie questions:
|
| 1) Does Python have passing-by-reference?
| 2) In ordinary parlance, "deep" implies "shallow" but not conversely. In the
| Python "copy" module (if I understand correctly), the implication goes the
other
| way. Do you find this a nuisance?
|
| Peace,
| EJ
|
|