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

¿Cual es la diferencia?

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

Además de que las tuplas son inmutables, también hay una distinción semántica que debe guiar su uso. Las tuplas son estructuras de datos heterogéneas (es decir, sus entradas tienen diferentes significados), 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ágina y número 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 una 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 que las tuplas son inmutables.

Puede haber situaciones en las que desee cambiar elementos dentro de una tupla de ubicación existente, por ejemplo, al iterar a través de 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 progtwigción funcional, que pueden tener ventajas sustanciales.

Hay algunos artículos interesantes sobre este tema, por ejemplo, “Las tuplas de Python no son solo listas constantes” o “Entender las tuplas contra 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 de 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. Así que la diferencia es muy obvia.

Por último, está el nombre de tupla en Python, lo que tiene 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.

Diferencia entre lista y tupla.

  1. Literal

     someTuple = (1,2) someList = [1,2] 
  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 mucho para mencionar hasta que tenga una gran cantidad de elementos.

  3. Operaciones permitidas

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

    Eso también significa que no puedes 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 el 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 
  4. Uso

    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 
  5. Hashable Tuple es hashable mientras que la lista no lo es. Las funciones hash devuelven el valor hash del objeto, si tiene uno.

    Hashability de la lista y tuple.

Si salía a caminar, podría anotar sus coordenadas en cualquier momento en una tupla (x,y) .

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

Pero no podías hacerlo al revés.

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

Así que si vas a necesitar cambiar los valores usa una lista.

Beneficios para las tuplas:

  1. Ligera mejora de rendimiento.
  2. Como una tupla es inmutable, se puede utilizar como clave en un diccionario.
  3. Si no puede cambiarlo, nadie puede hacerlo, es decir, no tiene que preocuparse por ninguna de las funciones de la API, etc. cambiando 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, por lo general, contienen una secuencia heterogénea de elementos a los que se accede mediante el desempaquetado (consulte más adelante en esta sección) o la indexación (o incluso por atributo en el caso de las muestras nombradas). Las listas son mutables, y sus elementos generalmente son homogéneos y se accede a ellos iterando sobre la lista.

Se ha mencionado que la diferencia es en gran medida semántica: la gente espera que una tupla y una lista representen información diferente. Pero esto va más allá de una pauta; 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 pido 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, si bien NumPy no forma parte de la biblioteca estándar, es una biblioteca importante de Python, y dentro de las listas y tuplas de NumPy hay cosas completamente diferentes.

Las listas son para bucle, las tuplas son para estructuras, es decir, "%s %s" %tuple .

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

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

Este es un ejemplo de las 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 tanto que ambas son colecciones ordenadas de valores. Además de la diferencia superficial, las listas se crean con corchetes “[…, …]” y tuplas con paréntesis “(…, …)”, la diferencia técnica entre “codificado por hardware en la syntax de Python” 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 se pueden usar como claves de hash / diccionario!). Esto da lugar a diferencias en la forma en que pueden o no pueden usarse (aplicada a priori por la syntax) y en cómo las personas eligen usarlas (alentadas como “mejores prácticas”, a posteriori, esto es lo que hacen los progtwigdores inteligentes ). La principal diferencia a posteriori en la diferenciación cuando se usan las tuplas en comparación con cuando se usan las listas radica en el significado que las personas le dan al orden de los elementos.

Para las tuplas, ‘orden’ no significa nada más que una ‘estructura’ específica para mantener 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 a través de dos dimensiones o escalas diferentes. Proporcionan respuestas a diferentes tipos de preguntas y son típicamente de la forma: para un objeto / sujeto dado, ¿cuáles son sus atributos? El objeto / sujeto se mantiene constante, los atributos difieren.

Para listas, ‘orden’ significa una secuencia o una direccionalidad. El segundo elemento DEBE venir después del primer elemento porque se coloca 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, generalmente de la forma, para un atributo dado, ¿cómo se comparan estos objetos / sujetos? El atributo se mantiene constante, el objeto / sujeto difiere.

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

Para resumir algunos de los detalles más finos.

Similitudes:

  1. Duplicados : tanto las tuplas como las listas permiten duplicados
  2. Indexación, selección y corte : tanto las tuplas como las listas indexan usando valores enteros encontrados entre paréntesis. Por lo tanto, si desea los primeros 3 valores de una lista o tupla dada, la syntax sería la misma:

     >>> my_list[0:3] [0,1,2] >>> my_tuple[0:3] [a,b,c] 
  3. Comparación y clasificación : dos tuplas o dos listas se comparan por su primer elemento, y si hay un empate, luego por el segundo elemento, y así sucesivamente. No se presta más atención a los elementos subsiguientes 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.

  1. Sintaxis : uso de listas [], uso de tuplas ()

  2. Mutabilidad : los elementos de una lista dada son mutables, los elementos de 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 "", line 1, in  TypeError: 'tuple' object does not support item assignment 
  3. Hashtables (diccionarios) : como las hashtables (diccionarios) requieren que sus claves sean hashables y, por lo tanto, inmutables, solo las tuplas pueden actuar como claves del 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 "", line 1, in  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.

  1. Homo frente a heterogeneidad de los elementos: en general, los objetos de la lista son homogéneos y los de la tupla son heterogéneos. Es decir, las listas se usan para objetos / sujetos del mismo tipo (como todos los candidatos presidenciales, o todas las canciones, o todos los corredores), aunque aunque no están obligadas a hacerlo, mientras que las tuplas son más para objetos heterogéneos.

  2. Bucle contra Estructuras: aunque ambos permiten el bucle (para x en mi lista), 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 la lista se pueden cambiar en cualquier momento, pero los valores de las tuplas no se pueden cambiar.

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

Las listas pretenden 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.

  1. Sintaxis literal

    Utilizamos paréntesis ( ) para construir tuplas y corchetes [ ] para obtener una nueva lista. Además, podemos usar la llamada del tipo apropiado para obtener la estructura requerida: tupla o lista.

     someTuple = (4,6) someList = [2,6] 
  2. Mutabilidad

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

  3. Uso de memoria

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

  4. Extensible

    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).

  5. Hash

    Las tuplas son hashable y las listas no. Esto 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 
  6. Semántica

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

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

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

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

Si la tuple contiene una list o un dictionary dentro de ella, se pueden cambiar incluso si la tuple sí 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 los contenidos de la lista como

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

lo que hace que la tupla nueva parezca

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

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

 my_tuple[4]['a'] = 500 

lo que hará que la tupla en general se vea como

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

Esto sucede porque la list y el dictionary son los objetos y estos objetos no están cambiando, pero los contenidos a los que apunta.

Así que la tuple permanece inmutable sin excepción.

Una cita de la 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, por lo general, contienen una secuencia heterogénea de elementos a los que se accede mediante el desempaquetado (consulte más adelante en esta sección) o la indexación (o incluso por atributo en el caso de las muestras nombradas). Las listas son mutables , y sus elementos generalmente son 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 aliasing)
    • Inmutable (tuple, int, float, str)
    • Concatenación usando + (se creará una tupla nueva, por supuesto)
    • Indexación
    • Rebanar
    • Singleton (3,) # -> (3) lugar de (3) # -> 3
  • Lista (Array en otros idiomas), secuencia ordenada de valores
    • Mudable
    • Singleton [3]
    • new_array = origin_array[:]
    • La lista de comprensión [x**2 for x in range(1,7)] le proporciona [1,4,9,16,25,36] (no legible)

El uso de la lista también puede causar un error de aliasing (dos rutas distintas que apuntan al mismo objeto).

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

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

Ahora cambia los valores de índice de lista y 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, se demostró que el siguiente código no es válido con tuple, porque intentamos actualizar una tupla, lo cual no está permitido.

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 creas 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. Por ejemplo, si la asignación de memoria actual es de 100 bytes, cuando desee agregar el 101.o byte, tal vez se asignarán otros 100 bytes (en este caso, un total de 200 bytes).

Sin embargo, si sabe que no agrega con frecuencia nuevos elementos, entonces debe usar tuplas. Las tuplas asignan exactamente el tamaño de la memoria necesaria y, por lo tanto, ahorran memoria, especialmente cuando usas grandes bloques de memoria.

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