The main difference is that tuples are immutable (they cannot be modified) and lists are not. This immutability makes it possible to apply a hash function to it.

Another very important issue is that tuples are more efficient than lists . So unless you need mutability in your data structure, it's more convenient to use a tuple instead of a list. Let's see why in detail.

1. Compilation

Python recognizes and evaluates tuples as constant expressions at compile time, rather than at execution, this is known as Constant Folding . disassemblyI can demonstrate this to you with the python module

from dis import dis

#Vemos lo que sucede en la compilación
print("Tupla al compilar:\n")
print(dis(compile('(1,2,3, "a")', 'string', 'eval')))
print("\nLista al compilar:\n")
print(dis(compile('[1,2,3, "a"]', 'string', 'eval')))

Departure

Tupla al compilar:

  1           0 LOAD_CONST               0 ((1, 2, 3, 'a'))
              2 RETURN_VALUE

Lista al compilar:

  1           0 LOAD_CONST               0 (1)
              2 LOAD_CONST               1 (2)
              4 LOAD_CONST               2 (3)
              6 LOAD_CONST               3 ('a')
              8 BUILD_LIST               4
             10 RETURN_VALUE

Effectively, Python has evaluated the tuple as a constant expression and returned it, however in the list, it has had to evaluate each element of the list as a constant, then build the list and finally return it. This of course has a cost of time let's see

from timeit import timeit

print("Tupla: ", timeit("(1,2,3,4,5,6,7,8,9)", number=15_000_000))
print("Lista: ", timeit("[1,2,3,4,5,6,7,8,9]", number=15_000_000))

Departure:

Tupla:  0.09676512900114176
Lista:  0.9273542539995105

A tuple is about 10 times faster

Caveat

This behavior happens because we have created the tuple with immutable elements, if only one of the elements were mutable , the tuple would be evaluated by Python in the same way as the list and the times would be similar.

2. Copy

When you want to copy a list, Python allocates memory again to create a new list. In the case of tuples, due to their immutability, they are not copied, just a shallow copy reference is created . Let's prove it:

lista_1 = [1,2,3,4,5]
lista_2 = list(lista_1)
print("Lista copiadas: ", hex(id(lista_1)), hex(id(lista_2)))

tupla_1 = (1,2,3,4,5)
tupla_2 = tuple(tupla_1)
print("Tupla copiada:  ", hex(id(tupla_1)), hex(id(tupla_2)))

Departure:

Lista copiadas:  0x7f9cc80bb960 0x7f9cc17a9500
Tupla copiada:   0x7f9cc8101bf0 0x7f9cc8101bf0

When copying the list they are in different memory locations , however the tuple is in the same memory location.

This also has an impact on execution times :

from timeit import timeit

timeit("tuple((1,2,3,4,5))", number=5_000_000)
timeit("list((1,2,3,4,5))", number=5_000_000)

Departure

Lista copiadas:  0.5346233499985829
Tupla copiadas:  0.3198905820026994

Note that I have copied the list from a tuple , to avoid including the extra creation time that a list has (what we saw in point 1) and so that we focus exclusively on the copy and it is a fair comparison .

3. Storage

The storage for a tuple is exact, that is, Python reserves the space just and necessary to store a tuple, since it is immutable. In lists it is different, Python reserves more space than necessary for a list, which is known as Overallocation and pre-allocate with the aim of optimizing the entry of elements in said list. If you want to know more, you can see Dynamic array . Let's see this:

print("Almacenamiento Tupla")
t = tuple()
previa = sys.getsizeof(t)
for n in range(10):
    tupla = tuple(range(n + 1))
    tamano_tupla = sys.getsizeof(tupla)
    diferencia, previa = tamano_tupla - previa, tamano_tupla
    print(f"{n+1} Espacio reservado: {tamano_tupla}, diferencia={diferencia}")

print("\nAlmacenamiento Lista")
t = list()
previa = sys.getsizeof(t)
for n in range(10):
    lista = list(range(n + 1))
    tamano_lista = sys.getsizeof(lista)
    diferencia, previa = tamano_lista - previa, tamano_lista
    print(f"{n+1} Espacio reservado: {tamano_lista}, diferencia={diferencia}")

Departure:

Almacenamiento Tupla
1 Espacio reservado: 64, diferencia=8
2 Espacio reservado: 72, diferencia=8
3 Espacio reservado: 80, diferencia=8
4 Espacio reservado: 88, diferencia=8
5 Espacio reservado: 96, diferencia=8
6 Espacio reservado: 104, diferencia=8
7 Espacio reservado: 112, diferencia=8
8 Espacio reservado: 120, diferencia=8
9 Espacio reservado: 128, diferencia=8
10 Espacio reservado: 136, diferencia=8

Almacenamiento Lista
1 Espacio reservado: 104, diferencia=32
2 Espacio reservado: 112, diferencia=8
3 Espacio reservado: 120, diferencia=8
4 Espacio reservado: 128, diferencia=8
5 Espacio reservado: 136, diferencia=8
6 Espacio reservado: 144, diferencia=8
7 Espacio reservado: 152, diferencia=8
8 Espacio reservado: 168, diferencia=16
9 Espacio reservado: 200, diferencia=32
10 Espacio reservado: 208, diferencia=8

Indeed, the tuple always reserves 8 bytes and occupies just enough space for the elements, however the list occupies more space and makes different memory reservations.

This is because, when reserving more memory than necessary, Python uses an algorithm that, looking at the size of the list, calculates how much more space it is going to reserve. Thus if, for example, we use .append()and the list grows, we avoid having to re-reserve space to enter the element, since said space is previously reserved.

Bonuses

Another issue that is associated, but that can be overlooked, is that since it is immutable, the order is maintained, that is, in tuples , the order in which the elements come has meaning.

The only difference is that tuples are immutable and lists are not.

This distinction may be important for two reasons:

• You may want to have a "group" of values ​​to pass as a parameter to a function, but you want to be sure that the function will not modify any of the values ​​in the group. Since in python everything is references, once the function receives the reference to the "group" (a list, an object) it can change its values. The only way around it is to make that group a tuple. In fact I suggest you also look into the ones namedtuplesthat are a mechanism to create something that looks like an object (with its named fields) but is actually implemented internally as a tuple, so that it is immutable.

  This use case is more important than it seems at first glance. I have gone crazy debugging code in which, in the end, the bug was caused because a data list did not have the data that I had loaded into it but others, because one of the multiple functions that received it as a parameter modified it. In the end I solved it by changing all my lists to tuples and seeing where the program broke when a function tried to modify the data.

  Thanks to the tuples and namedtuplesI was able to refactor the program so that all the functions are pure (they do not cause secondary effects on variables that do not belong to the function). This is much easier to debug and maintain.

• Almost more importantly, being immutable they are also hashable . That is, the function can be applied to them hash()and the result will always be the same. In a list obviously the hash could change if the elements of the list have changed.

  Hashing data is important because only hashing data can be stored in a set ( set()) or can be used as dictionary keys (because these data structures are basically hash tables).

  So if you find yourself needing to use a list as a key in a dictionary, you'll find that you can't. Convert it to a tuple and you're good to go.

ACCORDING to resourcespython.com .

A list is not the same as a tuple, both are an ordered set of values, where the latter can be any object: a number, a string, a function, a class, an instance, etc.

The difference is that lists have a series of additional functions that allow extensive handling of the values ​​they contain. Based on this definition, it can be said that lists are dynamic, while tuples are static.