{"id":1148,"date":"2020-11-15T05:31:34","date_gmt":"2020-11-15T05:31:34","guid":{"rendered":"https:\/\/www.pythontutorial.net\/?page_id=1148"},"modified":"2025-03-27T14:45:41","modified_gmt":"2025-03-27T14:45:41","slug":"python-tuple-vs-list","status":"publish","type":"page","link":"https:\/\/www.pythontutorial.net\/advanced-python\/python-tuple-vs-list\/","title":{"rendered":"Python Tuple vs. List"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn the difference between tuple and list.<\/p>\n\n\n\n

Both tuple<\/a> and list<\/a> are sequence types<\/a>. However, they have some main differences.<\/p>\n\n\n\n

A tuple is immutable while a list is mutable #<\/a><\/h2>\n\n\n\n

The following example defines a list and modifies the first element:<\/p>\n\n\n

fruits = ['apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>]\nfruits[0<\/span>] = 'strawberry'<\/span>\n\nprint(fruits)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
['strawberry', 'orange', 'banana']<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
The output indicate that you can mutable a list. However, you cannot mutable a tuple. The following will result in an error:<\/p>\n\n\n
fruits = ('apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>)\nfruits[0<\/span>] = 'strawberry'<\/span>    <\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Error:<\/p>\n\n\n
TypeError<\/span>: 'tuple'<\/span> object does not support item assignment<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Python doesn’t allow you to change the element of a tuple but let you can reference a new tuple. For example:<\/p>\n\n\n
fruits = ('apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>)\nfruits = ('strawberry'<\/span>, 'orange'<\/span>, 'banana'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, Python creates a new tuple and bounds the fruits<\/code> variable to the newly created tuple. <\/p>\n\n\n\n
If you examine the memory addresses of the tuple objects, you’ll see that the fruits<\/code> variable references a different memory address after the assignment:<\/p>\n\n\n
fruits = ('apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>)\nprint(hex(id(fruits)))\n\nfruits = ('strawberry'<\/span>, 'orange'<\/span>, 'banana'<\/span>)\nprint(hex(id(fruits)))\n<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
0x1c018286e00\n0x1c018286e40<\/code><\/span><\/pre>\n\n\n
The storage efficiency of a tuple is greater than a list #<\/a><\/h2>\n\n\n\n
A list is mutable<\/a>. It means that you can add more elements to it. Because of this, Python needs to allocate more memory than needed to the list. This is called over-allocating. The over-allocation improves performance when a list is expanded.<\/p>\n\n\n\n
Meanwhile, a tuple is immutable therefore its element count is fixed. So Python just needs to allocate enough memory to store the initial elements.<\/p>\n\n\n\n
As a result, the storage efficiency of a tuple is greater than a list.<\/p>\n\n\n\n
To get the size of an object, you use the getsizeof<\/code> function from the sys<\/code> module. <\/p>\n\n\n\n
The following shows the sizes of a list and a tuple that stores the same elements:<\/p>\n\n\n
from<\/span> sys import<\/span> getsizeof\n\nfruits = ['apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>]\nprint(f'The size of the list is {getsizeof(fruits)}<\/span> bytes.'<\/span>)\n\nfruits = ('strawberry'<\/span>, 'orange'<\/span>, 'banana'<\/span>)\nprint(f'The size of the tuple is {getsizeof(fruits)}<\/span> bytes.'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
The size of the list<\/span> is 80<\/span> bytes.\nThe size of the tuple is 64<\/span> bytes.<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Copying a tuple is faster than a list #<\/a><\/h2>\n\n\n\n
When you copy a list, Python creates a new list. The following example illustrates copying a list to another:<\/p>\n\n\n
fruit_list = ['apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>]\nfruit_list2 = list(fruit_list)\n\n\nprint(id(fruit_list) == id(fruit_list2))  # False<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
However, when copying a tuple, Python just reuses an existing tuple. It doesn’t create a new tuple because tuples are immutable.<\/p>\n\n\n
fruit_tuple = ('apple'<\/span>, 'orange'<\/span>, 'banana'<\/span>)\nfruit_tuple2 = tuple(fruit_tuple)\n\nprint(id(fruit_tuple) == id(fruit_tuple2))  # True<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Therefore, copying a tuple always slightly faster than a list. <\/p>\n\n\n\n
The following compares the time that needs to copy a list and a tuple 1 million times:<\/p>\n\n\n
from<\/span> timeit import<\/span> timeit\n\ntimes = 1<\/span>_000_000\n\nt1 = timeit(\"list(['apple', 'orange', 'banana'])\"<\/span>, number=times)\nprint(f'Time to copy a list {times}<\/span> times: {t1}<\/span>'<\/span>)\n\nt2 = timeit(\"tuple(('apple', 'orange', 'banana'))\"<\/span>, number=times)\nprint(f'Time to copy a tuple {times}<\/span> times: {t2}<\/span>'<\/span>)\n\ndiff = \"{:.0%}\"<\/span>.format((t2 - t1)\/t1)\n\nprint(f'difference: {diff}<\/span>'<\/span>)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Time to copy a list 1000000 times: 0.33310000100027537\nTime to copy a tuple 1000000 times: 0.0569000010000309\ndifference: -83%<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary #<\/a><\/h2>\n\n\n\n
    \n
  • A tuple is immutable while a list is mutable.<\/li>\n\n\n\n
  • The storage efficiency of a tuple is greater than a list.<\/li>\n\n\n\n
  • Copying a tuple is slightly faster than a list.<\/li>\n\n\n\n
  • Use a tuple if you don’t intend to mutable it.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n
Try it<\/a><\/p>\n\n\n\n