Semestre 02, 2026
Se requiere guardar la nota de cada estudiante de una sección.
estudiantes = ["Ana", "Carlos", "María"]
notas = [85, 90, 78]
La única relación entre un nombre y su nota es que ocupan la misma posición en dos listas distintas. Para saber la nota de Carlos hay que saber primero que Carlos está en el índice uno.
estudiantes.insert(1, "Luis")
print(estudiantes[1], notas[1]) # Luis 90
Al insertar un nombre en una lista y no en la otra, todas las notas siguientes quedan asignadas a la persona equivocada. Python no produce ningún error, así que la falla pasa desapercibida.
| Clave | Valor |
|---|---|
| "Ana" | 85 |
| "Carlos" | 90 |
| "María" | 78 |
Cada nota debe quedar unida al nombre que la identifica, sin depender de una posición. Esa asociación directa es la que modela un diccionario.
Un diccionario es una colección de pares clave y valor. Cada valor se obtiene a partir de su clave, no de una posición.
notas = {
"Ana": 85,
"Carlos": 90,
"María": 78
}
La clave se escribe entre corchetes, igual que un índice en una lista.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
print(notas["Ana"]) # 85
print(notas["Carlos"]) # 90
La expresión notas["Ana"] se lee como el valor asociado a la clave "Ana" dentro de notas.
| Lista | Diccionario | |
|---|---|---|
| Delimitador | [ ] | { } |
| Acceso | notas[0] | notas["Ana"] |
| Se ubica por | Posición numérica | Clave descriptiva |
| Significado | Depende del orden | Lo describe la clave |
| Elementos repetidos | Permitidos | Claves únicas |
persona = {
"nombre": "Ana",
"edad": 22,
"activa": True,
"cursos": ["CC2005", "CC3062"]
}
Un diccionario puede describir una sola entidad con varios campos nombrados. Los valores pueden ser números, textos, booleanos e incluso listas.
notas = {"Ana": 85, "Carlos": 90, "Ana": 92}
print(notas) # {'Ana': 92, 'Carlos': 90}
Python no reporta la clave duplicada. La segunda aparición reemplaza el valor de la primera y el diccionario conserva un solo par.
notas = {"Ana": 85, "Carlos": 90}
notas["Ana"] = 92 # la clave existe
notas["María"] = 78 # la clave es nueva
print(notas) # {'Ana': 92, 'Carlos': 90, 'María': 78}
La misma instrucción cumple dos funciones. Si la clave ya existe se actualiza su valor, y si no existe se agrega el par al final.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
del notas["Carlos"]
print(notas) # {'Ana': 85, 'María': 78}
del elimina la clave junto con su valor. Si la clave no existe produce un KeyError.
notas = {"Ana": 85, "Carlos": 90}
if "Ana" in notas:
print("Ana está registrada")
if "Luis" not in notas:
print("Luis no está registrado")
El operador in busca entre las claves, no entre los valores. La expresión 85 in notas da False.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
print(len(notas)) # 3
print(len({})) # 0
len devuelve la cantidad de pares clave y valor que contiene el diccionario.
notas = {"Ana": 85}
print(notas["Luis"]) # KeyError: 'Luis'
El acceso con corchetes exige que la clave exista. Si no existe, el programa se detiene con un KeyError.
notas = {"Ana": 85}
print(notas.get("Luis")) # None
print(notas.get("Luis", 0)) # 0
print(notas.get("Ana", 0)) # 85
get(clave, defecto) devuelve el valor si la clave existe y el valor por defecto si no existe. Sin segundo argumento el valor por defecto es None.
| Situación | Forma de acceso |
|---|---|
| La clave siempre debe existir | notas["clave"] |
| La clave puede no existir | notas.get("clave", defecto) |
| Se necesita saber si existe | "clave" in notas |
Si una clave ausente indica un error del programa, conviene que los corchetes lo detengan. get es para los casos en que la ausencia es normal.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
print(notas.keys())
# dict_keys(['Ana', 'Carlos', 'María'])
keys devuelve una vista con todas las claves. Se puede recorrer con for o convertir a lista con list.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
print(notas.values())
# dict_values([85, 90, 78])
values devuelve una vista con todos los valores, en el mismo orden que sus claves.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
print(notas.items())
# dict_items([('Ana', 85), ('Carlos', 90), ('María', 78)])
items devuelve cada par como una tupla de dos elementos, con la clave primero y el valor después.
base = {"Ana": 85, "Carlos": 90}
nuevos = {"María": 78, "Ana": 92}
base.update(nuevos)
print(base) # {'Ana': 92, 'Carlos': 90, 'María': 78}
update copia los pares de otro diccionario. Las claves que ya existían se actualizan y las nuevas se agregan.
notas = {"Ana": 85, "Carlos": 90}
valor = notas.pop("Carlos")
print(valor) # 90
print(notas) # {'Ana': 85}
pop elimina el par y devuelve el valor eliminado. A diferencia del pop de listas, recibe una clave y no una posición.
| Método | Qué hace | Modifica |
|---|---|---|
| keys() | Devuelve las claves | No |
| values() | Devuelve los valores | No |
| items() | Devuelve los pares | No |
| get(k, d) | Valor de k, o d si no existe | No |
| update(otro) | Fusiona otro diccionario | Sí |
| pop(k) | Elimina y devuelve el valor de k | Sí |
notas = {"Ana": 85, "Carlos": 90, "María": 78}
for nombre in notas:
print(nombre, notas[nombre])
Se imprime Ana 85, Carlos 90 y María 78. Recorrer el diccionario directamente entrega las claves, y con cada clave se obtiene su valor.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
for nombre, nota in notas.items():
print(f"{nombre}: {nota}")
items entrega cada par como una tupla, y el for la separa en dos variables. Es la forma más legible cuando se necesitan ambos datos.
Se requiere el promedio de todas las notas registradas.
notas = {"Ana": 85, "Carlos": 90, "María": 78}
total = 0
for nota in notas.values():
total = total + nota
promedio = total / len(notas)
print(f"Promedio: {promedio}") # Promedio: 84.33333333333333
Se requiere contar cuántos votos recibió cada candidato.
votos = ["A", "B", "A", "C", "A", "B"]
conteo = {}
for voto in votos:
conteo[voto] = conteo.get(voto, 0) + 1
print(conteo) # {'A': 3, 'B': 2, 'C': 1}
get con valor por defecto cero permite sumar sin verificar antes si el candidato ya tenía votos.
Una lista de diccionarios combina las dos estructuras del curso. Cada diccionario describe un registro completo con campos nombrados, y la lista guarda todos los registros en orden.
estudiantes = [
{"nombre": "Ana", "nota": 85, "seccion": "A"},
{"nombre": "Carlos", "nota": 90, "seccion": "B"},
{"nombre": "María", "nota": 78, "seccion": "A"},
{"nombre": "Luis", "nota": 58, "seccion": "B"},
]
Todos los diccionarios comparten las mismas claves. Esa coincidencia es la que permite leer la lista como una tabla con columnas fijas.
| Índice | nombre | nota | seccion |
|---|---|---|---|
| 0 | Ana | 85 | A |
| 1 | Carlos | 90 | B |
| 2 | María | 78 | A |
| 3 | Luis | 58 | B |
Una hoja de cálculo, un archivo CSV y una tabla de base de datos tienen esta misma forma.
print(estudiantes[0])
# {'nombre': 'Ana', 'nota': 85, 'seccion': 'A'}
print(estudiantes[0]["nombre"]) # Ana
print(estudiantes[2]["nota"]) # 78
El primer corchete recibe un índice y entrega un diccionario completo. El segundo recibe una clave y entrega un campo de esa fila.
for estudiante in estudiantes:
print(estudiante["nombre"], estudiante["nota"])
Se imprime una línea por estudiante, desde Ana 85 hasta Luis 58. En cada vuelta la variable del ciclo es un diccionario completo, no un número.
Se requiere la lista de estudiantes con nota aprobatoria, de 61 en adelante.
aprobados = []
for estudiante in estudiantes:
if estudiante["nota"] >= 61:
aprobados.append(estudiante)
print(len(aprobados)) # 3
aprobados contiene los diccionarios de Ana, Carlos y María. El resultado es otra lista de diccionarios con la misma forma.
nuevo = {"nombre": "Sofía", "nota": 95, "seccion": "A"}
estudiantes.append(nuevo)
print(len(estudiantes)) # 5
Agregar una fila es agregar un diccionario a la lista con append. El nuevo registro debe tener las mismas claves que los demás.
estudiantes[3]["nota"] = 64
print(estudiantes[3])
# {'nombre': 'Luis', 'nota': 64, 'seccion': 'B'}
El índice ubica la fila y la clave ubica el campo. La asignación cambia solo ese valor y deja intactos los demás campos y registros.
Se requiere el promedio de la columna nota.
total = 0
for estudiante in estudiantes:
total = total + estudiante["nota"]
promedio = total / len(estudiantes)
print(promedio) # 77.75
Se requieren los datos completos de María a partir de su nombre.
encontrado = None
for estudiante in estudiantes:
if estudiante["nombre"] == "María":
encontrado = estudiante
print(encontrado)
# {'nombre': 'María', 'nota': 78, 'seccion': 'A'}
Si ningún registro coincide, encontrado conserva None. Ese valor indica que la búsqueda no tuvo resultado.
Se requiere el estudiante con la mejor nota, sin usar funciones ya hechas.
mejor = estudiantes[0]
for estudiante in estudiantes:
if estudiante["nota"] > mejor["nota"]:
mejor = estudiante
print(mejor["nombre"], mejor["nota"]) # Carlos 90
Es el mismo algoritmo del mayor de una lista. La diferencia es que se guarda el registro completo, así que el nombre llega junto con la nota.
CSV significa Comma Separated Values. Es un archivo de texto en el que cada línea es un registro y los campos se separan con comas.
estudiantes.csv
nombre,nota,seccion
Ana,85,A
Carlos,90,B
María,78,A
Luis,58,B
La primera línea contiene los encabezados, que serán las claves. Cada línea siguiente es un registro, que será un diccionario.
archivo = open("estudiantes.csv", "r")
lineas = archivo.readlines()
archivo.close()
encabezados = lineas[0].strip().split(",")
estudiantes = []
for linea in lineas[1:]:
valores = linea.strip().split(",")
fila = {}
for i in range(len(encabezados)):
fila[encabezados[i]] = valores[i]
estudiantes.append(fila)
archivo = open("estudiantes.csv", "r")
lineas = archivo.readlines()
archivo.close()
encabezados = lineas[0].strip().split(",")
estudiantes = []
for linea in lineas[1:]:
valores = linea.strip().split(",")
fila = {}
for i in range(len(encabezados)):
fila[encabezados[i]] = valores[i]
estudiantes.append(fila)
readlines lee el archivo completo y devuelve una lista de strings, una por línea. Después de leerlo, el archivo se cierra.
archivo = open("estudiantes.csv", "r")
lineas = archivo.readlines()
archivo.close()
encabezados = lineas[0].strip().split(",")
estudiantes = []
for linea in lineas[1:]:
valores = linea.strip().split(",")
fila = {}
for i in range(len(encabezados)):
fila[encabezados[i]] = valores[i]
estudiantes.append(fila)
strip quita el salto de línea del final y split separa por comas. La primera línea produce ['nombre', 'nota', 'seccion'].
archivo = open("estudiantes.csv", "r")
lineas = archivo.readlines()
archivo.close()
encabezados = lineas[0].strip().split(",")
estudiantes = []
for linea in lineas[1:]:
valores = linea.strip().split(",")
fila = {}
for i in range(len(encabezados)):
fila[encabezados[i]] = valores[i]
estudiantes.append(fila)
El slice omite la línea de encabezados. Cada línea restante se separa en sus valores, por ejemplo ['Ana', '85', 'A'].
archivo = open("estudiantes.csv", "r")
lineas = archivo.readlines()
archivo.close()
encabezados = lineas[0].strip().split(",")
estudiantes = []
for linea in lineas[1:]:
valores = linea.strip().split(",")
fila = {}
for i in range(len(encabezados)):
fila[encabezados[i]] = valores[i]
estudiantes.append(fila)
El ciclo interno une cada encabezado con el valor de la misma posición. Así las dos listas se convierten en un diccionario.
archivo = open("estudiantes.csv", "r")
lineas = archivo.readlines()
archivo.close()
encabezados = lineas[0].strip().split(",")
estudiantes = []
for linea in lineas[1:]:
valores = linea.strip().split(",")
fila = {}
for i in range(len(encabezados)):
fila[encabezados[i]] = valores[i]
estudiantes.append(fila)
Cada diccionario se agrega a la lista. Al terminar, el archivo completo quedó convertido en una lista de diccionarios.
print(estudiantes[0])
# {'nombre': 'Ana', 'nota': '85', 'seccion': 'A'}
for fila in estudiantes:
fila["nota"] = int(fila["nota"])
Un archivo CSV no guarda tipos de dato, así que la nota llega como el string '85'. Cada campo numérico debe convertirse a mano antes de operar con él.
import csv
archivo = open("estudiantes.csv", "r")
estudiantes = list(csv.DictReader(archivo))
archivo.close()
La biblioteca estándar de Python incluye DictReader, que hace el mismo trabajo del ciclo anterior y entrega una lista de diccionarios. Los valores siguen llegando como texto.