tuples vs lists

Discussion in 'Python' started by Ivan Voras, Sep 16, 2003.

  1. Ivan Voras

    Ivan Voras Guest

    Are there any performance/size differences between using tuples and using
    lists?


    --
    --
    Every sufficiently advanced magic is indistinguishable from technology
    - Arthur C Anticlarke
    Ivan Voras, Sep 16, 2003
    #1
    1. Advertising

  2. On Tue, 16 Sep 2003 18:51:38 +0200, rumours say that "Ivan Voras"
    <> might have written:

    >Are there any performance/size differences between using tuples and using
    >lists?


    Assuming you know that tuples are immutable and lists are mutable (they
    can grow, shrink, get sorted etc), tuples consume less memory (lists
    allocate more memory than your list needs, to avoid reallocating space
    on every append/insert). This accounts for size.

    Performance-wise, I don't think there is a noticable difference between
    indexing lists and tuples (but you can always use the timeit module).

    IIRC Guido has stated that tuples are not intended to be immutable
    lists, but a kind of handy unnamed structs (a la C) or records (a la
    Pascal).

    Keep in mind also that lists have useful methods (like count and index)
    that tuples don't. This about functionality.
    --
    TZOTZIOY, I speak England very best,
    Microsoft Security Alert: the Matrix began as open source.
    Christos TZOTZIOY Georgiou, Sep 16, 2003
    #2
    1. Advertising

  3. "Ivan Voras" <> writes:

    > Are there any performance/size differences between using tuples and using
    > lists?
    >


    I made the timings of creation/unpacking/indexing for short
    tuples/lists and loops for longer tuples/lists. In Python 2.1, 2.2 and
    2.3 creation and unpacking of short tuples is 2x/3x faster which is
    what you may expact knowing they are fixed size, but indexing is
    slightly slower for tuples which I didn't expect. Whether you loop
    over tuple or list does matter only for 2.2 (tuples are 30% slower).
    Where there is 2x difference or 30% difference it is reproducable in
    subsequent runs of of the script given below.


    lupan@psi:[~/dyplom/src]$ sh tuple-vs-list.sh
    2.1
    creation
    tuple 1000000 loops, best of 3: 0.442 usec per loop
    list 1000000 loops, best of 3: 1.1 usec per loop
    unpacking
    tuple 1000000 loops, best of 3: 0.58 usec per loop
    list 1000000 loops, best of 3: 1.23 usec per loop
    indexing
    tuple 1000000 loops, best of 3: 0.369 usec per loop
    list 1000000 loops, best of 3: 0.339 usec per loop
    looping
    tuple 10000 loops, best of 3: 170 usec per loop
    list 10000 loops, best of 3: 173 usec per loop
    2.2
    creation
    tuple 1000000 loops, best of 3: 0.341 usec per loop
    list 1000000 loops, best of 3: 0.96 usec per loop
    unpacking
    tuple 1000000 loops, best of 3: 0.457 usec per loop
    list 1000000 loops, best of 3: 1.09 usec per loop
    indexing
    tuple 1000000 loops, best of 3: 0.286 usec per loop
    list 1000000 loops, best of 3: 0.264 usec per loop
    looping
    tuple 10000 loops, best of 3: 149 usec per loop
    list 10000 loops, best of 3: 114 usec per loop
    2.3
    creation
    tuple 1000000 loops, best of 3: 0.286 usec per loop
    list 1000000 loops, best of 3: 0.672 usec per loop
    unpacking
    tuple 1000000 loops, best of 3: 0.387 usec per loop
    list 1000000 loops, best of 3: 0.761 usec per loop
    indexing
    tuple 1000000 loops, best of 3: 0.204 usec per loop
    list 1000000 loops, best of 3: 0.19 usec per loop
    looping
    tuple 10000 loops, best of 3: 74.6 usec per loop
    list 10000 loops, best of 3: 76.3 usec per loop


    # tuple-vs-list.py
    TIMEIT=/usr/lib/python2.3/timeit.py
    # they are big as I have fast machine
    N=1000000
    N2=10000

    for ver in 2.1 2.2 2.3; do
    echo $ver
    echo -ne 'creation\ntuple '
    python$ver -O $TIMEIT -n $N '(1,2,3)'
    echo -n 'list '
    python$ver -O $TIMEIT -n $N '[1,2,3]'
    echo -ne 'unpacking\ntuple '
    python$ver -O $TIMEIT -n $N 'a,b,c = (1,2,3)'
    echo -n 'list '
    python$ver -O $TIMEIT -n $N 'a,b,c = [1,2,3]'
    echo -ne 'indexing\ntuple '
    python$ver -O $TIMEIT -n $N -s 'x = (1,2,3)' 'x[1]'
    echo -n 'list '
    python$ver -O $TIMEIT -n $N -s 'x = [1,2,3]' 'x[1]'
    echo -ne 'looping\ntuple '
    python$ver -O $TIMEIT -n $N2 -s 'r = tuple(range(1000))' 'for x in r: pass'
    echo -n 'list '
    python$ver -O $TIMEIT -n $N2 -s 'r = range(1000)' 'for x in r: pass'
    done

    --

    =*= Lukasz Pankowski =*=
    Lukasz Pankowski, Sep 16, 2003
    #3
  4. Ivan Voras

    Ivan Voras Guest

    Ok, I gather touples should be smaller & faster as I thought :)


    --
    --
    Every sufficiently advanced magic is indistinguishable from technology
    - Arthur C Anticlarke
    Ivan Voras, Sep 16, 2003
    #4
  5. Ivan Voras

    Ivan Voras Guest

    Lukasz Pankowski wrote:

    > subsequent runs of of the script given below.


    Thank you, this is exactly what I was looking for.


    --
    --
    Every sufficiently advanced magic is indistinguishable from technology
    - Arthur C Anticlarke
    Ivan Voras, Sep 16, 2003
    #5
  6. Ivan Voras

    Peter Hansen Guest

    Ivan Voras wrote:
    >
    > Ok, I gather touples should be smaller & faster as I thought :)


    Don't make a decision based on performance. Use tuples if you
    require the immutability, or if you want to follow Guido's "advice" (?)
    to treat them as simple unnamed structs.

    Use lists any time you want lists of stuff, even if you think you
    might benefit by the supposedly higher performance of a tuple.

    Anyone reading your code will likely be much happier, and you won't
    find yourself getting caught in a bind because you've used an
    immutable tuples where you really should have used a list.

    -Peter
    Peter Hansen, Sep 16, 2003
    #6
  7. Ivan Voras

    Ivan Voras Guest

    Peter Hansen wrote:
    > Ivan Voras wrote:
    >>
    >> Ok, I gather touples should be smaller & faster as I thought :)

    >
    > Don't make a decision based on performance. Use tuples if you
    > require the immutability, or if you want to follow Guido's "advice"
    > (?) to treat them as simple unnamed structs.


    I know that. I was just wandering if they also behave faster. Lists are only
    interesting to me in case I need mutability.


    --
    --
    Every sufficiently advanced magic is indistinguishable from technology
    - Arthur C Anticlarke
    Ivan Voras, Sep 16, 2003
    #7
  8. Ivan Voras

    Peter Hansen Guest

    Ivan Voras wrote:
    >
    > Peter Hansen wrote:
    > > Ivan Voras wrote:
    > >>
    > >> Ok, I gather touples should be smaller & faster as I thought :)

    > >
    > > Don't make a decision based on performance. Use tuples if you
    > > require the immutability, or if you want to follow Guido's "advice"
    > > (?) to treat them as simple unnamed structs.

    >
    > I know that. I was just wandering if they also behave faster. Lists are only
    > interesting to me in case I need mutability.


    I'd suggest you have that backwards. Lists should _always_ be interesting
    to you. Tuples should be interesting only in the case where you need
    *immutability*.

    -Peter
    Peter Hansen, Sep 16, 2003
    #8
  9. Ivan Voras

    Ivan Voras Guest

    Peter Hansen wrote:
    > Ivan Voras wrote:


    >> I know that. I was just wandering if they also behave faster. Lists
    >> are only interesting to me in case I need mutability.

    >
    > I'd suggest you have that backwards. Lists should _always_ be
    > interesting
    > to you. Tuples should be interesting only in the case where you need
    > *immutability*.


    I disagree. :) I would always use tuples except when I explicitely need
    mutability. That doesn't meen that I would intentionaly (badly) restructure
    code just to use tuples, only that in many cases my structures don't need to
    be modified.

    --
    --
    Every sufficiently advanced magic is indistinguishable from technology
    - Arthur C Anticlarke
    Ivan Voras, Sep 17, 2003
    #9
  10. Ivan Voras

    Peter Hansen Guest

    Ivan Voras wrote:
    >
    > Peter Hansen wrote:
    > > Ivan Voras wrote:

    >
    > >> I know that. I was just wandering if they also behave faster. Lists
    > >> are only interesting to me in case I need mutability.

    > >
    > > I'd suggest you have that backwards. Lists should _always_ be
    > > interesting
    > > to you. Tuples should be interesting only in the case where you need
    > > *immutability*.

    >
    > I disagree. :) I would always use tuples except when I explicitely need
    > mutability. That doesn't meen that I would intentionaly (badly) restructure
    > code just to use tuples, only that in many cases my structures don't need to
    > be modified.


    That's your personal choice, I suppose, and I won't try any more to dissuade
    you any more except to point out that most Python programmers, I believe, do
    not see tuples as their first choice, but use them only in certain special cases.

    I could be wrong. It happens. ;-)

    -Peter
    Peter Hansen, Sep 17, 2003
    #10
  11. Ivan Voras

    Donn Cave Guest

    In article <>,
    Peter Hansen <> wrote:

    > Ivan Voras wrote:
    > >
    > > Peter Hansen wrote:
    > > > Ivan Voras wrote:

    > >
    > > >> I know that. I was just wandering if they also behave faster. Lists
    > > >> are only interesting to me in case I need mutability.
    > > >
    > > > I'd suggest you have that backwards. Lists should _always_ be
    > > > interesting
    > > > to you. Tuples should be interesting only in the case where you need
    > > > *immutability*.

    > >
    > > I disagree. :) I would always use tuples except when I explicitely need
    > > mutability. That doesn't meen that I would intentionaly (badly) restructure
    > > code just to use tuples, only that in many cases my structures don't need
    > > to
    > > be modified.

    >
    > That's your personal choice, I suppose, and I won't try any more to dissuade
    > you any more except to point out that most Python programmers, I believe, do
    > not see tuples as their first choice, but use them only in certain special
    > cases.


    These two positions may be more similar than different. The
    notion of a sequence that never needs to be modified is certainly
    a special case, and if we were looking at the actual applications
    for these sequences we might all agree that they're more or less
    appropriately cast as tuples. One argues about principles like
    this at some risk of silliness.

    The thing that eventually pushed me towards lists and away from
    tuples, for sequences of like items, is the notation. It may
    seem like a awfully prosaic consideration, but lists are usually
    easier to mentally parse out of an expression, because the tuple's
    parentheses are shared by other syntactical groupings. And then
    there's the awkward notation for a single-element tuple. Lists
    are easier to write and easier to read.

    Donn Cave,
    Donn Cave, Sep 17, 2003
    #11
    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. Daniel Nogradi
    Replies:
    3
    Views:
    349
    Dennis Lee Bieber
    Nov 10, 2006
  2. Replies:
    5
    Views:
    552
    Thomas J. Gritzan
    Oct 6, 2006
  3. tuples within tuples

    , Oct 26, 2007, in forum: Python
    Replies:
    12
    Views:
    572
    Dennis Lee Bieber
    Oct 27, 2007
  4. xera121
    Replies:
    8
    Views:
    721
    lolmc
    Sep 30, 2009
  5. Jon Reyes
    Replies:
    18
    Views:
    228
    Mitya Sirenef
    Feb 19, 2013
Loading...

Share This Page