Diccionarios y conjuntos en Python

Un diccionario almacena pares: una clave identifica un elemento y su valor contiene la información que quieres. Una lista de contactos es un modelo útil: un nombre lleva a un número de teléfono. Una consulta en un diccionario usa una clave, incluso cuando esa clave es un número.

Escribe los pares

ages = {"Ana": 31, "Ben": 27, "Cara": 35}
print(ages["Ben"])
print(len(ages))

Esto imprime 27 y después 3. Los dos puntos unen cada clave con su valor; las comas separan los pares. len cuenta pares. Tanto {} como dict() crean un diccionario vacío.

Cada clave aparece solo una vez. En {"a": 1, "b": 2, "a": 3}, el valor posterior de "a" sustituye al anterior y deja {'a': 3, 'b': 2}. Dos claves diferentes pueden tener el mismo valor: {"Ana": "blue", "Ben": "blue"} sigue teniendo dos elementos.

Construye a partir de otros datos

Elige la forma que corresponda a los datos de entrada:

colors = dict(red=1, blue=2)
coordinates = dict([("x", 10), ("y", 20)])
labels = dict(zip(["a", "b", "c"], [1, 2, 3]))

La primera forma crea claves de cadena a partir de los nombres de los argumentos. La segunda lee una secuencia de pares de dos elementos. La tercera empareja los elementos correspondientes de dos listas y produce {'a': 1, 'b': 2, 'c': 3}. Las cadenas de la primera forma son 'red' y 'blue', no consultas de variables.

Elige claves válidas

Las claves de diccionario deben ser aptas para hash. Las cadenas y los números sirven, al igual que las tuplas formadas íntegramente por elementos aptos para hash. Las listas, los diccionarios y los conjuntos ordinarios no sirven como claves. Para una ubicación, usa (2, 3), una tupla, en lugar de [2, 3], una lista:

board = {(0, 0): "start", (2, 3): "treasure"}
print(board[(2, 3)])

Esto imprime treasure. Los paréntesis convierten el par de coordenadas en una sola clave. Una tupla que contenga una lista sigue incumpliendo la regla de aptitud para hash. Los valores de diccionario no tienen esa restricción: un valor puede ser una lista, otro diccionario o cualquier otro tipo.

Las claves numéricas iguales hacen referencia a la misma entrada. Como 1, 1.0 y True son iguales al compararlos, {1: "one", 1.0: "float one"} contiene un par, con el valor 'float one'. La cadena "1" es una clave distinta del número 1.

Distingue el orden de la identidad

Desde Python 3.7, los diccionarios conservan el orden de inserción. Las edades anteriores aparecen como Ana, Ben, Cara al imprimirlas o recorrerlas con un bucle. Siguen teniendo claves, no posiciones de lista: ages[0] solicita la clave 0 y lanza KeyError: 0.

Los diccionarios son mutables. Después de backup = ages, ambos nombres hacen referencia al mismo diccionario. Asignar backup["Ana"] = 32 también cambia el valor al que se accede mediante ages. Para copiar el diccionario externo, escribe backup = ages.copy() o backup = dict(ages). Los diccionarios externos independientes pueden seguir compartiendo listas y diccionarios anidados.

La consulta debe ajustarse a lo que signifique una clave ausente en tu programa. A veces indica un error. Otras veces es normal, como un producto que aún no se ha contado. Python te ofrece distintas formas de tratar esos casos.

Lee un valor existente

stock = {"apples": 12, "pears": 0, "plums": 7}
print(stock["plums"])

La consulta con corchetes devuelve 7. Las claves deben coincidir exactamente: "Plums" es diferente de "plums". Leer stock["kiwis"] lanza KeyError: 'kiwis' porque esa clave no existe. No proporciona un valor vacío ni un conteo de cero.

Usa esta consulta directa cuando la clave sea obligatoria. Así, un error llama la atención sobre datos incompletos o un fallo de escritura en el lugar donde ocurre.

Comprueba si hay una clave

La expresión key in stock comprueba si una clave existe. "pears" in stock es True, aunque su valor almacenado sea cero. "kiwis" not in stock también es True.

item = "kiwis"
if item in stock:
    print(stock[item])
else:
    print("No stock record for", item)

Aquí, la clave ausente provoca un mensaje. La consulta solo se realiza en la rama en la que la clave existe.

La comprobación de pertenencia en un diccionario busca claves. 12 in stock es False; para preguntar si algún elemento tiene un valor almacenado de 12, escribe 12 in stock.values(). La colección que coloques después de in determina dónde se busca.

Lee con un valor predeterminado

stock.get("kiwis") devuelve None sin lanzar KeyError. Proporciona un segundo argumento para elegir otro valor predeterminado: stock.get("kiwis", 0) devuelve 0. Ninguna de las llamadas inserta un elemento nuevo. Después de ambas llamadas, el diccionario sigue conteniendo solo manzanas, peras y ciruelas.

El valor predeterminado sustituye el resultado de una consulta ausente, no un valor almacenado. stock.get("pears", 99) devuelve 0 porque las peras ya tienen un valor.

No confundas cero con ausente

if stock.get("pears"): comprueba el valor de verdad del valor devuelto. Cero se considera falso, así que se omite esa rama. La misma prueba también omite una clave ausente cuya consulta devuelve None. Para distinguir esos casos, comprueba directamente la pertenencia de la clave.

Procesa un pedido completo

prices = {"coffee": 3.5, "tea": 2.75}
order = ["tea", "coffee", "tea", "soda"]
total = 0
for item in order:
    if item in prices:
        total += prices[item]
    else:
        print("No price for", item)
print(total)

El primer té lleva el total a 2,75, el café lo lleva a 6,25 y el segundo té lo lleva a 9,0. El refresco produce el mensaje No price for soda y no añade nada. Una consulta directa en cada iteración fallaría con el refresco; usar sin aviso un precio predeterminado de cero ocultaría que falta el precio. La rama separada hace visible esa información ausente.

Las actualizaciones de diccionarios usan claves para identificar lo que cambia. Asignar un valor puede añadir un par nuevo o sustituir un valor anterior. Eliminar un par también puede devolver información que necesites, como la cantidad retirada de un inventario.

Añade y sustituye

scores = {"Ana": 8}
scores["Ben"] = 6
scores["Ana"] = 9
scores["Ben"] += 2
print(scores)

El resultado es {'Ana': 9, 'Ben': 8}. Se añade a Ben, se actualiza a Ana y después aumenta la puntuación existente de Ben. La línea con += lee primero el valor anterior, así que lanza KeyError para una clave ausente. Los diccionarios no tienen un método append.

Combina diccionarios

update copia pares en un diccionario existente. Con esas puntuaciones, scores.update({"Ben": 7, "Cara": 10}) cambia la de Ben a 7 y añade a Cara con 10.

Desde Python 3.9, el operador de fusión puede construir un diccionario nuevo:

left = {"x": 1, "y": 2}
right = {"y": 5, "z": 3}
merged = left | right
print(merged)

Esto imprime {'x': 1, 'y': 5, 'z': 3}. Para una clave compartida, prevalece el lado derecho. left permanece sin cambios; left |= right actualizaría el objeto original.

update() devuelve None. Escribir scores = scores.update(new_scores) modifica el diccionario anterior y después hace que scores haga referencia a None. Llama a update en una línea propia. Asigna el resultado de left | right cuando quieras un diccionario nuevo fusionado.

Elimina pares

Para {"a": 1, "b": 2, "c": 3}, popitem() devuelve ('c', 3). Esto usa el orden de inserción, no el orden alfabético ni el valor máximo.

Sigue un cambio de inventario

inventory = {"pens": 10, "pads": 4}
inventory["pens"] -= 3
inventory["clips"] = 50
removed = inventory.pop("pads")

La venta deja 7 bolígrafos. Añadir clips crea una clave nueva. Eliminar los blocs almacena 4 en removed y deja {'pens': 7, 'clips': 50}. El valor devuelto por pop permite al programa usar la cantidad retirada después de que el par haya desaparecido.

Inserta solo si no existe

setdefault(key, default) devuelve el valor existente o inserta y devuelve el valor predeterminado cuando la clave no existe. Para stock = {"apples": 12, "pears": 0, "plums": 7}, stock.setdefault("kiwis", 0) inserta los kiwis y devuelve 0. stock.setdefault("apples", 99) devuelve 12 y deja las manzanas sin cambios. Esta inserción es la diferencia con get.

Actualizar una clave existente mantiene su lugar. A partir de {"a": 1, "b": 2, "c": 3}, asignar d["a"] = 10 mantiene "a" en primer lugar. Eliminar "a" y volver a insertarla la coloca después de "c". Sustituir un valor e insertar un par nuevo afectan al orden de manera distinta.

Elige un bucle que te proporcione la parte de cada par que necesitas. Un diccionario por sí solo proporciona claves. Sus vistas pueden proporcionar valores o pares completos, para que no tengas que recuperar información que el bucle podría darte directamente.

Visita claves, valores o pares

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
for day, temp in temps.items():
    print(day, temp)

Las temperaturas están en grados Fahrenheit. Esto imprime Mon 68, Tue 75 y Wed 71 en líneas separadas, en orden de inserción. Cada elemento es una tupla de dos elementos que el bucle desempaqueta en day y temp.

Con for day in temps:, usa temps[day] dentro del bucle cuando necesites el valor correspondiente. Si el programa necesita ambas partes cada vez, .items() suele expresar la tarea con más claridad.

Comprende las vistas

keys(), values() e items() devuelven vistas, que reflejan los cambios posteriores en su diccionario. No son listas y no permiten acceder por índices de posición. temps.keys()[0] lanza TypeError. Convierte a una lista cuando necesites una instantánea con posiciones: list(temps) produce ['Mon', 'Tue', 'Wed'].

Calcula un total o encuentra la clave correspondiente

sum(temps.values()) devuelve 214, y dividir entre len(temps) produce una media de aproximadamente 71,33. max(temps.values()) devuelve 75. Para encontrar qué día tiene ese valor, escribe max(temps, key=temps.get), que devuelve 'Tue'.

El argumento key= proporciona una función que se usa para comparar. Aquí Python visita las claves de día y llama a temps.get para cada una para obtener su temperatura. Escribe el nombre de la función sin llamarla: temps.get, no temps.get(). Si los valores empatan, max devuelve la primera clave que encuentra.

Ordena un informe

sorted(temps) devuelve las claves en orden alfabético. sorted(temps.items()) devuelve los pares ordenados por clave. Para ordenar las claves de día por temperatura, usa sorted(temps, key=temps.get), que produce ['Mon', 'Wed', 'Tue']. Añade reverse=True para obtener ['Tue', 'Wed', 'Mon']. Estas llamadas devuelven listas; no reorganizan temps.

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
passing = 0
for name, grade in grades.items():
    print(f"{name}: {grade}")
    if grade >= 75:
        passing += 1

El informe imprime cada nombre con su calificación. Ana y Cara alcanzan el umbral, así que passing termina en 2.

Elimina entradas sin interrumpir el recorrido

No añadas ni elimines claves mientras iteras directamente sobre un diccionario. Cambiar su tamaño puede lanzar RuntimeError: dictionary changed size during iteration. Sí se permite sustituir un valor existente.

Para eliminar los días más frescos, usa for day in list(temps): y elimina temps[day] cuando su valor sea inferior a 70. El bucle recorre una lista independiente de claves y deja {'Tue': 75, 'Wed': 71} en el diccionario. Construir un diccionario nuevo filtrado es otra forma de separar el recorrido de los cambios.

Un diccionario nuevo suele surgir de una regla aplicada a datos existentes. Empieza con un bucle que puedas explicar y después usa una comprensión cuando la misma regla quepa con claridad en una expresión.

Construye un par cada vez

words = ["kiwi", "fig", "banana"]
lengths = {}
for word in words:
    lengths[word] = len(word)

Cada iteración elige una palabra como clave y su longitud como valor. El resultado es {'kiwi': 4, 'fig': 3, 'banana': 6}. El diccionario se crea antes del bucle para que los pares anteriores sigan disponibles en las iteraciones posteriores.

Un diccionario por comprensión expresa el mismo trabajo:

lengths = {word: len(word) for word in words}

Lee la parte de for para ver qué se visita y después la expresión anterior para ver qué par se produce. Los dos puntos separan la expresión de la clave de la expresión del valor. Sin esos dos puntos, {word for word in words} construye un conjunto.

Conserva algunos elementos

Una cláusula if filtra la entrada:

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
high_grades = {
    name: grade
    for name, grade in grades.items()
    if grade >= 80
}

Ana y Cara cumplen la condición, lo que produce {'Ana': 88, 'Cara': 95}. El par de Ben queda fuera. El diccionario de entrada no cambia; el resultado contiene solo los pares que cumplen la condición.

Transforma valores

Una comprensión puede conservar los días mientras convierte las lecturas de Fahrenheit a Celsius:

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
celsius = {
    day: round((f - 32) * 5 / 9, 1)
    for day, f in temps.items()
}

El resultado es {'Mon': 20.0, 'Tue': 23.9, 'Wed': 21.7}. Para el martes, restar 32 da 43; multiplicar por 5 y dividir entre 9 da aproximadamente 23,89. round(..., 1) almacena 23,9. La clave se mantiene mientras cambia el valor.

Empareja listas con cuidado

dict(zip(names, scores)) empareja cada nombre con la puntuación de la misma posición. zip se detiene cuando termina la entrada más corta. Emparejar ["Ana", "Ben", "Cara"] con [90, 85] produce {'Ana': 90, 'Ben': 85}. Ningún error avisa de que falta la puntuación de Cara, así que comprueba las longitudes de entrada cuando cada nombre deba tener una.

Intercambia claves y valores

favorites = {"Ana": "blue", "Ben": "red", "Cara": "blue"}
by_color = {color: name for name, color in favorites.items()}

El resultado es {'blue': 'Cara', 'red': 'Ben'}. Tanto Ana como Cara necesitarían la misma clave nueva, así que el par posterior de Cara sustituye al de Ana. La inversión conserva todos los pares solo cuando los valores anteriores son únicos y aptos para hash. Un valor de tipo lista no puede convertirse en una clave de diccionario. Para conservar varios nombres bajo un color, almacena una lista de nombres bajo ese color.

Usa un bucle normal cuando la tarea necesite varias sentencias, mensajes o comprobaciones. Una comprensión resulta útil porque hace visible una regla breve; comprimir en ella un procedimiento más extenso dificulta seguir la regla.

Una tabla de frecuencias responde cuántas veces aparece cada elemento distinto. Sus claves identifican los elementos; sus valores son contadores. El diccionario crece cuando aparece un elemento nuevo, mientras que las apariciones posteriores aumentan un conteo existente.

Sigue la evolución de un contador

counts = {}
for letter in "banana":
    if letter in counts:
        counts[letter] += 1
    else:
        counts[letter] = 1

La primera letra crea 'b': 1. La siguiente crea 'a': 1 y después se crea 'n': 1. La siguiente "a" aumenta su conteo existente a 2. Después de las dos últimas letras, el diccionario es {'b': 1, 'a': 3, 'n': 2}. Su orden registra cuándo apareció cada letra por primera vez, no cuál es la más frecuente.

Usa cero antes de la primera aparición

Las dos ramas pueden convertirse en una asignación:

counts = {}
for letter in "banana":
    counts[letter] = counts.get(letter, 0) + 1

El lado derecho lee el conteo anterior, usando cero cuando la clave no existe, y después suma uno. El lado izquierdo almacena ese conteo nuevo. get por sí mismo no inserta nada; la asignación sí.

Usar solo counts[letter] += 1 falla cuando una letra es nueva. Mover counts = {} al interior del bucle causa otro problema: cada iteración borra los conteos anteriores. Inicializa una vez antes de procesar los elementos.

Decide qué cuenta como la misma palabra

En un texto, las mayúsculas, las minúsculas y la puntuación afectan a las claves. Las cadenas "The" y "the" son distintas, al igual que "dog." y "dog". Normaliza las formas antes de usarlas como claves:

text = "The cat saw the dog. The dog ran."
counts = {}
for word in text.lower().split():
    word = word.strip(".,!?")
    counts[word] = counts.get(word, 0) + 1

Esto produce {'the': 3, 'cat': 1, 'saw': 1, 'dog': 2, 'ran': 1}. lower convierte a minúsculas, split separa las palabras por los caracteres de espacio en blanco y strip elimina de los extremos los signos de puntuación indicados. No elimina signos de puntuación del interior de una palabra.

Encuentra los elementos más frecuentes

Para esta tabla no vacía, max(counts, key=counts.get) devuelve 'the'. Para encontrar las dos palabras más frecuentes, usa sorted(counts, key=counts.get, reverse=True)[:2], que produce ['the', 'dog']. Los conteos iguales mantienen su orden original al ordenarse.

El patrón también cuenta números o tuplas. Para los lanzamientos [3, 6, 3, 1, 6, 3], construye {3: 3, 6: 2, 1: 1}. Un valor que nunca se ha observado no tiene entrada. Léelo con un valor predeterminado de cero cuando resulte útil.

Reconoce el atajo de la biblioteca

from collections import Counter
letter_counts = Counter("banana")
print(letter_counts.most_common(1))
print(letter_counts["z"])

Esto imprime [('a', 3)] y después 0. La importación permite usar Counter, de la biblioteca estándar de Python. Un Counter es un diccionario diseñado para contar: sus claves son elementos aptos para hash y la consulta directa de un elemento ausente devuelve cero. Sus conteos para esta entrada se muestran como Counter({'a': 3, 'n': 2, 'b': 1}).

Un diccionario puede almacenar un grupo completo bajo cada clave. La clave nombra la categoría y una lista contiene los elementos que se le asignan. Así, todos los miembros quedan disponibles para calcular totales, medias o informes posteriores.

Construye listas independientes para los grupos

words = ["apple", "bean", "avocado", "beet", "corn"]
groups = {}
for word in words:
    first = word[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(word)

Para "apple", el programa crea una lista vacía bajo "a" y añade la palabra. "bean" inicia una lista "b" independiente. "avocado" se incorpora a la lista "a" existente. El resultado es {'a': ['apple', 'avocado'], 'b': ['bean', 'beet'], 'c': ['corn']}.

La lista vacía se crea solo para una etiqueta nueva. Crearla en cada iteración descartaría los miembros anteriores de ese grupo.

Abrevia la inicialización

groups.setdefault(word[0], []).append(word) realiza el mismo paso de agrupación. setdefault devuelve la lista existente si la hay. De lo contrario, almacena la lista vacía proporcionada y la devuelve. El append que sigue modifica esa lista devuelta.

Otra opción crea las listas automáticamente:

from collections import defaultdict
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

Pasa list, la función que crea una lista nueva, sin paréntesis. Al consultar una clave ausente, este defaultdict crea y almacena una lista vacía nueva. Incluso una lectura como groups["z"] inserta esa clave ausente. Usa "z" in groups cuando solo quieras comprobar si un grupo existe.

Mantén las listas independientes

groups = dict.fromkeys(["a", "b"], []) coloca la misma lista bajo ambas claves. Añadir 1 mediante groups["a"] produce entonces {'a': [1], 'b': [1]}. Las listas se comparten, no se copian.

Para empezar con listas independientes, usa {key: [] for key in keys}, setdefault con un [] nuevo o defaultdict(list). Cada categoría nueva debe recibir su propio objeto lista.

Suma importes por categoría

El conteo suma uno por aparición. Un total por categoría suma el importe de cada elemento:

expenses = [("food", 12.5), ("travel", 30),
            ("food", 7.25), ("books", 18)]
totals = {}
for category, amount in expenses:
    totals[category] = totals.get(category, 0) + amount

La categoría de alimentación empieza en 12,5 y después suma 7,25, hasta llegar a 19,75. Los viajes suman 30 y los libros suman 18. Almacenar solo amount sustituiría el total anterior en lugar de añadirle el importe.

Calcula la media o elimina duplicados de un grupo

Para scores = {"A": [80, 90], "B": [70]}, recorre scores.items() y calcula sum(values) / len(values). La media del grupo A es 85,0; la del grupo B es 70,0. Comprueba if values: antes de dividir para tratar por separado un grupo vacío.

Cuando las repeticiones deban desaparecer dentro de cada grupo, usa conjuntos como valores. tags.setdefault(post, set()).add(tag) crea un conjunto para una publicación nueva y añade su etiqueta. Una etiqueta repetida sigue siendo un solo elemento; una lista conservaría cada aparición.

Un registro reúne campos relacionados, como la edad, la especialidad y las calificaciones de un estudiante. Un diccionario anidado almacena otro diccionario como valor. Las claves externas pueden identificar registros, mientras que las internas identifican campos.

Lee un nivel cada vez

students = {
    "ana": {"age": 19, "major": "math", "grades": [88, 92]},
    "ben": {"age": 22, "major": "history", "grades": [75, 81, 79]},
}

students["ana"] proporciona el diccionario del registro de Ana. Añadir ["major"] lee su especialidad, así que students["ana"]["major"] devuelve 'math'. Para la última calificación de Ben, students["ben"]["grades"][-1] accede al registro, después a su lista y después al último elemento de la lista, 79.

Cada consulta actúa sobre el objeto devuelto por la consulta anterior. La misma sintaxis de corchetes puede representar una clave de diccionario en un nivel y una posición de lista en otro.

Cambia un campo o añade un registro

students["ana"]["age"] = 20
students["ben"]["email"] = "ben@example.com"
students["cara"] = {"age": 21, "major": "art", "grades": []}
students["cara"]["grades"].append(90)

Las dos primeras líneas modifican o añaden campos dentro de registros existentes. La tercera añade un registro completo bajo un identificador nuevo. La cuarta accede a la lista de calificaciones de Cara y le añade una puntuación.

Asignar students["dev"]["age"] = 30 falla porque la consulta externa de "dev" se realiza primero y lanza KeyError: 'dev'. Crea el registro antes de asignar sus campos.

Para una lectura opcional, students.get("dev", {}).get("age") devuelve None. El primer valor predeterminado es un diccionario vacío, así que el segundo get tiene un diccionario que leer incluso cuando el registro no existe. En estos registros, cada valor externo es a su vez un diccionario.

Elige una estructura adecuada para el acceso

Una lista de diccionarios mantiene las filas en orden:

rows = [{"name": "Ana", "city": "Austin"},
        {"name": "Ben", "city": "Denver"}]
print(rows[1]["city"])

Esto imprime Denver: primero el índice de lista y después la clave del campo. Un diccionario de listas, como {"A": [80, 90], "B": [70]}, almacena varios valores por etiqueta. Estas estructuras pueden combinarse cuando un registro necesita tanto campos con nombre como una lista ordenada.

Cuando los nombres identifican las filas de forma única, construye by_name = {row["name"]: row for row in rows}. Después, by_name["Ben"] encuentra directamente la fila de Ben. Los valores son los diccionarios de fila existentes, así que las modificaciones mediante este índice también afectan a esas filas. Si los nombres se repiten, una fila posterior sustituye a una anterior bajo esa clave.

Copia los datos anidados de forma consciente

backup = students comparte el diccionario completo. backup = students.copy() crea un diccionario externo independiente, pero mantiene los mismos registros internos. Después de esa copia superficial, backup["ana"]["age"] = 99 también cambia la edad de Ana en students.

import copy
independent = copy.deepcopy(students)
independent["ana"]["age"] = 25

Para estos diccionarios y listas anidados, la copia profunda también crea objetos internos independientes. Cambiar la edad copiada deja intacta la original. Usa nombres de campo coherentes entre registros para que el mismo código de consulta funcione con cada registro.

Procesar datos anidados implica seguir en qué nivel se encuentra el bucle. Un bucle externo elige un registro. Una consulta de campo accede a un valor dentro de ese registro, y un bucle interno puede recorrer después los elementos de una lista almacenada.

Resume un registro por iteración

students = {
    "ana": {"major": "math", "grades": [88, 92]},
    "ben": {"major": "history", "grades": [75, 81, 79]},
    "cara": {"major": "art", "grades": []},
}
for name, info in students.items():
    grades = info["grades"]
    major = info["major"]
    if grades:
        average = sum(grades) / len(grades)
        print(f"{name}: {major}, average {average:.1f}")
    else:
        print(f"{name}: {major}, no grades")

Las calificaciones de Ana suman 180, así que su media es 90,0. El total de Ben es 235 entre tres calificaciones, lo que da aproximadamente 78,33; el formato :.1f muestra 78,3. La lista de Cara está vacía, así que el programa imprime cara: art, no grades sin dividir entre cero.

Asignar grades y major dentro del bucle da a cada nombre los valores del registro actual. La media también debe estar dentro del bucle: hay que calcularla por separado para cada estudiante.

Lee campos opcionales

info.get("email", "no email") proporciona un texto para un campo de correo electrónico opcional. Una consulta directa con info["email"] lanzaría KeyError para un registro que no lo tuviera. El valor predeterminado debe situarse en el nivel donde puede faltar el campo. El get del diccionario externo buscaría identificadores de estudiantes, no campos de correo electrónico.

Selecciona registros

math_students = []
for name, info in students.items():
    if info["major"] == "math":
        math_students.append(name)

Esto produce ['ana']. La condición lee un campo del registro actual; el valor añadido es la clave externa. Si el informe necesitara registros completos, podría añadir info en su lugar. Decide qué tipo de resultado necesita la siguiente parte del programa.

Visita cada calificación almacenada

count = 0
for info in students.values():
    for grade in info["grades"]:
        if grade > 80:
            count += 1

El bucle interno visita el 88 y el 92 de Ana, y después el 75, el 81 y el 79 de Ben. La lista vacía de Cara no añade iteraciones. Tres calificaciones superan 80: 88, 92 y 81. El conteo se inicializa fuera de ambos bucles porque describe a todos los estudiantes en conjunto. Reiniciarlo dentro del bucle externo conservaría solo el conteo del último registro.

Cuenta registros por un campo

majors = {}
for info in students.values():
    major = info["major"]
    majors[major] = majors.get(major, 0) + 1

Cada registro aporta uno a su especialidad. Solo con Ana y Ben, el resultado es {'math': 1, 'history': 1}; incluir a Cara añade 'art': 1. Para sumar o agrupar otro campo, conserva el bucle externo de registros y cambia el valor que aporta.

Para obtener informes legibles, imprime una línea con formato por registro en lugar de todo el diccionario anidado. En una cadena formateada, almacena primero un campo en una variable, como arriba, o usa el tipo de comillas opuesto dentro de las llaves, como en f"{name}: {info['major']}".

Un conjunto registra qué valores distintos están presentes. Conserva cada elemento una vez y no tiene un orden garantizado. Los conjuntos son adecuados para comprobar la pertenencia y eliminar duplicados cuando el número de apariciones no importa.

Crea un conjunto

colors = {"red", "green"}
numbers = set([3, 1, 3, 2, 1])
print(len(numbers))
print(sorted(numbers))

Esto imprime 3 y después [1, 2, 3]. Las entradas repetidas se convierten en un solo elemento. Un conjunto vacío es set(); {} crea un diccionario vacío.

set("banana") visita los caracteres de la cadena y deja las letras distintas "a", "b" y "n". {"banana"} proporciona la cadena completa como un elemento. Como ocurre con las claves de diccionario, los valores numéricos iguales cuentan una vez: {1, 1.0, True} tiene un elemento.

Los elementos deben ser aptos para hash. Los números, las cadenas y las tuplas de valores aptos para hash sirven; las listas, los diccionarios y los conjuntos ordinarios no. Usa (1, 2) para un elemento de coordenadas en lugar de [1, 2]. Un frozenset es un conjunto inmutable y puede ser a su vez un elemento de conjunto o una clave de diccionario.

Trabaja sin posiciones

colors[0] lanza TypeError porque un conjunto no tiene posiciones. Su orden de impresión no está garantizado, y los elementos de cadena pueden imprimirse en otro orden en una ejecución distinta. sorted(colors) produce una lista nueva ordenada cuando los elementos se pueden comparar. No asigna un orden al conjunto.

Cambia los miembros

add("blue") añade una cadena. update(["blue", "gold"]) añade dos cadenas. Usar update("blue") añade, en cambio, caracteres separados, porque una cadena es iterable. Los conjuntos no tienen un método append.

Conserva las primeras apariciones cuando sea necesario

list(set(items)) elimina duplicados, pero pierde su orden original. Si las primeras apariciones importan, usa el orden de inserción de los diccionarios:

items = [3, 1, 3, 2, 1]
unique = list(dict.fromkeys(items))
print(unique)

Esto imprime [3, 1, 2]. Los valores se convierten en claves de diccionario, así que cada uno aparece una vez en el orden en que se encontró por primera vez.

También puedes hacer explícitas las funciones de cada colección:

seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

El conjunto responde si un elemento ya ha aparecido; la lista conserva las primeras apariciones en orden. Ambas formas requieren elementos de entrada aptos para hash.

Cuenta elementos distintos o comprueba la pertenencia

Para las ocho palabras de "the cat saw the dog the dog ran".split(), len(set(words)) es 5: the, cat, saw, dog y ran. Esto cuenta palabras diferentes, no sus frecuencias.

Un conjunto de remitentes bloqueados permite que sender in blocked responda si una dirección está presente. En colecciones grandes, comprobar la pertenencia en conjuntos y diccionarios suele ser mucho más rápido que buscar en una lista elemento por elemento.

Las operaciones de conjuntos expresan preguntas sobre la pertenencia a dos colecciones. Usa la operación que corresponda a la pregunta: cualquier miembro de cualquiera de las colecciones, solo los miembros compartidos o los miembros que quedan tras las exclusiones.

Lee las cuatro operaciones

Supón que las inscripciones en los cursos son:

python = {"Ana", "Ben", "Cara", "Dev"}
sql = {"Ben", "Dev", "Eli"}

La unión incluye a los cinco estudiantes una vez. La intersección conserva solo a los dos estudiantes compartidos. La diferencia parte del conjunto de la izquierda y excluye todo lo que esté en el de la derecha. Invertir la diferencia cambia la pregunta: sql - python contiene solo a Eli. La diferencia simétrica conserva las dos partes que no se solapan; equivale a la unión menos la intersección.

Las formas con métodos son python.union(sql), python.intersection(sql), python.difference(sql) y python.symmetric_difference(sql).

Comprueba una relación

a <= b pregunta si todos los miembros de a pertenecen a b. Esa es la comprobación de subconjunto. a < b exige además que b tenga al menos un miembro adicional, lo que convierte a a en un subconjunto propio. a >= b y a > b comprueban las relaciones de superconjunto correspondientes.

print({"Ben"} <= sql)
print(sql <= sql)
print(sql < sql)
print(python.isdisjoint(sql))

Esto imprime True, True, False y False. Un conjunto es subconjunto de sí mismo, pero no subconjunto propio de sí mismo. Los conjuntos disjuntos no tienen ningún miembro compartido; Python y SQL comparten a Ben y Dev. Los métodos issubset e issuperset también devuelven resultados booleanos.

Mantén los resultados separados o modifica un conjunto

result = a | b crea un conjunto nuevo y deja ambas entradas sin cambios. Las formas a |= b, a &= b, a -= b y a ^= b modifican el objeto a original para que contenga la unión, la intersección, la diferencia o la diferencia simétrica. Cualquier otro nombre que haga referencia a ese mismo conjunto refleja el cambio.

Los métodos de conjuntos aceptan iterables como las listas. python.union(["Fay"]) funciona. Los operadores ordinarios de conjuntos requieren operandos de tipo conjunto: {"a"} | ["b"] lanza TypeError.

Usa | para combinar conjuntos, no +. Distingue también & de and: {1, 2} and {3} devuelve {3} porque el conjunto de la izquierda se considera verdadero (truthy). No calcula los miembros comunes.

Encuentra los requisitos que faltan

required = {"python", "sql", "git"}
skills = {"python", "excel", "git"}
missing = required - skills
extra = skills - required
qualified = required <= skills

El conjunto de competencias que faltan contiene "sql"; el de competencias adicionales contiene "excel". La intersección contiene "git" y "python". qualified es False porque falta al menos una competencia obligatoria. Una persona candidata puede tener muchas competencias y aun así no superar la comprobación de subconjunto: todos los miembros requeridos deben estar presentes.

Elige una colección según la tarea que deba realizar el programa con ella. El orden, las repeticiones, la consulta por nombre y la posibilidad de modificarla son necesidades distintas. Un programa puede usar varios tipos de colecciones porque las diferentes partes de sus datos cumplen funciones distintas.

Compara las colecciones incorporadas

Una lista es adecuada para una secuencia de eventos: el orden importa y el mismo evento puede ocurrir más de una vez. Una tupla es adecuada para un grupo fijo de valores relacionados, como unas coordenadas. Una tupla puede contener un objeto mutable, así que sus posiciones fijas no hacen inmutables todos los objetos que contiene. Solo una tupla de elementos aptos para hash puede ser una clave de diccionario o un elemento de conjunto.

Un diccionario es adecuado para información con nombre: un identificador lleva a un registro o el nombre de un producto lleva a una cantidad. Sus valores pueden repetirse y pueden ser colecciones completas. Un conjunto es adecuado para una pregunta de pertenencia: el programa necesita saber si un identificador está presente, no un valor separado asociado a él.

Conserva la información que necesita la tarea

Convertir [1, 2, 1] en un conjunto pierde tanto la aparición repetida como la secuencia. Esto resulta útil para una lista de elementos distintos, pero es incorrecto para un registro completo de eventos. Un diccionario como {"reader": True, "editor": True} puede convertirse a menudo en {"reader", "editor"} cuando los valores no aportan información adicional. Si cada rol necesita un nivel de permisos, conserva el diccionario.

La igualdad sigue el significado de cada colección. [1, 2] == [2, 1] es False porque el orden de la secuencia es distinto. {1, 2} == {2, 1} es True. Los diccionarios con pares clave-valor iguales son iguales al compararlos aunque las claves se hayan insertado en órdenes diferentes. Su orden de inserción afecta a la iteración, no a esa prueba de igualdad.

Compara claves de diccionario como conjuntos

store_a = {"pens": 10, "pads": 4, "ink": 2}
store_b = {"pads": 7, "clips": 30, "ink": 5}
common = store_a.keys() & store_b.keys()
only_a = store_a.keys() - store_b.keys()

Las claves comunes son "ink" y "pads"; only_a contiene "pens". Son los productos que se venden, independientemente de sus cantidades. Las dos tiendas tienen distintas cantidades de tinta, pero la tinta sigue siendo una clave compartida.

Las vistas de claves de diccionario admiten operaciones de conjuntos porque las claves son únicas y aptas para hash. Las vistas de valores no admiten estos operadores: store_a.values() & {1} lanza TypeError. Es posible convertir los valores en un conjunto cuando son aptos para hash, pero eso descarta los valores repetidos y plantea una pregunta distinta de comparar las claves de productos.

Combina estructuras en un programa

Una biblioteca puede usar un diccionario de identificadores de libros asociados a diccionarios de registro, un conjunto de identificadores de libros actualmente prestados y una lista de los préstamos de hoy en orden cronológico. Una tupla como ("Dune", 1965) mantiene juntos un título y un año. El diccionario encuentra los detalles de un libro; el conjunto comprueba si está prestado; la lista conserva el historial del día.