Listas, tuplas, diccionarios y conjuntos

• Nivel: principiante
• Úsala cuando: trabajes con grupos de valores, registros, conteos o elementos únicos
• Conocimientos previos útiles: variables, condicionales y bucles for

En esta página organizarás los datos de un club escolar con cuatro colecciones de Python. Consultarás, cambiarás y recorrerás esos datos en un cuaderno o intérprete con Python 3, y justificarás qué colección corresponde a cada necesidad.

Qué puedes consultar aquí

• describir cómo manejan el orden y los duplicados una lista, una tupla, un diccionario y un conjunto;
• consultar elementos mediante índices, cortes o claves, según la colección;
• modificar listas, diccionarios y conjuntos, y explicar por qué no se puede reasignar una posición de una tupla;
• recorrer cada colección y comprobar pertenencia con in;
• elegir una estructura según el acceso, el orden, los duplicados y la posibilidad de cambio.

Un problema: organizar datos de un club escolar

El club tiene una lista de llegadas, categorías fijas, integrantes agrupados por equipo y talleres inscritos. Cada grupo de datos exige operaciones distintas. La lista de llegadas debe conservar el orden; para registrar cada taller una sola vez, hay que descartar repeticiones.

Usaremos este escenario en toda la página. Así podrás comparar las colecciones sin cambiar de problema entre ejemplos.

Listas: una secuencia que puede cambiar

Una lista es una secuencia ordenada y mutable. Conserva la posición de sus elementos, admite duplicados y se escribe entre corchetes. Mutable significa que su contenido puede cambiar después de crearla.

Los índices empiezan en 0. El índice -1 consulta el último elemento. Un corte como lista[1:3] incluye la posición inicial y excluye la final.

llegadas = ["Luz", "Diego", "Luz", "Mara"]

print(llegadas[0])
print(llegadas[-1])
print(llegadas[1:3])
print("Diego" in llegadas)

La lista conserva las dos apariciones de "Luz". Consultar una posición inexistente, por ejemplo llegadas[10], produce IndexError. La reparación consiste en usar un índice dentro del intervalo disponible o comprobar primero len(llegadas).

La asignación por índice reemplaza un elemento. append agrega al final y muta la lista existente. Los métodos mutadores, incluidos append y sort, devuelven None; no conviene asignar ese resultado como si fuera la lista modificada.

llegadas = ["Luz", "Diego", "Luz", "Mara"]
llegadas[1] = "Diego A."
resultado = llegadas.append("Nora")

for nombre in llegadas:
    print(nombre)

print(resultado)  # None

Tuplas: una secuencia inmutable

Una tupla también conserva posiciones y duplicados, pero sus posiciones no pueden reasignarse. Usa índices y cortes como una lista. Es adecuada para categorías cuya cantidad y orden forman parte del dato.

categorias = ("Robótica", "Ciencia", "Arte")

print(categorias[0])
print(categorias[-1])
print(categorias[1])
print("Música" not in categorias)

for categoria in categorias:
    print(categoria)

La instrucción categorias[0] = "Programación" produce TypeError, porque una posición de la tupla no admite asignación. Para obtener categorías distintas hay que crear otra tupla, por ejemplo nuevas_categorias = ("Programación",) + categorias[1:].

La coma crea una tupla de un elemento: un_elemento = ("Robótica",). Sin esa coma, los paréntesis solo agrupan una expresión. La inmutabilidad es superficial: si una tupla contiene una lista, esa lista aún puede mutar; lo que no puede reasignarse es la posición de la tupla.

Diccionarios: valores asociados con claves

Un diccionario asocia cada clave con un valor. Las claves son únicas y deben ser hashables: Python necesita poder calcular con hash(valor) un identificador estable que usa para localizar la clave. Las cadenas y los números son hashables; una tupla lo es solo si todos sus elementos también lo son. Una lista puede cambiar y hash([]) produce TypeError, así que no puede ser clave. Los diccionarios conservan el orden de inserción, pero no se consultan mediante posiciones numéricas.

En el club, el nombre de un equipo puede ser la clave y su lista de integrantes, el valor. Asignar una clave nueva agrega una asociación. Asignar una clave existente reemplaza su valor.

equipos = {
    "Halcones": ["Luz", "Mara"],
    "Ajolotes": ["Diego"],
}

equipos["Ajolotes"] = ["Diego", "Nora"]
equipos["Colibríes"] = ["Iker"]

print(equipos["Halcones"])
print(equipos.get("Mapaches", []))
print("Ajolotes" in equipos)
print(["Diego", "Nora"] in equipos.values())

El operador in busca claves cuando se aplica directamente al diccionario. Para buscar un valor se usa valor in equipos.values(). El método get permite indicar un valor alternativo si falta la clave; el acceso con corchetes produciría KeyError en ese caso.

items() entrega cada asociación como un par (clave, valor). El encabezado for nombre_equipo, integrantes in equipos.items() desempaqueta ese par: en cada vuelta asigna la primera parte a nombre_equipo y la segunda a integrantes. El desempaquetado requiere la misma cantidad de nombres que de elementos; aquí siempre son dos.

equipos = {
    "Halcones": ["Luz", "Mara"],
    "Ajolotes": ["Diego", "Nora"],
}

for nombre_equipo, integrantes in equipos.items():
    print(nombre_equipo, len(integrantes))

Conjuntos: elementos únicos

Un conjunto o set contiene elementos únicos y hashables. Se aplica la misma regla operativa: cada elemento debe aceptar hash(elemento) sin producir TypeError, por lo que una cadena puede pertenecer al conjunto y una lista no. El conjunto elimina duplicados, permite pruebas de pertenencia y puede mutar. No mantiene posiciones ni admite acceso por índice, por lo que talleres[0] no es válido; tampoco debes depender del orden de iteración o impresión.

Un literal como {"Ajedrez", "Teatro"} crea un conjunto con elementos. En cambio, {} crea un diccionario vacío; para un conjunto vacío usa set().

inscripciones = ["Ajedrez", "Robótica", "Ajedrez", "Teatro"]
talleres = set(inscripciones)

talleres.add("Ciencia")
talleres.discard("Danza")
print("Robótica" in talleres)
print(len(talleres))

remove(x) elimina x, pero produce KeyError si el elemento falta. discard(x) también elimina el elemento y no falla cuando está ausente. Ambos métodos mutan el conjunto.

La unión reúne elementos presentes en cualquiera de dos conjuntos. La intersección conserva los elementos compartidos. Para verificar el contenido sin depender del orden impreso, conviene comparar conjuntos directamente.

talleres_manana = {"Ajedrez", "Robótica", "Teatro"}
talleres_tarde = {"Robótica", "Ciencia"}

union = talleres_manana | talleres_tarde
comunes = talleres_manana & talleres_tarde

print(union == {"Ajedrez", "Robótica", "Teatro", "Ciencia"})
print(comunes == {"Robótica"})

for taller in comunes:
    print(taller)

Compara las cuatro colecciones

Ya conoces las operaciones de cada tipo. El siguiente visual permite contrastar acceso, cambio, recorrido y búsqueda sobre los datos del club.

La tabla ofrece la misma comparación en formato de lectura.

Consulta, cambio, recorrido y pertenencia

Las cuatro colecciones aceptan recorrido y pertenencia, aunque el significado depende del tipo. Solo las secuencias usan índices. El diccionario usa claves y el conjunto no ofrece acceso posicional.

llegadas = ["Luz", "Diego"]
categorias = ("Robótica", "Ciencia")
equipos = {"Halcones": ["Luz"], "Ajolotes": ["Diego"]}
talleres = {"Ajedrez", "Robótica"}

print(llegadas[0])
print(categorias[0])
print(equipos["Halcones"])
print("Robótica" in talleres)

llegadas.append("Mara")
equipos["Halcones"].append("Mara")
talleres.add("Teatro")

for clave, valor in equipos.items():
    print(clave, valor)

Comprensiones

Una comprensión construye una colección nueva a partir de un recorrido, en una sola expresión. La comprensión de lista se escribe entre corchetes: primero va la expresión que calcula cada elemento y después el for que recorre los datos. Equivale a crear una lista vacía y llamar a append en cada vuelta de un for.

llegadas = ["Luz", "Diego", "Luz", "Mara"]

minusculas = []
for nombre in llegadas:
    minusculas.append(nombre.lower())

minusculas_comprension = [nombre.lower() for nombre in llegadas]

print(minusculas)
print(minusculas_comprension)
print(llegadas)

Los dos primeros print muestran ['luz', 'diego', 'luz', 'mara']. La comprensión conserva el orden y los duplicados de llegadas, igual que el for. El tercer print muestra ['Luz', 'Diego', 'Luz', 'Mara']: la comprensión crea otra lista y no modifica la original.

Un if al final de la comprensión filtra los elementos: solo entran aquellos para los que la condición produce True. Equivale a poner ese if dentro del for, antes de append.

inscripciones = ["Ajedrez", "Robótica", "Ajedrez", "Teatro"]

otros = []
for taller in inscripciones:
    if taller != "Ajedrez":
        otros.append(taller)

otros_comprension = [taller for taller in inscripciones if taller != "Ajedrez"]

print(otros)
print(otros == otros_comprension)

Imprime ['Robótica', 'Teatro'] y True.

Una comprensión de diccionario usa llaves y un par clave: valor antes del for. Con items() y desempaquetado, recorre un diccionario existente y construye otro. Equivale a empezar con {} y asignar conteo[equipo] = len(integrantes) en cada vuelta.

equipos = {
    "Halcones": ["Luz", "Mara"],
    "Ajolotes": ["Diego", "Nora"],
    "Colibríes": ["Iker"],
}

conteo = {equipo: len(integrantes) for equipo, integrantes in equipos.items()}

print(conteo)

Imprime {'Halcones': 2, 'Ajolotes': 2, 'Colibríes': 1}.

Sin el par clave: valor, las llaves producen una comprensión de conjunto. Equivale a empezar con set() y llamar a add en cada vuelta.

llegadas = ["Luz", "Diego", "Luz", "Mara"]

personas = {nombre.lower() for nombre in llegadas}

print(len(personas))
print(personas == {"luz", "diego", "mara"})

Imprime 3 y True. La lista del primer ejemplo tenía cuatro elementos porque conservaba las dos apariciones de 'luz'; el conjunto tiene tres.

Una comprensión conviene cuando el resultado es una colección nueva y cada elemento se calcula con una expresión corta. Un for explícito es más claro cuando cada vuelta hace varios pasos, cambia otra colección, imprime algo o necesita break. Una comprensión escrita solo por su efecto, como [print(nombre) for nombre in llegadas], imprime los nombres, pero además construye una lista de None que nadie usa.

En este recorrido, cada vuelta consulta un conjunto que se construye en el mismo bucle y decide qué colección cambia:

llegadas = ["Luz", "Diego", "Luz", "Mara"]
vistos = set()
repetidos = []

for nombre in llegadas:
    if nombre in vistos:
        repetidos.append(nombre)
    else:
        vistos.add(nombre)

print(repetidos)
print(vistos == {"Luz", "Diego", "Mara"})

Imprime ['Luz'] y True. Cada vuelta consulta vistos y después modifica vistos o repetidos. Con un for, esos pasos se leen de arriba abajo; una sola comprensión no expresa los dos cambios con claridad.

Cómo elegir

Primero identifica cómo necesitas consultar el dato. Si una clave descriptiva conduce a un valor, usa un diccionario. Si la consulta depende de una posición y el contenido cambiará, usa una lista; si sus posiciones deben permanecer fijas, considera una tupla.

Cuando solo importan elementos únicos, sin acceso posicional, usa un conjunto. Antes de elegir, comprueba además si deben conservarse duplicados y si habrá cambios.

En el club, la elección queda así:

• La llegada usa una lista porque conserva el orden y puede recibir nombres nuevos.
• Las categorías usan una tupla porque sus posiciones forman una configuración fija.
• Los equipos usan un diccionario porque cada nombre de equipo permite consultar integrantes.
• Los talleres inscritos usan un conjunto cuando solo interesa cada nombre una vez.

Errores comunes

lista.append(valor) cambia la lista y devuelve None. Si escribes lista = lista.append(valor), el nombre termina asociado con None. Ejecuta el método sin reasignar.

Una tupla de un elemento necesita coma. También es incorrecto intentar cambiar una de sus posiciones: crea otra tupla con el contenido deseado.

En un diccionario, in busca claves, no valores. En un conjunto, no uses índices ni supongas un orden al imprimir. Usa pertenencia, recorrido u operaciones de conjuntos.

Práctica

Traza

Sin ejecutar este código, escribe la salida de cada print y el estado de las cuatro colecciones después de cada cambio:

llegadas = ["Luz", "Diego", "Mara"]
categorias = ("Robótica", "Ciencia", "Arte")
equipos = {"Halcones": ["Luz", "Mara"], "Ajolotes": ["Diego"]}
talleres = {"Ajedrez", "Robótica"}

print(llegadas[1])
llegadas[1] = "Nora"
print(llegadas)
print(categorias[0])
print("Ciencia" in categorias)
print("Halcones" in equipos)
print(["Luz", "Mara"] in equipos.values())
equipos["Ajolotes"] = ["Diego", "Iker"]
print(equipos["Ajolotes"])
talleres.add("Ciencia")
print(talleres == {"Ajedrez", "Robótica", "Ciencia"})

Después ejecútalo y compara. Debes obtener Diego, ['Luz', 'Nora', 'Mara'], Robótica y cuatro resultados True, además de ['Diego', 'Iker']. Explica por qué "Halcones" in equipos busca una clave, mientras la búsqueda en equipos.values() encuentra una lista. Comprueba también que categorias no cambió y explica por qué categorias[0] = "Programación" produciría TypeError.

Modifica

Parte de este programa completo:

llegadas = ["Luz", "Diego", "Mara"]
categorias = ("Robótica", "Ciencia", "Arte")
equipos = {
    "Halcones": ["Luz", "Mara"],
    "Ajolotes": ["Diego"],
}
talleres = {"Ajedrez", "Robótica"}

# Escribe aquí los cambios.

print(llegadas)
print(categorias)
print(equipos)
print(talleres == {"Ajedrez", "Robótica", "Teatro"})

Reemplaza "Diego" por "Diego A." en la lista llegadas y agrega "Nora" al final. Reemplaza el valor completo de la clave "Ajolotes" por ["Diego A.", "Nora"]. Agrega "Teatro" al conjunto. No reasignes ninguna posición de categorias.

Al terminar, las tres primeras salidas deben ser ['Luz', 'Diego A.', 'Mara', 'Nora'], ('Robótica', 'Ciencia', 'Arte') y {'Halcones': ['Luz', 'Mara'], 'Ajolotes': ['Diego A.', 'Nora']}; la última debe ser True.

Crea

Crea una colección llamada cupos para estos requisitos: cada taller se consulta por nombre, su cantidad puede cambiar, un nombre de taller no puede repetirse como clave y el orden por posición no forma parte del dato. Empieza con 12 cupos para "Robótica" y 8 para "Arte"; después cambia Robótica a 10.

Comprueba que cupos["Robótica"] == 10, cupos["Arte"] == 8 y "Arte" in cupos produzcan True. Escribe una frase que justifique la colección elegida mediante acceso, cambio, duplicados y orden.

Reto

Construye el registro de un torneo escolar. Usa estos datos iniciales sin cambiar nombres ni categorías:

llegadas = ["Luz", "Diego", "Mara"]
equipos = {
    "Halcones": ["Luz", "Mara"],
    "Ajolotes": ["Diego"],
}
categorias = ("Robótica", "Ajedrez", "Ciencia")
inscripciones_por_persona = {
    "Luz": ["Robótica", "Ajedrez"],
    "Diego": ["Ciencia"],
    "Mara": ["Ajedrez", "Ajedrez"],
}

Realiza estas operaciones en orden:

1. Crea participantes_unicos a partir de llegadas.
2. Crea talleres_por_persona como diccionario. Cada nombre debe conservarse como clave y cada lista de inscripciones_por_persona debe convertirse en un conjunto; así, Mara tendrá un solo "Ajedrez".
3. Añade "Iker" al final de llegadas y a participantes_unicos.
4. Añade "Iker" a la lista de equipos["Ajolotes"] y asigna talleres_por_persona["Iker"] = {"Ciencia"}. No cambies categorias.
5. Consulta equipos["Ajolotes"]: debe devolver ["Diego", "Iker"]. Comprueba también "Ajolotes" in equipos, "Iker" not in equipos, ["Diego", "Iker"] in equipos.values(), "Ciencia" in categorias, "Iker" in participantes_unicos y "Ciencia" in talleres_por_persona["Iker"]; las seis expresiones deben producir True.
6. Recorre llegadas, categorias y participantes_unicos con for; recorre equipos con items(). No evalúes el conjunto por el orden en que se imprime.

Agrega al final estas verificaciones. El reto termina cuando las ocho imprimen True:

print(llegadas == ["Luz", "Diego", "Mara", "Iker"])
print(equipos == {"Halcones": ["Luz", "Mara"], "Ajolotes": ["Diego", "Iker"]})
print(categorias == ("Robótica", "Ajedrez", "Ciencia"))
print(participantes_unicos == {"Luz", "Diego", "Mara", "Iker"})

La quinta compara el diccionario completo: no faltan Luz ni Diego ni sobran claves.

print(
    talleres_por_persona
    == {
        "Luz": {"Robótica", "Ajedrez"},
        "Diego": {"Ciencia"},
        "Mara": {"Ajedrez"},
        "Iker": {"Ciencia"},
    }
)
print(talleres_por_persona["Iker"] == {"Ciencia"})
print("Ajolotes" in equipos and "Iker" not in equipos)
print(
    ["Diego", "Iker"] in equipos.values()
    and "Ciencia" in categorias
    and "Iker" in participantes_unicos
    and "Ciencia" in talleres_por_persona["Iker"]
)

Escribe una frase por tipo para justificar lista, tupla, diccionario y conjunto según acceso, orden, duplicados y posibilidad de cambio.

Comprueba estos cuatro aspectos:

1. Las ocho verificaciones finales imprimen True.
2. Las seis comprobaciones de pertenencia del paso 5 producen el resultado indicado y la consulta por clave devuelve ["Diego", "Iker"].
3. Los cuatro recorridos usan el contenido solicitado y el programa no depende del orden de un conjunto.
4. Las cuatro justificaciones nombran al menos una propiedad observable de cada elección.

Si falta alguno, revisa la operación correspondiente.

Lista de comprobación

• Puedo predecir si cada colección conserva posiciones y duplicados.
• Puedo consultar una lista o tupla por índice y un diccionario por clave.
• Puedo modificar una lista, un diccionario y un conjunto sin reasignar una tupla.
• Puedo recorrer los cuatro tipos y explicar qué busca in en cada uno.
• Puedo escribir una comprensión de lista, de diccionario o de conjunto, su for equivalente y decidir cuándo el for es más claro.
• Puedo justificar una elección mediante acceso, orden, duplicados y mutabilidad.

Para consultar

• Estructuras de datos en el tutorial oficial de Python
• Tipos integrados de Python