Why doesn't python's list append() method return the list itself?

Discussion in 'Python' started by dhruvbird, Jul 11, 2010.

  1. dhruvbird

    dhruvbird Guest

    Why doesn't python's list append() method return the list itself? For
    that matter, even the reverse() and sort() methods?
    I found this link (http://code.google.com/edu/languages/google-python-
    class/lists.html) which suggests that this is done to make sure that
    the programmer understands that the list is being modified in place,
    but that rules out constructs like:
    I want to prepend an empty list to [1,2,3,4]. This is just a toy
    example, since I can always do that with [[]]+[1,2,3,4].

    dhruvbird, Jul 11, 2010
    1. Advertisements

  2. No!

    you can either approach this by imperatively modifying a list in-place:

    L = [1,2,3,4]

    Or you can use a more functional style:

    L2 = reversed(reversed([1,2,3,4]) + [[]])

    (or ([1,2,3,4][::-1]+[[]])[::-1], if you like that kind of thing)

    Imagine list.reverse and list.append *did* return self:

    L1 = [1,2,3,4]
    L2 = L1.reverse().append([]).reverse()

    would you expect, after this code, that (L1 == L2) and (L1 is L2)? I
    think it would surprise a lot of people. Better clearly separate
    modifying an object and functionally processing an object.


    Thomas Jollans, Jul 11, 2010
    1. Advertisements

  3. ah yes, forgot about that nuance. casting reversed to list. Still, there
    is slicing.
    Thomas Jollans, Jul 11, 2010
  4. [5, 6, 1, 2, 3, 4]
    Antoine Pitrou, Jul 11, 2010
  5. dhruvbird

    MRAB Guest

    If you want to prepend an empty list in-place, use the .insert method:

    L = [1,2,3,4]
    L.insert(0, [])
    MRAB, Jul 11, 2010
  6. dhruvbird

    dhruvbird Guest

    Okay, but this assumes that I have reversed/sorted/etc... type of
    functions for all member functions that mutate the container.
    Also, as Nathan mentioned, reversed returns an iterator, whereas
    sorted returns a list. This asymmertic behaviour is a bit unnerving.
    I think this is a fair call. Honestly, I wouldn't expect them to be
    the same.

    However, there are cases when I want to be able to write down my
    intent in one line.
    Much like f(g(h(x))).

    On a side note, is there any other way to append to a list using
    slices (apart from the one below):
    x[len(x):len(x)] = [item to append]

    And while we are talking about python here, why does this statement:
    y = x[:0] = [100] behave the way it does?
    I mean everything except for the last value is assigned to the last
    value rather than the assignments following the chain and every item
    getting its succeeding item's reference?

    dhruvbird, Jul 11, 2010
  7. dhruvbird

    News123 Guest

    dy you mean

    News123, Jul 12, 2010
  8. Because Guido thinks that having those methods return None is the best
    way to communicate that the underlying object has been mutated in-

    Some other languages do it differently, but this is Guido's language,
    so we do it his way.

    Raymond Hettinger, Jul 12, 2010
  9. You know, the latter two I can see an argument for, and could see the
    usefulness therein -- though I've never used either like that, but I
    consider that chance. I could see the use (and could readily write my
    own all/any in such a case, then keep it in my toolbox).

    But the first: what?!

    for ch in data:

    is exceptionally useful. Strings-as-sequences I've used hundreds,
    thousands of times. I use it constantly.


    Stephen Hansen
    ... Also: Ixokai
    ... Mail: me+list/python (AT) ixokai (DOT) io
    ... Blog: http://meh.ixokai.io/

    Version: GnuPG v2.0.10 (Darwin)

    -----END PGP SIGNATURE-----
    Stephen Hansen, Jul 12, 2010
  10. dhruvbird

    Chris Rebert Guest

    If you weren't taught about vacuous truth (or even identity elements)
    in Discrete Mathematics, someone fscked up. Said behavior is the
    absolute correct behavior from a formal logic standpoint.

    Chris Rebert, Jul 12, 2010
  11. dhruvbird

    dhruvbird Guest

    No, I meant x.append(4)
    Except that I want to accomplish it using slices.

    (I can do it as x[lex(x):] = [item_to_append] but is there any other

    dhruvbird, Jul 12, 2010
  12. It seems that you've found a way to do so, so why do you need another
    way? Are you after elegance? Efficiency? Brevity?

    Here are some other ways to express the same, and all use slices in some

    x[slice(len(x), None)] = [item_to_append]
    x.__setitem__(slice(len(x), None), [item_to_append])
    x.__setslice__(len(x), len(x), [item_to_append])

    ....but I have no idea why any of them would make any more sense than
    x[len(x):] = [item_to_append].
    Hrvoje Niksic, Jul 12, 2010
  13. dhruvbird

    dhruvbird Guest

    Actually, the reason I ask is because I think a lot of things can be
    done using slices and its support for negative indexes. Basically
    putting constants in the slices (as opposed to variables like len(x),
    etc... which depend upon the variable name). So, was just trying to
    cogitate on whether append can be implemented that way or not.

    dhruvbird, Jul 12, 2010
  14. dhruvbird

    John Nagle Guest

    It's interesting that all Python functions are considered to
    return a value. Arguably, if a function just does a "return",
    it should be an error to try to use its return value.

    Some languages have a very functional orientation, and
    everything is considered to return some value, even
    control structures. LISP is like that. But Python isn't
    one of those languages.

    John Nagle
    John Nagle, Jul 12, 2010
  15. It's been suggested at least once before that the
    default return value for a function should be some
    special value that raises an exception if you try
    to do anything with it except throw it away.

    Unfortunately, the existence of such a value would
    cause headaches for things like debuggers that need
    to be able to deal with anything at all without
    blowing up.
    Gregory Ewing, Jul 13, 2010
  16. dhruvbird

    Aahz Guest

    [Original not available on my swerver, responding here]

    Because I love to repeat myself:

    "...string iteration isn't about treating strings as sequences of strings,
    it's about treating strings as sequences of characters. The fact that
    characters are also strings is the reason we have problems, but characters
    are strings for other good reasons." --Aahz

    Do you really want to give up Python's lovely string-slicing
    Aahz, Jul 14, 2010
  17. dhruvbird

    John Nagle Guest

    Treating that case as an error would be consistent with the
    way attribute access works in Python. In Python, attempting
    to access a nonexistent attribute raises an exception. In
    Javascript, that returns a null. Javascript makes no
    distinction between "null" and "nonexistent", but Python

    It's un-Pythonic and inconsistent that functions which
    return nothing are considered to return a None object.

    John Nagle
    John Nagle, Jul 16, 2010
    1. Advertisements

Ask a Question

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

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.