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

1020

¿Cual es la diferencia?

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

Lucas Gabriel Sánchez
fuente
13
Los otros respondieron a continuación, pero me gustaría señalar que, en mi opinión, python tiene nombres de tipo de datos totalmente poco intuitivos. No creo que ningún otro idioma tenga tuplas (por ese nombre), y lo que es peor, como palabra, ni siquiera puedo traducirlo en mi idioma. ¿Alguien sabe de dónde viene la "tupla"? Holandés?
Torre de
98
Las tuplas son un término básico en matemáticas, derivado del latín (ver wikipedia).
nikow
129129
par -> triple -> cuádruple -> quintuple -> sextuple -> um, cómo se llama, ah sod it, 7-tuple -> 8-tuple -> ... de ahí 'tuple' como nombre genérico.
John Fouhy
31
@JohnFouhy Han pasado más de seis años, pero: ... heptuple, octuple, tuple-with-nine-elements, decuple, undecuple, dodecuple ...: D
Augusta
18
@MegaWidget Pensé que habíamos establecido que una no tupla era una list. ; D
Augusta

Respuestas:

1017

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 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 programació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 "Comprender las tuplas frente a las 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á la nombrada tupla en Python, lo cual tiene sentido porque ya se supone que una tupla tiene estructura. Esto subraya la idea de que las tuplas son una alternativa ligera a las clases e instancias.

nikow
fuente
11
+1, especialmente para su segundo enlace con un gran ejemplo. Me encanta esta cita: "Esta tupla funciona como un registro o estructura ligera".
Baltimark
105
"Las listas son secuencias homogéneas". Soy nuevo en Python, pero ¿no son las listas heterogéneas? De docs.python.org/py3k/tutorial/introduction.html : "No es necesario que todos los elementos de la lista tengan el mismo tipo". Pero tal vez estás hablando sobre el concepto formal, y no sobre Python.
Matthew Cornell
13
Un buen sinónimo semántico para "tupla" podría ser "registro". Es una colección de elementos de datos relacionados en una secuencia específica. De hecho, siento collections.namedtupleque sería mejor llamarlo collections.record. No tendría sentido intercambiar, digamos, el nombre y la dirección en un registro de cliente; de hecho, hacerlo sería generalmente un error, que la inmutabilidad de la tupla le impide cometer.
poco
44
@nikow: Respecto What would you do with such a list?, siempre tiemblo cuando la gente usa la falta de fantasía como argumento. El uso de listas de tipos mixtos funciona muy bien, por ejemplo, para algunas estructuras de datos jerárquicas, donde cada lista se compone de listas secundarias y elementos de valor.
Sebastian Mach
18
¿No es engañoso decir que las tuplas son heterogéneas y las listas son homogéneas? Por ejemplo, una lista puede tener mezclas de diferentes tipos de datos, es decir, l = [1, 2, 'a']. No entiendo de qué estás hablando.
Celeritas
362

Diferencia entre lista y tupla

  1. Literal

    someTuple = (1,2)
    someList  = [1,2] 
  2. Talla

    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.

  3. 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, podría agregar un nuevo elemento tanto a la lista como a la tupla con la única diferencia de que, dado que la tupla es inmutable, en realidad no está agregando un elemento pero está creando una nueva tupla, por lo que la identificación de cambiará

    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
Nikita
fuente
Entonces, ¿qué sucede cuando intento cambiar el tamaño del tamaño de la lista a valores grandes? ¿Cambiará la dirección de memoria (que creo que debería cambiar la identificación)? ¿O me arrojará un error?
WanderingMind
17
@WanderingMind: la dirección de memoria donde se almacenan los valores de la lista no es la misma que la dirección de memoria donde se almacena el objeto de la lista.
Tom
2
Hmmm ... todo el código en esta publicación, excepto el primer cuadro debajo, 3. Permitted operationmuestra primero el caso de la tupla. Sé que es habitual mostrar el éxito y luego el error, pero eso me molestó por unos momentos.
dmckee --- ex gatito moderador
1
Como se muestra en el punto 3, puede ser una lista de un solo elemento one_item_list = [a], pero one_tuple = (a,)es la tupla correspondiente. Tenga en cuenta la coma que sigue al nombre de la variable. Pero también tenga en cuenta two_tuple = (a, b). Esto me arrojó más de una vez (todavía allí en Python 3).
mjkrause
1
@Cheng Porque ordenar la tupla lo mutaría, es decir, cambiaría sus elementos. Las tuplas no son compatibles con eso. La forma más sencilla de obtener una tupla ordenada en Python estuple(sorted(the_unsorted_tuple))
ApproachingDarknessFish,
204

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

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

Pero no podrías hacerlo al revés.

dan-gph
fuente
37
Este ejemplo parece simplemente una convención. La gente podría argumentar "Todavía puedo usar [x, y] para anotar las coordenadas si quiero". Por lo tanto, esta respuesta se considera incompleta a menos que una oración más: "Lea la publicación de @nikow para saber por qué no debe usar la lista para almacenar coordenadas"
RayLuo
71
@Iceberg, mi respuesta está destinada a ayudar a desarrollar la intuición. No está destinado a explorar todos los matices del tema.
dan-gph
8
Buen ejemplo +1. Enfatiza la naturaleza complementaria de los elementos de la tupla (aquí las coordenadas), que es la razón por la cual no está permitido modificar ninguno de ellos, porque cambia el significado de toda la tupla (aquí la posición de un punto).
Hao Wang
77

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:

  1. Ligera mejora del rendimiento.
  2. Como una tupla es inmutable, puede usarse como clave en un diccionario.
  3. Si no puede cambiarlo, nadie más puede hacerlo, lo que quiere decir que no tiene que preocuparse de que las funciones de la API, etc. cambien su tupla sin que se lo pidan.
Dave Webb
fuente
14
Tenga en cuenta que una tupla solo es inmutable si todos sus elementos lo son . Se podría decir que lo mismo es cierto para todas las colecciones inmutables, como frozenseto los diversos dict / tree / etc congelados de terceros. tipos, pero ninguno de ellos le permite agregar elementos mutables. (Y, por supuesto, una tupla solo se puede cambiar si todos sus elementos lo son, que se maneja de la manera habitual de EAFP, por d[1, [2]]lo que aumentará TypeError: unhashable type: 'list').
abarnert
1
Una tupla solo se puede usar como clave en un diccionario si todos sus elementos son inmutables. Ver aquí
Will Dereham
31

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 desempacando (ver más adelante en esta sección) o indexando (o incluso por atributo en el caso de las tuplas nombradas). Las listas son mutables, y sus elementos son generalmente homogéneos y se accede iterando sobre la lista.

duffymo
fuente
1
Realmente creo que también debería considerar las implicaciones semánticas (vea mi respuesta a continuación).
nikow
Apenas parece que valga la pena el esfuerzo ahora, pero gracias por el aviso.
duffymo
Seis meses después, ¿y esto es todo lo que puedes aportar? Di esa respuesta en ese momento porque en las cuatro horas que pasaron entre mi respuesta original y el comentario, otros habían compensado la diferencia. ¿La respuesta fue incorrecta? En realidad no, aunque fue mejorado por Nikow. Entonces, ¿qué agregaría realmente un enlace?
duffymo
44
Es divertido ver cómo otras respuestas aquí tienen la misma calidad como esta, pero solo esto es odiado porque un comentarista dijo "-1". Y hay otra respuesta que tiene solo 0.5 veces la calidad, pero solo 0.1 veces los votos negativos.
Sebastian Mach
2
@duffymo Creo que esta respuesta es la más clara y concisa de esta página. Nombra la única diferencia realmente importante entre las tuplas y las listas y no parlotea interminablemente sobre este descarado falso homogéneo vs heterogéneo.
antred
20

Se ha mencionado que la diferencia es en gran medida semántica: las personas esperan que una tupla y una lista representen 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 importante de Python, y dentro de las listas y tuplas de NumPy hay cosas completamente diferentes.

Shep
fuente
2
Esta no es realmente una respuesta útil. La diferencia es que type(a_list) != type(a_tuple), por lo que cualquier ramificación de código de biblioteca basada en type(x)se comportará de manera diferente
Eric
1
Buen punto, he editado la publicación: esto realmente solo señala que las pautas semánticas están codificadas en algunas bibliotecas.
Shep
1
Puede ser mejor usar ejemplos de stdlib / builtins que de bibliotecas de terceros. Hay varios lugares donde puede usar un solo valor o una tupla de valores, y una lista u otra secuencia se considera un solo valor. Por ejemplo, '%d %d' % [2, 3]es un TypeError, porque está intentando pasar una lista a la primera %dy no está pasando ningún valor a la segunda %d. (Sin embargo, también hay ejemplos contrarios a esto, como max...)
abarnert
eso es interesante, no sabía que hubiera ejemplos de esto en la biblioteca estándar de Python. ¿Un número de lugares que dices?
Shep
18

Las listas son para bucles, 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 de longitud variable, las tuplas son de longitud fija.

Srinivas Reddy Thatiparthy
fuente
16

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 diferencia superficial de que las listas se crean con corchetes "[..., ...]" y las tuplas con paréntesis "(..., ...)", la diferencia técnica principal "codificada en sintaxis de Python" 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 hacen los programadores inteligentes ). La gente da al orden de los elementos.

Para las tuplas, 'orden' no significa nada más que solo una 'estructura' específica para almacenar 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 son típicamente de la forma: para un objeto / tema determinado, ¿cuáles son sus atributos? El objeto / sujeto permanece constante, los atributos difieren.

Para las 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:

  1. Duplicados : tanto las tuplas como las listas permiten duplicados
  2. Indexación, selección y división : 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]
  3. Comparación y clasificación : dos tuplas o dos listas se comparan por su primer elemento, y si hay un empate, entonces 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

  1. Sintaxis : las listas usan [], las tuplas usan ()

  2. 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
  3. Tablas hash (diccionarios) : como las tablas hash (diccionarios) requieren que sus claves sean hash 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

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

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

Inspiración
fuente
Me gusta el ejemplo de tabla hash / hashable para explicar una razón de inmutabilidad: puede usar una tupla (registro / estructura / coordenada / vector / punto) como una clave compleja en un dict.
Dave X
9

Los valores de la lista se pueden cambiar en cualquier momento, pero los valores de las tuplas no se pueden cambiar.

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

azulado
fuente
7

Diferencia entre lista y tupla

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

  1. Sintaxis literal

    Usamos 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] 
  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. 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
  6. Semántica

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

iNet
fuente
1
Mi voto aquí para la discusión explícita de la extensión y el hash, que no noté en las respuestas existentes que de otro modo serían muy buenas.
dmckee --- ex-gatito moderador
6

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

pquers
fuente
26
En este punto, esta respuesta no agrega nada a la discusión, ya que hay muchas otras mejores respuestas.
Jonathon Reinhart el
5

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

Si tuplecontiene a listo a dictionarydentro, se pueden cambiar incluso si el tuplemismo 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

lo que hace que parezca una nueva tupla

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

también podemos cambiar el diccionario dentro de tupla como

my_tuple[4]['a'] = 500

lo que hará que la tupla general se vea como

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

Esto sucede porque listy dictionaryson los objetos y estos objetos no están cambiando, sino el contenido al que apunta.

Entonces los tuplerestos son inmutables sin ninguna excepción

Daksh
fuente
Esta publicación se mejoraría si explicara que "se pueden cambiar incluso si la tupla en sí es inmutable". es porque esos objetos conservan su identidad mientras que (por lo que la tupla no ha cambiado porque todavía contiene los mismos objetos ...).
dmckee --- ex-gatito moderador
3

El PEP 484 - Sugerencias de tipo dice que los tipos de elementos de a tuplese pueden escribir individualmente; para que puedas decir Tuple[str, int, float]; pero a list, con la Listclase de escritura solo puede tomar un parámetro de tipo: lo List[str]que sugiere que la diferencia de los 2 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 a struct.

Antti Haapala
fuente
3

Como la gente ya ha mencionado las diferencias, escribiré sobre por qué las tuplas.

¿Por qué se prefieren las tuplas?

Optimización de asignación para tuplas pequeñas

Para reducir la fragmentación de la memoria y acelerar las asignaciones, Python reutiliza tuplas antiguas. Si una tupla ya no es necesaria y tiene menos de 20 elementos en lugar de eliminarla permanentemente, Python la mueve a una lista libre.

Una lista gratuita se divide en 20 grupos, donde cada grupo representa una lista de tuplas de longitud n entre 0 y 20. Cada grupo puede almacenar hasta 2 000 tuplas. El primer grupo (cero) contiene solo 1 elemento y representa una tupla vacía.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

En el ejemplo anterior, podemos ver que ayb tienen la misma identificación. Eso es porque inmediatamente ocupamos una tupla destruida que estaba en la lista libre.

Optimización de asignación para listas

Como las listas se pueden modificar, Python no usa la misma optimización que en las tuplas. Sin embargo, las listas de Python también tienen una lista libre, pero solo se usa para objetos vacíos. Si GC elimina o recopila una lista vacía, puede reutilizarla más tarde.

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Fuente: https://rushter.com/blog/python-lists-and-tuples/

¿Por qué las tuplas son más eficientes que las listas? -> https://stackoverflow.com/a/22140115

Pygirl
fuente
2

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 desempacando (ver más adelante en esta sección) o indexando (o incluso por atributo en el caso de las tuplas nombradas). Las listas son mutables , y sus elementos son generalmente homogéneos y se accede iterando sobre la lista.

Albus Dumbledore
fuente
1

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 +(por supuesto, se creará una nueva tupla)
    • Indexación
    • Rebanar
    • Singleton en (3,) # -> (3)lugar de(3) # -> 3
  • Lista (matriz en otros idiomas), secuencia ordenada de valores
    • Mudable
    • único [3]
    • Clonación new_array = origin_array[:]
    • La comprensión de la lista [x**2 for x in range(1,7)]te da [1,4,9,16,25,36](no legible)

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

Lorem Ipsum Dolor
fuente
0

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 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, lo cual no está permitido.

Rahul Sawriya
fuente
-1

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. Por ejemplo, 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 el tamaño exacto de la memoria necesaria y, por lo tanto, ahorra memoria, especialmente cuando utiliza grandes bloques de memoria.

Tony
fuente
2
Si bien algo de eso es técnicamente cierto, esa no es realmente la diferencia crucial entre los tipos mutables e inmutables. La mayor diferencia es que los tipos mutables se pueden cambiar después de la construcción, mientras que los tipos inmutables no.
Roger Fan
1
Ese tampoco es el por qué. La memoria y la mutabilidad no tienen nada que ver entre sí. Eso es simplemente un detalle de implementación específico de las listas. La memoria tampoco se asigna a las variables, se asigna a los objetos. Las variables son solo referencias a esos objetos.
Roger Fan