two quick questions

Discussion in 'Python' started by Elaine Jackson, Aug 13, 2003.

  1. 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
    Elaine Jackson, Aug 13, 2003
    #1
    1. Advertising

  2. Elaine Jackson

    Ganesan R Guest

    >>>>> "Elaine" == Elaine Jackson <> 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
    Ganesan R, Aug 13, 2003
    #2
    1. Advertising

  3. 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.alcyone.com/max/
    __ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
    / \ I always entertain great hopes.
    \__/ Robert Frost
    Erik Max Francis, Aug 13, 2003
    #3
  4. Elaine Jackson

    Terry Reedy Guest

    "Elaine Jackson" <> wrote in message
    news:uzk_a.740726$...
    > 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
    Terry Reedy, Aug 13, 2003
    #4
  5. Elaine Jackson

    Hans Nowak Guest

    Hans Nowak, Aug 13, 2003
    #5
  6. 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" <> schrieb im Newsbeitrag
    news:...
    > 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.alcyone.com/max/
    > __ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
    > / \ I always entertain great hopes.
    > \__/ Robert Frost
    Michael Peuser, Aug 13, 2003
    #6
  7. Elaine Jackson

    Chad Netzer Guest

    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
    Chad Netzer, Aug 13, 2003
    #7
  8. 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 <> wrote in message
    news:uzk_a.740726$...
    | 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
    |
    |
    Elaine Jackson, Aug 13, 2003
    #8
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. JS

    Two quick questions

    JS, Jan 18, 2006, in forum: Java
    Replies:
    7
    Views:
    339
    Roedy Green
    Jan 18, 2006
  2. Geoff Hague
    Replies:
    5
    Views:
    393
    Mark Parnell
    Jul 15, 2004
  3. Horny Porno-thologist

    Just two quick questions

    Horny Porno-thologist, Jan 27, 2004, in forum: XML
    Replies:
    2
    Views:
    369
    Paul Lee
    Jan 27, 2004
  4. Replies:
    1
    Views:
    341
    Richard Tobin
    Mar 13, 2005
  5. Michele Dondi

    Two quick questions about Perl6

    Michele Dondi, May 28, 2004, in forum: Perl Misc
    Replies:
    3
    Views:
    88
    Uri Guttman
    May 30, 2004
Loading...

Share This Page