Apuntes de Python

Apariencia

📙 Clase 04 — Diccionarios ​

Fase 1 · Estructuras de datos y bucles ⬅️ Volver al índice de clases

🎯 Qué aprendí ​

  • Qué es un diccionario ({clave: valor}) y por qué es la estructura más usada de Python.
  • Leer con seguridad (get), agregar, actualizar y borrar entradas.
  • Recorrerlo con .items() y el puente clave: un diccionario = una fila de base de datos.

📖 PARTE TEÓRICA ​

🗂️ 1. ¿Qué es un diccionario? ​

Un diccionario guarda datos como pares clave → valor. En vez de acceder por posición (como la lista), accedes por un nombre (la clave). Se escribe con llaves {}.

python
persona = {
    "nombre": "Styp",
    "edad": 30,
    "pais": "Perú",
}

Compara con una lista: en la lista preguntas "¿qué hay en la posición 0?"; en el diccionario preguntas "¿qué hay en la clave nombre?".

LISTA (por posición)          DICCIONARIO (por nombre)
[0] "Styp"                     "nombre" → "Styp"
[1] 30                         "edad"   → 30
[2] "Perú"                     "pais"   → "Perú"

💡 Un diccionario es perfecto para representar "una cosa con varios atributos": una persona, un producto, un contacto, una tarea con fecha y prioridad…

🔑 2. Leer valores: [clave] vs .get() ​

python
persona = {"nombre": "Styp", "edad": 30}
print(persona["nombre"])          # Styp
print(persona.get("pais"))        # None   (no existe, pero NO se cae)
print(persona.get("pais", "?"))   # ?      (valor por defecto si no existe)
FormaSi la clave existeSi NO existe
dic["clave"]devuelve el valor💥 KeyError (la app se cae)
dic.get("clave")devuelve el valordevuelve None (seguro)
dic.get("clave", x)devuelve el valordevuelve x (tu valor por defecto)

⚠️ persona["telefono"] cuando telefono no existe lanza KeyError. En una app, si no estás seguro de que la clave está, usa .get() con un valor por defecto.

✏️ 3. Agregar, actualizar y borrar ​

Asignar a una clave que existe la actualiza; a una que no existe, la crea.

python
persona = {"nombre": "Styp", "edad": 30}
persona["pais"] = "Perú"     # AGREGA  → {'nombre':'Styp','edad':30,'pais':'Perú'}
persona["edad"] = 31         # ACTUALIZA (la clave ya existía)
del persona["pais"]          # BORRA la clave 'pais'
edad = persona.pop("edad")   # SACA y devuelve el valor (edad = 31)

👀 4. Recorrer: claves, valores e items ​

python
persona = {"nombre": "Styp", "edad": 31}

print(list(persona.keys()))     # ['nombre', 'edad']       ← las claves
print(list(persona.values()))   # ['Styp', 31]             ← los valores
print(list(persona.items()))    # [('nombre','Styp'), ('edad',31)]  ← pares

# La forma pythónica de recorrerlo (clave y valor a la vez):
for clave, valor in persona.items():
    print(f"{clave} → {valor}")
# nombre → Styp
# edad → 31

Comprobar si una clave existe (útil antes de leerla):

python
if "nombre" in persona:      # 'in' mira las CLAVES
    print("Sí tiene nombre")

🧪 Tip de entrevista: "¿Cómo recorres un diccionario con clave y valor?" → con for k, v in dic.items(). Y "clave in dic" comprueba entre las claves, no los valores.

🪆 5. Diccionarios anidados y listas de diccionarios ​

Los valores pueden ser cualquier cosa: otro diccionario, una lista… Así modelas datos reales.

python
# Una agenda: clave = nombre, valor = un dict con sus datos
agenda = {
    "Ana": {"tel": "999-111", "email": "ana@x.com"},
    "Luis": {"tel": "988-222", "email": "luis@x.com"},
}
print(agenda["Ana"]["tel"])     # 999-111  (dict dentro de dict)

# O una lista de diccionarios (cada dict = un registro):
contactos = [
    {"nombre": "Ana",  "tel": "999-111"},
    {"nombre": "Luis", "tel": "988-222"},
]

💡 "Lista de diccionarios" es EL patrón para guardar muchos registros: una lista donde cada elemento es un diccionario con la misma forma. Es, literalmente, una tabla.

🖥️ EN TU APP DE ESCRITORIO ​

Un diccionario es la forma natural de recoger un formulario: cada campo → una clave.

python
def guardar_contacto():
    contacto = {
        "nombre": entry_nombre.get(),   # cada CTkEntry.get() → un valor del dict
        "tel":    entry_tel.get(),
        "email":  entry_email.get(),
    }
    contactos.append(contacto)          # lista de diccionarios = tu "tabla" en memoria
    pintar_lista()

Y para pintar cada registro recorres la lista de diccionarios:

python
for c in contactos:
    texto = f"{c['nombre']} — {c['tel']}"
    ctk.CTkLabel(lista, text=texto).pack(anchor="w")
En tu appEl diccionario representa
Formulario de registrolos campos capturados (nombre, email, …)
Agenda de contactoscada contacto (nombre, tel, email)
To-Do avanzadacada tarea (texto, hecha, prioridad)
Config de la appajustes (tema, idioma, tamaño_fuente)

💡 Tu Ejercicio 3 · Agenda es exactamente esto: una lista de diccionarios, uno por contacto.

🗄️ CON BASE DE DATOS (el puente principal) ​

Aquí está la idea que hace que todo encaje: un diccionario ES una fila de una tabla. Las claves son las columnas; los valores, los datos de esa fila.

DICCIONARIO en Python            FILA en la tabla 'contactos'
{                                ┌─────────┬──────────┐
  "nombre": "Ana",     ─────▶    │ nombre  │ tel      │
  "tel":    "999-111",           ├─────────┼──────────┤
}                                │ Ana     │ 999-111  │
                                 └─────────┴──────────┘

Por eso, cuando llegues a SQLite (Fase 6), insertar un diccionario es directo — SQLite acepta parámetros con nombre :clave que casan con las claves del dict:

python
import sqlite3
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE contactos (nombre TEXT, tel TEXT)")

contacto = {"nombre": "Ana", "tel": "999-111"}      # ← el MISMO dict del formulario
con.execute("INSERT INTO contactos (nombre, tel) VALUES (:nombre, :tel)", contacto)
con.commit()

# Y al leer, puedes recuperar cada fila COMO un diccionario:
con.row_factory = sqlite3.Row
fila = con.execute("SELECT * FROM contactos").fetchone()
print(dict(fila))     # {'nombre': 'Ana', 'tel': '999-111'}   ← ¡de vuelta a un dict!

🗄️ Conclusión que vale oro: si diseñas tus datos como diccionarios desde ahora, el día que agregues base de datos casi no cambias nada: el mismo dict que llenó el formulario es el que se guarda como fila. Por eso empezamos a pensar en diccionarios ya.

🏋️ EJERCICIOS CON SOLUCIÓN ​

Ejercicio 1 — Ficha de producto ​

Crea un diccionario producto con nombre="Teclado", precio=120, stock=5. Imprime "Teclado cuesta 120 (quedan 5)".

Ver solución
python
producto = {"nombre": "Teclado", "precio": 120, "stock": 5}
print(f"{producto['nombre']} cuesta {producto['precio']} (quedan {producto['stock']})")
# Teclado cuesta 120 (quedan 5)

Ejercicio 2 — Lectura segura ​

Del producto anterior, intenta leer la clave "color" sin que el programa se caiga; si no existe, muestra "sin color".

Ver solución
python
print(producto.get("color", "sin color"))   # sin color  (usa .get, no producto["color"])

Ejercicio 3 — Recorrer una ficha ​

Recorre el diccionario producto e imprime cada campo como "clave: valor".

Ver solución
python
for clave, valor in producto.items():
    print(f"{clave}: {valor}")
# nombre: Teclado
# precio: 120
# stock: 5

Ejercicio 4 — Mini agenda (lista de dicts) ​

Crea una lista agenda con dos contactos (dicts con nombre y tel). Recórrela e imprime "nombre → tel" de cada uno.

Ver solución
python
agenda = [
    {"nombre": "Ana",  "tel": "999-111"},
    {"nombre": "Luis", "tel": "988-222"},
]
for c in agenda:
    print(f"{c['nombre']} → {c['tel']}")
# Ana → 999-111
# Luis → 988-222

❓ Preguntas y respuestas (autoevaluación) ​

1. ¿Con qué símbolo se crea un diccionario y cómo accedes a un valor?

Con llaves {}; accedes por su clave: dic["clave"] o, seguro, dic.get("clave").

2. ¿Qué pasa si haces dic["x"] y la clave x no existe?

Lanza KeyError y el programa se cae. Usa dic.get("x", valor_por_defecto) para evitarlo.

3. ¿Cómo recorres un diccionario obteniendo clave y valor a la vez?

Con for clave, valor in dic.items():.

4. ¿Por qué un diccionario es el mejor amigo de una base de datos?

Porque un diccionario = una fila (claves = columnas). El mismo dict del formulario se inserta como fila y se recupera como dict.

📎 Apuntes relacionados ​

➡️ Siguiente ​

Clase 05 · Tuplas y sets — colecciones inmutables y sin duplicados.