¿Cuál es la diferencia entre listas y tuplas?

https://stackoverflow.com/questions/626759

06-07-2019
|

Pregunta

¿Cuál es la diferencia?

¿Cuáles son las ventajas / desventajas de las tuplas / listas?

Solución

Además de que las tuplas son inmutables, también existe una distinción semántica que debería guiar su uso. Las tuplas son estructuras de datos heterogéneas (es decir, sus entradas tienen significados diferentes), mientras que las listas son secuencias homogéneas. Las tuplas tienen estructura, las listas tienen orden.

El uso de esta distinción hace que el código sea más explícito y comprensible.

Un ejemplo sería pares de páginas y números de línea para hacer referencia a ubicaciones en un libro, por ejemplo:

my_location = (42, 11)  # page number, line number

Luego puede usar esto como clave en un diccionario para almacenar notas en ubicaciones. Una lista, por otro lado, podría usarse para almacenar múltiples ubicaciones. Naturalmente, es posible que desee agregar o eliminar ubicaciones de la lista, por lo que tiene sentido que las listas sean mutables. Por otro lado, no tiene sentido agregar o eliminar elementos de una ubicación existente, por lo tanto, las tuplas son inmutables.

Puede haber situaciones en las que desee cambiar elementos dentro de una tupla de ubicación existente, por ejemplo, al recorrer las líneas de una página. Pero la inmutabilidad de la tupla te obliga a crear una nueva tupla de ubicación para cada nuevo valor. Esto parece inconveniente a primera vista, pero el uso de datos inmutables como este es una piedra angular de los tipos de valor y las técnicas de programación funcional, que pueden tener ventajas sustanciales.

Hay algunos artículos interesantes sobre este tema, p. " Las tuplas de Python no son solo listas constantes " o " Comprensión de tuplas frente a listas en Python " . La documentación oficial de Python también menciona esto

" Las tuplas son inmutables y generalmente contienen una secuencia heterogénea ... " ;.

En un lenguaje de tipo estático como Haskell , los valores en una tupla generalmente tienen diferentes tipos y la longitud de la tupla debe ser fija. En una lista, todos los valores tienen el mismo tipo y la longitud no es fija. Entonces la diferencia es muy obvia.

Finalmente está el namedtuple en Python, que hace sentido porque una tupla ya se supone que tiene estructura. Esto subraya la idea de que las tuplas son una alternativa ligera a las clases e instancias.

Otros consejos

Diferencia entre lista y tupla

Literal
```
someTuple = (1,2)
someList  = [1,2] 
```
Tamaño
```
a = tuple(range(1000))
b = list(range(1000))

a.__sizeof__() # 8024
b.__sizeof__() # 9088
```
Debido al tamaño más pequeño de una operación de tupla, se vuelve un poco más rápido, pero no hay mucho que mencionar hasta que tenga una gran cantidad de elementos.

Operaciones permitidas

b    = [1,2]   
b[0] = 3       # [3, 2]

a    = (1,2)
a[0] = 3       # Error

Eso también significa que no puede eliminar un elemento u ordenar una tupla. Sin embargo, puede agregar un nuevo elemento tanto a la lista como a la tupla con la única diferencia de que cambiará la identificación de la tupla agregando elemento

a     = (1,2)
b     = [1,2]  

id(a)          # 140230916716520
id(b)          # 748527696

a   += (3,)    # (1, 2, 3)
b   += [3]     # [1, 2, 3]

id(a)          # 140230916878160
id(b)          # 748527696

Usuario

Como una lista es mutable, no se puede usar como clave en un diccionario, mientras que se puede usar una tupla.
```
a    = (1,2)
b    = [1,2] 

c = {a: 1}     # OK
c = {b: 1}     # Error
```
Hashable Tuple es hashable mientras que la lista no lo es. Las funciones hash devuelven el valor hash del objeto, si tiene uno.

Si saliste a caminar, podrías anotar tus coordenadas en cualquier momento en una tupla (x, y) .

Si desea registrar su viaje, puede agregar su ubicación cada pocos segundos a una lista.

Pero no puedes hacerlo al revés.

La diferencia clave es que las tuplas son inmutables. Esto significa que no puede cambiar los valores en una tupla una vez que lo haya creado.

Entonces, si necesita cambiar los valores, use una Lista.

Beneficios para las tuplas:

Ligera mejora del rendimiento.
Como una tupla es inmutable, puede usarse como clave en un diccionario.
Si no puede cambiarlo, tampoco lo puede hacer nadie más, lo que quiere decir que no necesita preocuparse de que ninguna función de API, etc. cambie su tupla sin que se lo pidan.

Las listas son mutables; las tuplas no lo son.

De docs.python.org/2/tutorial/datastructures.html

Las tuplas son inmutables y generalmente contienen una secuencia heterogénea de elementos a los que se accede desempacando (ver más adelante en esta sección) o indexación (o incluso por atributo en el caso de namedtuples). Liza son mutables, y sus elementos suelen ser homogéneos y son se accede iterando sobre la lista.

Es se ha mencionado que la diferencia es en gran medida semántica: la gente espera una tupla y una lista para representar información diferente. Pero esto va más allá de una guía; algunas bibliotecas en realidad se comportan de manera diferente en función de lo que se pasan. Tome NumPy por ejemplo (copiado de otra publicación donde solicito más ejemplos):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

El punto es que, aunque NumPy puede no ser parte de la biblioteca estándar, es una biblioteca Python major , y dentro de las listas y tuplas de NumPy hay cosas completamente diferentes.

Las listas son para bucles, las tuplas son para estructuras, es decir, "% s% s " % tupla .

Las listas suelen ser homogéneas, las tuplas suelen ser heterogéneas.

Las listas son de longitud variable, las tuplas son de longitud fija.

Este es un ejemplo de listas de Python:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

Este es un ejemplo de tupla de Python:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

Las listas y tuplas de Python son similares en que ambas son colecciones ordenadas de valores. Además de la pequeña diferencia de que las listas se crean con corchetes " [..., ...] " y tuplas usando paréntesis '' (..., ...) '', el núcleo técnico '' codificado en sintaxis Python '' La diferencia entre ellos es que los elementos de una tupla en particular son inmutables, mientras que las listas son mutables (... así que solo las tuplas son hashable y pueden usarse como claves de diccionario / hash) Esto da lugar a diferencias en cómo se pueden o no se pueden usar (aplicadas a priori por la sintaxis) y diferencias en cómo las personas eligen usarlas (alentadas como 'mejores prácticas', a posteriori, esto es lo que inteligente los programadores lo hacen). La principal diferencia a posteriori en la diferenciación cuando se usan tuplas versus cuando se usan listas radica en lo que significado dan las personas al orden de los elementos.

Para las tuplas, 'orden' no significa más que solo una 'estructura' específica para contener información. Los valores que se encuentran en el primer campo se pueden cambiar fácilmente al segundo campo, ya que cada uno proporciona valores en dos dimensiones o escalas diferentes. Proporcionan respuestas a diferentes tipos de preguntas y generalmente tienen la forma: para un objeto / sujeto determinado, ¿cuáles son sus atributos? El objeto / sujeto permanece constante, los atributos difieren.

Para listas, 'orden' significa una secuencia o direccionalidad. El segundo elemento DEBE venir después del primer elemento porque está posicionado en el segundo lugar según una escala o dimensión particular y común. Los elementos se toman como un todo y en su mayoría proporcionan respuestas a una sola pregunta, típicamente de la forma, para un atributo dado, ¿cómo se comparan estos objetos / sujetos? El atributo permanece constante, el objeto / sujeto difiere .

Hay innumerables ejemplos de personas en la cultura popular y programadores que no se ajustan a estas diferencias y hay innumerables personas que podrían usar un tenedor de ensalada como plato principal. Al final del día, está bien y ambos generalmente pueden hacer el trabajo.

Para resumir algunos de los detalles más finos

Similitudes :

Duplicados : tanto las tuplas como las listas permiten duplicados
Indexación, selección y & amp; Rebanar : tanto las tuplas como las listas indexan utilizando valores enteros que se encuentran entre paréntesis. Entonces, si desea los primeros 3 valores de una lista o tupla dada, la sintaxis sería la misma:
```
>>> my_list[0:3]
[0,1,2]
>>> my_tuple[0:3]
[a,b,c]
```
Comparación y amp; Ordenar : dos tuplas o dos listas se comparan por su primer elemento, y si hay un empate, por el segundo elemento, y así sucesivamente. No se presta más atención a los elementos posteriores después de que los elementos anteriores muestran una diferencia.
```
>>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
True
>>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
True
```

Diferencias: - A priori, por definición

Sintaxis - Las listas usan [], las tuplas usan ()

Mutabilidad - Los elementos en una lista dada son mutables, los elementos en una tupla dada NO son mutables.

# Lists are mutable:
>>> top_rock_list
['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
>>> top_rock_list[1]
'Kashmir'
>>> top_rock_list[1] = "Stairway to Heaven"
>>> top_rock_list
['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']

# Tuples are NOT mutable:       
>>> celebrity_tuple
('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
>>> celebrity_tuple[5]
'Dead'
>>> celebrity_tuple[5]="Alive"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Tablas hash (Diccionarios) - Como las tablas hash (diccionarios) requieren que sus claves sean hashables y, por lo tanto, inmutables, solo las tuplas pueden actuar como claves de diccionario, no como listas.

#Lists CAN'T act as keys for hashtables(dictionaries)
>>> my_dict = {[a,b,c]:"some value"}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

#Tuples CAN act as keys for hashtables(dictionaries)
>>> my_dict = {("John","Wayne"): 90210}
>>> my_dict
{('John', 'Wayne'): 90210}

Diferencias - A posteriori, en uso

Homo versus heterogeneidad de elementos: en general, los objetos de lista son homogéneos y los objetos de tupla son heterogéneos. Es decir, las listas se usan para objetos / temas del mismo tipo (como todos los candidatos presidenciales, o todas las canciones, o todos los corredores), mientras que aunque no es forzado por ellos, mientras que las tuplas son más para objetos heterogéneos.
Bucle contra estructuras: aunque ambos permiten el bucle (para x en my_list ...), solo tiene sentido hacerlo para una lista. Las tuplas son más apropiadas para estructurar y presentar información (% s% s que reside en% s es un% sy actualmente% s% (" John ", " Wayne ", 90210, " Actor ", " Dead ") )

Los valores de list se pueden cambiar en cualquier momento, pero los valores de tuplas no se pueden cambiar.

Las ventajas y desventajas dependen del uso. Si tiene esos datos que nunca quiere cambiar, entonces debería usar tupla, de lo contrario, la lista es la mejor opción.

Las listas están destinadas a ser secuencias homogéneas, mientras que las tuplas son estructuras de datos heterogéneas.

Diferencia entre lista y tupla

Las tuplas y las listas son tipos de secuencia aparentemente similares en Python.

Sintaxis literal

Utilizamos paréntesis ( ) para construir tuplas y corchetes [] para obtener una nueva lista. Además, podemos usar llamadas del tipo apropiado para obtener la estructura requerida: tupla o lista.
```
someTuple = (4,6)
someList  = [2,6] 
```
Mutabilidad

Las tuplas son inmutables, mientras que las listas son mutables. Este punto es la base para los siguientes.
Uso de memoria

Debido a la mutabilidad, necesita más memoria para las listas y menos memoria para las tuplas.
Ampliación

Puede agregar un nuevo elemento tanto a las tuplas como a las listas con la única diferencia de que se cambiará la identificación de la tupla (es decir, tendremos un nuevo objeto).
Hashing

Las tuplas son hashable y las listas no. Significa que puede usar una tupla como clave en un diccionario. La lista no se puede usar como clave en un diccionario, mientras que se puede usar una tupla
```
tup      = (1,2)
list_    = [1,2] 

c = {tup   : 1}     # ok
c = {list_ : 1}     # error
```
Semántica

Este punto trata más sobre las mejores prácticas. Debe usar tuplas como estructuras de datos heterogéneas, mientras que las listas son secuencias homogéneas.

Como la gente ya ha respondido aquí que tuples son inmutables mientras que lists son mutables, pero hay un aspecto importante del uso de tuplas que debemos recordar

Si la tuple contiene una list o un dictionary en su interior, pueden cambiarse incluso si la tuple en sí mismo es inmutable.

Por ejemplo, supongamos que tenemos una tupla que contiene una lista y un diccionario como

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

podemos cambiar el contenido de la lista como

my_tuple[3][0] = 400
my_tuple[3][1] = 500

que hace que las nuevas tuplas se vean como

(10, 20, 30, [400, 500], {'a': 10})

también podemos cambiar el diccionario dentro de la tupla como

my_tuple[4]['a'] = 500

que hará que la tupla general se vea

(10, 20, 30, [400, 500], {'a': 500})

Esto sucede porque list y dictionary son los objetos y estos objetos no cambian, sino el contenido al que apunta.

Entonces la tupla permanece inmutable sin ninguna excepción

El PEP 484 - Sugerencias de tipo dice que los tipos de elementos de una tuple se pueden escribir individualmente; para que pueda decir Tuple [str, int, float] ; pero una list , con la clase de escritura List solo puede tomar un parámetro de tipo: List [str] , lo que sugiere que la diferencia de los 2 realmente es que el primero es heterogéneo, mientras que el segundo es intrínsecamente homogéneo.

Además, la biblioteca estándar usa principalmente la tupla como un valor de retorno de tales funciones estándar donde la C devolvería una struct .

Una cita de dirección de la documentación en 5.3. Tuplas y secuencias :

Aunque las tuplas pueden parecer similares a las listas, a menudo se usan en diferentes situaciones y para diferentes propósitos. Las tuplas son inmutables y generalmente contienen una secuencia heterogénea de elementos a los que se accede mediante desempaquetado (ver más adelante en esta sección) o indexación (o incluso por atributo en el caso de namedtuples). Las listas son mutables , y sus elementos son generalmente homogéneos y se accede a ellos iterando sobre la lista.

En primer lugar, ambos son objetos no escalares (también conocidos como objetos compuestos) en Python.

Tuplas, secuencia ordenada de elementos (que puede contener cualquier objeto sin problemas de alias)
- Inmutable (tupla, int, float, str)
- Concatenación usando + (se creará una nueva tupla, por supuesto)
- Indexación
- Cortando
- Singleton (3,) # - > (3) en lugar de (3) # - > 3
Lista (matriz en otros idiomas), secuencia ordenada de valores
- Mutable
- Singleton [3font>
- Clonación new_array = origin_array [:]
- Comprensión de la lista [x ** 2 para x en el rango (1,7)] le ofrece [1,4,9,16,25,36] (No legible)

Usar la lista también puede causar un error de alias (dos rutas distintas apuntando al mismo objeto).

Las listas son mutables y las tuplas son inmutables. Solo considere este ejemplo.

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

Ahora cambie los valores de índice de la lista y la tupla.

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

Por lo tanto, demostró que el siguiente código no es válido con la tupla, porque intentamos actualizar una tupla, que no está permitida.

La lista es mutable y las tuplas son inmutables. La principal diferencia entre mutable e inmutable es el uso de memoria cuando intenta agregar un elemento.

Cuando crea una variable, se asigna algo de memoria fija a la variable. Si es una lista, se asigna más memoria de la que realmente se usa. P.ej. si la asignación de memoria actual es de 100 bytes, cuando desee agregar el byte 101, tal vez se asignarán otros 100 bytes (en total 200 bytes en este caso).

Sin embargo, si sabe que no agrega elementos nuevos con frecuencia, debe usar tuplas. Tuples asigna exactamente el tamaño de la memoria necesaria y, por lo tanto, ahorra memoria, especialmente cuando utiliza grandes bloques de memoria.

La diferencia básica que he encontrado es que las listas son mutables donde las tuplas son inmutables. Las tuplas son buenas para los cálculos en los que no es necesario cambiarlas.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow