Todos los cursos > Informática ( TI ) > Lógica de programación ::

Selección de estructura según la operación: buscar, agregar y eliminar

Capítulo 3

Tiempo estimado de lectura: 8 minutos

Marco de decisión: ¿variable o lista según la operación?

Cuando estás programando, la elección entre guardar datos en una variable (un solo valor) o en una lista (varios valores) suele depender menos de “qué se ve más bonito” y más de qué operaciones harás con más frecuencia: buscar, agregar y eliminar. En este capítulo construiremos un marco práctico para decidir, usando escenarios típicos y una idea intuitiva de rendimiento: algunas operaciones son rápidas porque tocan pocos elementos; otras son lentas porque obligan a revisar o mover muchos.

Idea intuitiva de “rápido” y “lento” (sin fórmulas)

Piensa en una lista como una fila de tarjetas sobre la mesa. Si necesitas encontrar una tarjeta por su contenido, quizá tengas que mirar una por una hasta dar con ella (lento cuando hay muchas). Si necesitas agregar una tarjeta al final, solo la pones al final (rápido). Si necesitas insertar una tarjeta en medio, debes correr varias tarjetas para hacer espacio (más lento).

Rápido: tocar 1 elemento o muy pocos (por ejemplo, tomar el último, agregar al final).
Más lento: revisar muchos elementos (buscar por contenido) o mover muchos (insertar/eliminar en medio).

Guía paso a paso para elegir estructura

Paso 1: ¿Cuántos elementos necesitas guardar?

Siempre 1 (o estrictamente uno a la vez): usa variable.
Varios (o no sabes cuántos): usa lista.

Paso 2: ¿Necesitas mantener un orden?

No importa el orden y solo guardarás 1 valor: variable.
Importa el orden (por llegada, por prioridad, por posición): lista.

Paso 3: ¿Qué consultas harás?

“Necesito el último elemento”: lista (tomar el último suele ser rápido).
“Necesito encontrar si existe X”: lista funciona, pero si esto es muy frecuente y la lista crece, la búsqueda puede volverse lenta (porque revisa uno por uno).
“Necesito insertar en posiciones específicas”: lista lo permite, pero insertar en medio suele ser más lento que al final.

Paso 4: ¿Qué tan frecuentes son inserciones/eliminaciones?

Agregar al final muchas veces: lista es buena opción.
Insertar/eliminar en medio muchas veces: lista puede volverse costosa por el movimiento de elementos; si esto domina tu caso, conviene replantear el diseño (por ejemplo, cambiar la forma de representar el problema o usar otra estructura en capítulos posteriores).

Escenarios frecuentes y cómo razonar la elección

Escenario A: “Necesito el último elemento”

Ejemplo: registrar las últimas temperaturas leídas por un sensor y consultar la más reciente.

Si solo te interesa la última lectura y no guardas historial: variable (sobrescribes el valor).
Si necesitas historial y además consultar la última: lista (agregas al final y lees el último).

# Variable: solo última lectura (se reemplaza cada vez)ultima_lectura = 21.3ultima_lectura = 21.7  # ahora esta es la vigente# Lista: historial + última lecturalecturas = []lecturas.append(21.3)lecturas.append(21.7)ultima = lecturas[-1]

Rendimiento intuitivo: tomar el último es rápido; agregar al final suele ser rápido.

Escenario B: “Necesito encontrar si existe”

Ejemplo: verificar si un usuario ya está en una lista de invitados.

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

Con una lista, la verificación típica revisa nombres hasta encontrar coincidencia o llegar al final. Con pocos elementos es perfectamente aceptable; con muchos y consultas constantes, se vuelve más lenta.

invitados = ["Ana", "Luis", "Marta"]existe = ("Luis" in invitados)  # revisa uno por uno hasta encontrar

Regla práctica: si la lista crece y haces esta pregunta todo el tiempo, considera si realmente necesitas guardar muchos elementos o si puedes reducir el problema (por ejemplo, mantener solo los más recientes o dividir por categorías). En capítulos posteriores, otras estructuras pueden optimizar esta consulta.

Escenario C: “Necesito mantener el orden”

Ejemplo: una cola de tareas en el orden en que llegaron.

Si solo hay una tarea activa: variable.
Si hay varias y el orden de llegada importa: lista.

cola = []cola.append("Enviar correo")cola.append("Generar reporte")siguiente = cola[0]  # el primero en llegar

Rendimiento intuitivo: leer por índice es rápido; mantener orden implica que algunas eliminaciones (por ejemplo, quitar el primero) pueden ser más costosas si hay que “correr” elementos.

Escenario D: “Necesito insertar en posiciones específicas”

Ejemplo: ranking de puntuaciones donde insertas una nueva puntuación en la posición correcta.

Una lista permite insertar en una posición, pero al hacerlo en medio normalmente se mueven elementos hacia la derecha para abrir espacio.

ranking = [100, 90, 80]nueva = 95# insertar en la posición 1 para mantener orden descendenteranking.insert(1, nueva)  # ahora: [100, 95, 90, 80]

Rendimiento intuitivo: insertar en medio es más lento que agregar al final, especialmente si el ranking es grande.

Comparaciones rápidas: buscar, agregar y eliminar

Buscar

Variable: “buscar” no aplica como recorrido; ya tienes el valor (rápido).
Lista: buscar por contenido suele implicar revisar elementos (más lento a medida que crece).

Agregar

Variable: asignar/reemplazar (rápido).
Lista: agregar al final suele ser rápido; insertar en medio suele ser más lento.

Eliminar

Variable: “eliminar” suele ser reasignar a vacío/nulo o reemplazar (rápido).
Lista: eliminar por posición al final suele ser rápido; eliminar en medio o al inicio suele ser más lento por el corrimiento de elementos.

Tablas de decisión

Tabla 1: Elección rápida entre variable y lista

Criterio	Variable	Lista
Tamaño (número de elementos)	1	Varios / variable en el tiempo
Frecuencia de búsqueda “¿existe X?”	No aplica	Bien si es ocasional o la lista es pequeña; si es muy frecuente y grande, puede volverse lenta
Frecuencia de inserción	Reemplazo frecuente sin historial	Agregar al final frecuente; insertar en medio posible pero más costoso
Frecuencia de eliminación	Reemplazar por vacío/nulo	Eliminar al final frecuente; eliminar en medio/inicio puede ser costoso
Orden requerido	No	Sí (por llegada, prioridad, posición)

Tabla 2: Si eliges lista, ¿qué operación dominará?

Necesidad principal	Operación típica	Comportamiento esperado	Consejo práctico
Registrar historial y consultar el último	append + leer último	Rápido	Ideal para logs, lecturas, eventos recientes
Verificar existencia repetidamente	in / recorrido	Se vuelve más lento al crecer	Si crece mucho, replantea el diseño o considera otra estructura más adelante
Mantener orden y consumir desde el inicio	leer primero + eliminar primero	Eliminar primero puede ser costoso	Evalúa si puedes consumir por índice/contador en vez de borrar
Insertar en posiciones específicas	insert(pos, x)	Más lento por corrimiento	Úsalo si el tamaño es moderado o la inserción es poco frecuente

Patrones de diseño para evitar operaciones costosas en listas

Patrón 1: “No borres, marca o avanza”

Si estás consumiendo elementos desde el inicio (por ejemplo, una cola), en lugar de eliminar el primero cada vez, puedes mantener un índice de “inicio” que avanza. Así evitas mover elementos repetidamente.

tareas = ["A", "B", "C", "D"]inicio = 0# consumir sin borrarwhile inicio < len(tareas):    actual = tareas[inicio]    # procesar actual...    inicio += 1

Patrón 2: “Si solo importa el último, no guardes todo”

Si tu requerimiento real es “tener el último valor”, una variable es más simple y evita crecimiento innecesario.

ultimo_estado = "PENDIENTE"# ... cambiosultimo_estado = "EN_PROCESO"ultimo_estado = "FINALIZADO"

Ejercicios: selecciona y justifica

Ejercicio 1

Estás construyendo un sistema que muestra solo el precio actual de un producto (no historial). Operaciones: actualizar precio cada minuto; consultar precio actual muchas veces.

Elige: variable o lista.
Justifica con: tamaño, orden, tipo de consulta, costo esperado.

Ejercicio 2

Necesitas guardar los últimos 50 mensajes de un chat para mostrarlos en orden. Operaciones: agregar al final constantemente; consultar el último y recorrer para mostrar.

Elige: variable o lista.
Justifica con: orden requerido y operaciones dominantes.

Ejercicio 3

Lista de asistencia: cada vez que llega alguien, quieres saber si ya estaba registrado. Puede haber cientos de nombres. Operaciones: muchas consultas de existencia; algunas inserciones.

Elige: variable o lista.
Justifica con: frecuencia de búsqueda y tamaño.

Ejercicio 4

Ranking de puntuaciones: debes insertar nuevas puntuaciones en la posición correcta para mantener el orden. Operaciones: inserciones en medio; mostrar ranking completo.

Elige: variable o lista.
Justifica con: orden requerido y costo de inserción.

Ejercicio 5

Procesamiento de pedidos: llegan pedidos en orden y se procesan en ese mismo orden. Operaciones: agregar al final; consumir desde el inicio repetidamente.

Elige: variable o lista.
Propón una estrategia para evitar eliminaciones costosas (pista: índice de inicio).

Ahora responde el ejercicio sobre el contenido:

En un sistema de procesamiento de pedidos que llegan en orden y se atienden en ese mismo orden, ¿qué combinación de estructura y estrategia reduce el costo de eliminar repetidamente el primer elemento?

¡Tienes razón! Felicitaciones, ahora pasa a la página siguiente.

¡Tú error! Inténtalo de nuevo.

Como hay varios pedidos y el orden importa, conviene una lista. Eliminar el primero repetidamente puede ser costoso porque obliga a mover elementos; en su lugar, mantener un índice de inicio que avanza evita ese corrimiento.