Patrones de operaciones y errores frecuentes al manipular variables, listas y diccionarios

Patrones esenciales al operar con variables

Patrón 1: inicialización correcta y explícita

Muchos fallos aparecen cuando una variable se usa antes de tener un valor válido, o cuando se reutiliza una variable con un significado distinto dentro del mismo flujo. El patrón es: inicializa con un valor neutro coherente y mantén un propósito por variable.

• Contadores: empezar en 0
• Acumuladores numéricos: empezar en 0 o 0.0
• Acumuladores de texto: empezar en ""
• Mejor candidato encontrado: empezar en null/None y validar antes de usar

# Ejemplo (pseudocódigo): buscar el mayor valor en una lista de números
maximo = None
para cada n en numeros:
  si maximo es None o n > maximo:
    maximo = n
# Validación antes de usar
si maximo es None:
  error("lista vacía")

Error típico: sobrescritura accidental de variables

Ocurre cuando reutilizas el mismo nombre para cosas distintas (por ejemplo, una lista y luego un número), o cuando una variable de control pisa un valor importante.

# Fallo intencional
usuarios = ["Ana", "Luis", "Marta"]
para cada usuarios en usuarios:   # 'usuarios' se sobrescribe con cada elemento
  imprimir(usuarios)
# Al final, 'usuarios' ya no es la lista

Corrección: usa nombres distintos para colección y elemento.

usuarios = ["Ana", "Luis", "Marta"]
para cada usuario en usuarios:
  imprimir(usuario)

Patrones seguros al operar con listas

Patrón 2: actualización segura (comprobaciones de límites)

Antes de acceder por índice, valida que el índice existe. Este patrón evita errores de “fuera de rango” y también evita leer/modificar el elemento equivocado.

# Fallo intencional
pos = 3
val = lista[pos]   # si lista tiene longitud 3, el último índice es 2

Guía paso a paso para corregirlo:

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

• 1) Calcula n = longitud(lista).
• 2) Verifica 0 <= pos < n.
• 3) Solo entonces accede o actualiza.

n = longitud(lista)
si 0 <= pos y pos < n:
  val = lista[pos]
si no:
  error("índice inválido")

Error típico: confundir índice con valor

En recorridos, es común tratar el valor como si fuera un índice (o al revés). Esto produce lecturas incorrectas o errores de rango.

# Fallo intencional
edades = [18, 21, 30]
para cada edad en edades:
  imprimir(edades[edad])  # usa 'edad' como índice (18, 21, 30)

Corrección: si necesitas índice y valor, recórrelos juntos.

para cada (i, edad) en enumerar(edades):
  imprimir(i, edad)

Patrón 3: recorrer sin modificar la colección de forma insegura

Modificar una lista mientras la recorres puede saltarse elementos, duplicar trabajo o generar resultados inesperados. Patrones recomendados:

• Filtrar creando una nueva lista (más claro y seguro).
• Recorrer una copia si necesitas eliminar de la original.
• Recorrer al revés si eliminas por índice (reduce desplazamientos).

# Fallo intencional: eliminar pares mientras se recorre
nums = [1, 2, 3, 4, 5, 6]
para cada n en nums:
  si n es par:
    eliminar n de nums

Corrección (filtrado):

nums = [1, 2, 3, 4, 5, 6]
solo_impares = []
para cada n en nums:
  si n no es par:
    agregar n a solo_impares
nums = solo_impares

Error típico: mutaciones inesperadas por alias (referencias compartidas)

Dos variables pueden apuntar a la misma lista. Si modificas una, cambia la otra. Esto sorprende cuando se esperaba una copia.

# Fallo intencional
original = ["A", "B"]
copia = original
agregar "C" a copia
# original ahora también contiene "C"

Prevención: crea una copia explícita cuando el objetivo sea independizar.

original = ["A", "B"]
copia = copiar_lista(original)  # por ejemplo, slice, clone o copy según lenguaje
agregar "C" a copia

Patrones seguros al operar con diccionarios

Patrón 4: validaciones antes de acceder (verificación de pertenencia)

Acceder a una clave que no existe es uno de los errores más frecuentes. El patrón es: verifica pertenencia o usa valores por defecto.

# Fallo intencional
precios = {"pan": 1.2, "leche": 1.5}
imprimir(precios["huevos"])  # clave faltante

Corrección A (pertenencia):

si "huevos" en precios:
  imprimir(precios["huevos"])
si no:
  imprimir("sin precio")

Corrección B (valor por defecto):

precio = obtener_con_defecto(precios, "huevos", 0)
imprimir(precio)

Error típico: duplicados no controlados (sobrescritura de claves)

En diccionarios, una clave repetida no crea “dos entradas”; normalmente sobrescribe el valor anterior. Esto puede ocultar datos y generar inconsistencias.

# Fallo intencional
producto = {}
producto["id"] = 10
producto["id"] = 11  # sobrescribe sin avisar

Prevención: valida antes de insertar si la clave debe ser única, o usa una estructura que represente multiplicidad (por ejemplo, lista de registros) cuando esperas repetidos.

si "id" en producto:
  error("id duplicado")
si no:
  producto["id"] = 10

Patrón 5: actualización segura de contadores y acumuladores por clave

Un patrón común es contar ocurrencias o acumular importes por categoría. El error típico es asumir que la clave ya existe. Usa “inicialización perezosa” con valor por defecto.

# Fallo intencional
conteo = {}
para cada palabra en palabras:
  conteo[palabra] = conteo[palabra] + 1  # falla si no existe

Corrección (con defecto):

conteo = {}
para cada palabra en palabras:
  actual = obtener_con_defecto(conteo, palabra, 0)
  conteo[palabra] = actual + 1

Desincronización entre estructuras paralelas (y cómo evitarla)

Un error frecuente es mantener dos listas relacionadas por índice (por ejemplo, nombres[i] y edades[i]). Si insertas, eliminas o reordenas una lista y olvidas aplicar lo mismo a la otra, los datos quedan desalineados.

Mini-caso con fallo intencional

nombres = ["Ana", "Luis", "Marta"]
edades  = [20,  25,    30]
# Se elimina a "Luis" solo en nombres
eliminar_en_indice(nombres, 1)
# Ahora nombres[1] es "Marta" pero edades[1] sigue siendo 25

Estrategias de prevención (preferir estructuras que reduzcan ambigüedad)

• Unir los datos en una sola estructura (registro/objeto/diccionario por persona) y manejar una sola colección.
• Si debes usar paralelas, encapsula operaciones (insertar/eliminar/reordenar) en funciones que actualicen ambas a la vez.

# En vez de paralelas, una sola lista de registros
personas = [
  {"nombre": "Ana", "edad": 20},
  {"nombre": "Luis", "edad": 25},
  {"nombre": "Marta", "edad": 30}
]
# Eliminar por condición en una sola estructura
personas = [p para cada p en personas si p["nombre"] != "Luis"]

Checklist de prevención (aplicable a variables, listas y diccionarios)

Ejercicios de diagnóstico (corrige el fallo)

Ejercicio 1: contador por categoría

categorias = ["A", "B", "A", "C"]
conteo = {}
para cada c en categorias:
  conteo[c] = conteo[c] + 1
imprimir(conteo)

• Identifica el error exacto.
• Corrige usando un valor por defecto.

Ejercicio 2: eliminación durante recorrido

tareas = ["ok", "pendiente", "ok", "pendiente"]
para cada t en tareas:
  si t == "ok":
    eliminar t de tareas
imprimir(tareas)

• Explica por qué el resultado puede ser inesperado.
• Reescribe usando filtrado a una nueva lista.

Ejercicio 3: desincronización

productos = ["pan", "leche", "café"]
precios   = [1.2,   1.5,     3.0]
ordenar(productos)
# Se imprime producto con su precio por índice
para i desde 0 hasta longitud(productos)-1:
  imprimir(productos[i], precios[i])

• Detecta el problema lógico.
• Propón una estructura alternativa que evite paralelas.

Ejercicio 4: sobrescritura accidental

total = 0
valores = [5, 10, 15]
para cada total en valores:
  total = total + 1
imprimir(total)

• ¿Qué variable se está pisando?
• Renombra y corrige para que el resultado sea la suma de valores.