Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > two quick questions

Reply
Thread Tools

two quick questions

 
 
Elaine Jackson
Guest
Posts: n/a
 
      08-13-2003
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


 
Reply With Quote
 
 
 
 
Ganesan R
Guest
Posts: n/a
 
      08-13-2003
>>>>> "Elaine" == Elaine Jackson <(E-Mail Removed)> 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

 
Reply With Quote
 
 
 
 
Erik Max Francis
Guest
Posts: n/a
 
      08-13-2003
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 && http://www.velocityreviews.com/forums/(E-Mail Removed) && http://www.alcyone.com/max/
__ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
/ \ I always entertain great hopes.
\__/ Robert Frost
 
Reply With Quote
 
Terry Reedy
Guest
Posts: n/a
 
      08-13-2003

"Elaine Jackson" <(E-Mail Removed)> wrote in message
news:uzk_a.740726$(E-Mail Removed). 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


 
Reply With Quote
 
Hans Nowak
Guest
Posts: n/a
 
      08-13-2003
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,



 
Reply With Quote
 
Michael Peuser
Guest
Posts: n/a
 
      08-13-2003
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" <(E-Mail Removed)> schrieb im Newsbeitrag
news:(E-Mail Removed)...
> 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 && (E-Mail Removed) && http://www.alcyone.com/max/
> __ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
> / \ I always entertain great hopes.
> \__/ Robert Frost



 
Reply With Quote
 
Chad Netzer
Guest
Posts: n/a
 
      08-13-2003
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


 
Reply With Quote
 
Elaine Jackson
Guest
Posts: n/a
 
      08-13-2003
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 <(E-Mail Removed)> wrote in message
news:uzk_a.740726$(E-Mail Removed). 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
|
|


 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Two quick questions JS Java 7 01-18-2006 11:55 AM
two quick questions tascienu@ecoaches.com XML 1 03-13-2005 09:45 PM
Two quick questions about my band-related website Geoff Hague HTML 5 07-15-2004 05:04 AM
Just two quick questions Horny Porno-thologist XML 2 01-27-2004 10:29 PM
two quick questions Steve 'Wacko' Computer Support 6 09-27-2003 04:11 AM



Advertisments