Universidad Nacional de Costa Rica

EIY403

Introducción al análisis de datos para otras carreras

Clase 4: Sentencias iterativas

II Semestre 2025

Escuela de Informática y Computación

1 / 14

Universidad Nacional de Costa Rica

Agenda de la clase

Bloque 1: Conceptos básicos

¿Qué son las sentencias iterativas?
¿Por qué son útiles en química?
Tipos principales: for y while
Cuándo usar cada tipo

Bloque 2: Bucle for

Estructura básica
Ejemplos químicos simples
Procesar múltiples valores
Errores comunes

Bloque 3: Bucle while

Estructura y funcionamiento
Condiciones de parada
Ejemplos de convergencia
Prevenir bucles infinitos

Bloque 4: Mejores prácticas

Cuándo usar bucles vs. otros métodos
Optimización básica
Debugging y validación
Preparación para el laboratorio

2 / 14

Universidad Nacional de Costa Rica

¿Qué son las sentencias iterativas?

"Las sentencias iterativas nos permiten repetir un conjunto de instrucciones automáticamente"

Definición simple

Las sentencias iterativas son estructuras que ejecutan el mismo código múltiples veces, siguiendo un patrón específico.

Es como tener un robot que:

Hace la misma tarea repetidas veces
Nunca se cansa
No comete errores de copia
Es mucho más rápido que nosotros

Analogía de laboratorio

Imagina que tienes que:

Medir el pH de 50 muestras de agua
Calcular la concentración de cada una
Clasificarlas como ácidas, neutras o básicas

Sin bucles: Escribes 50 veces el mismo código

Con bucles: Escribes el código una vez, se ejecuta 50 veces

¿Por qué son importantes en química?

Análisis rutinarios: Procesar muchas muestras similares
Cálculos repetitivos: Misma fórmula, diferentes valores
Precisión: Eliminar errores de transcripción
Tiempo: Hacer en segundos lo que tomaría horas
Escalabilidad: Funciona igual para 10 o 1000 muestras

Ejemplos cotidianos en química

Calcular la molaridad de 20 soluciones diferentes
Convertir temperaturas de °C a Kelvin para múltiples experimentos
Determinar el pH de todas las muestras del día
Verificar si las concentraciones están dentro del rango aceptable
Calcular el porcentaje de error en múltiples mediciones

Ventaja principal: Escribes el código una vez, funciona para todos los datos

3 / 14

Universidad Nacional de Costa Rica

Tipos principales de bucles

Bucle for

Uso: Cuando sabes exactamente cuántas veces repetir

Situaciones típicas:

Procesar cada muestra en una lista
Repetir un cálculo 10 veces
Analizar datos del día 1 al día 30
Convertir todas las temperaturas

Ejemplo: "Calcula la molaridad para las 15 muestras"

→ Sabemos que son exactamente 15

Bucle while

Uso: Cuando no sabes cuántas repeticiones necesitas

Situaciones típicas:

Hasta que el pH sea neutro
Mientras la concentración sea muy alta
Hasta alcanzar la temperatura deseada
Mientras haya errores en los datos

Ejemplo: "Agrega base hasta que el pH sea 7"

→ No sabemos cuántas gotas necesitaremos

Aspecto	Bucle for	Bucle while
¿Cuántas veces?	Número conocido	Número desconocido
Condición	Hasta terminar la lista	Mientras se cumpla algo
Ejemplo químico	20 muestras → 20 repeticiones	Hasta pH = 7 → ? repeticiones
Riesgo	Muy seguro	Puede ser infinito

4 / 14

Universidad Nacional de Costa Rica

Bucle for: estructura básica

Sintaxis general

for (variable in lista) {
    # Código que se repite
    # Puede usar la variable
}

Componentes:

variable: Toma cada valor de la lista
lista: Conjunto de valores a procesar
código: Se ejecuta una vez por cada valor

Ejemplo muy simple

# Saludar a 3 estudiantes
estudiantes <- c("Ana", "Carlos", "María")

for (nombre in estudiantes) {
    print(paste("Hola", nombre))
}

# Resultado:
# "Hola Ana"
# "Hola Carlos" 
# "Hola María"

Ejemplo químico básico

# Convertir temperaturas de °C a Kelvin
temperaturas_C <- c(25, 30, 35, 40)

for (temp_C in temperaturas_C) {
    temp_K <- temp_C + 273.15
    print(paste(temp_C, "°C =", temp_K, "K"))
}

# Resultado:
# "25 °C = 298.15 K"
# "30 °C = 303.15 K"
# "35 °C = 308.15 K"
# "40 °C = 313.15 K"

Ejemplo con números

# Calcular el cuadrado de números del 1 al 5
for (numero in 1:5) {
    cuadrado <- numero^2
    print(paste(numero, "al cuadrado =", cuadrado))
}

# Resultado:
# "1 al cuadrado = 1"
# "2 al cuadrado = 4"
# "3 al cuadrado = 9"
# "4 al cuadrado = 16"
# "5 al cuadrado = 25"

Lo importante: El código dentro del bucle se ejecuta una vez para cada elemento de la lista

5 / 14

Universidad Nacional de Costa Rica

Ejemplos químicos con bucle for

Cálculo de molaridad

# Datos de diferentes soluciones
moles_soluto <- c(0.5, 1.2, 0.8, 2.0)
litros_solucion <- c(1.0, 2.0, 0.5, 1.5)

# Calcular molaridad para cada solución
for (i in 1:4) {
    molaridad <- moles_soluto[i] / litros_solucion[i]
    print(paste("Solución", i, ": M =", 
                round(molaridad, 2)))
}

# Resultado:
# "Solución 1 : M = 0.5"
# "Solución 2 : M = 0.6"
# "Solución 3 : M = 1.6"
# "Solución 4 : M = 1.33"

Clasificación de pH

# Valores de pH de diferentes muestras
valores_ph <- c(3.2, 7.1, 10.5, 6.8, 2.1)

for (ph in valores_ph) {
    if (ph < 7) {
        tipo <- "ácida"
    } else if (ph == 7) {
        tipo <- "neutra"
    } else {
        tipo <- "básica"
    }
    
    print(paste("pH", ph, "es", tipo))
}

# Resultado:
# "pH 3.2 es ácida"
# "pH 7.1 es básica"
# "pH 10.5 es básica"
# "pH 6.8 es ácida"
# "pH 2.1 es ácida"

Control de calidad básico

# Concentraciones medidas (mg/L)
concentraciones <- c(95, 102, 88, 110, 98)
limite_inferior <- 90
limite_superior <- 105

for (i in 1:length(concentraciones)) {
    conc <- concentraciones[i]
    
    if (conc >= limite_inferior && 
        conc <= limite_superior) {
        estado <- "APROBADA"
    } else {
        estado <- "RECHAZADA"
    }
    
    print(paste("Muestra", i, ":", conc, 
                "mg/L -", estado))
}

# Resultado:
# "Muestra 1 : 95 mg/L - APROBADA"
# "Muestra 2 : 102 mg/L - APROBADA"
# "Muestra 3 : 88 mg/L - RECHAZADA"
# "Muestra 4 : 110 mg/L - RECHAZADA"
# "Muestra 5 : 98 mg/L - APROBADA"

Cálculo de porcentaje de error

# Valores esperados vs medidos
valores_esperados <- c(100, 50, 75, 25)
valores_medidos <- c(98, 52, 73, 26)

for (i in 1:4) {
    esperado <- valores_esperados[i]
    medido <- valores_medidos[i]
    
    error_porcentual <- abs(esperado - medido) / esperado * 100
    
    print(paste("Muestra", i, ": Error =", 
                round(error_porcentual, 1), "%"))
}

# Resultado:
# "Muestra 1 : Error = 2 %"
# "Muestra 2 : Error = 4 %"
# "Muestra 3 : Error = 2.7 %"
# "Muestra 4 : Error = 4 %"

Patrón común:

Tengo una lista de valores químicos
Quiero hacer el mismo cálculo con cada uno
Uso for para procesar todos automáticamente

6 / 14

Universidad Nacional de Costa Rica

Bucle while: estructura básica

Sintaxis general

while (condición) {
    # Código que se repite
    # IMPORTANTE: cambiar algo que afecte la condición
}

Funcionamiento:

Verifica si la condición es verdadera
Si es verdadera: ejecuta el código
Repite desde el paso 1
Si es falsa: termina el bucle

Ejemplo muy simple

# Contar del 1 al 5
contador <- 1

while (contador <= 5) {
    print(paste("Número:", contador))
    contador <- contador + 1  # ¡MUY IMPORTANTE!
}

# Resultado:
# "Número: 1"
# "Número: 2"
# "Número: 3"
# "Número: 4"
# "Número: 5"

⚠️ CUIDADO: Si no cambias la variable en el bucle, se ejecutará infinitamente

Ejemplo químico: dilución

# Diluir hasta concentración aceptable
concentracion <- 500  # mg/L (muy alta)
objetivo <- 100       # mg/L (concentración deseada)
iteracion <- 0

print(paste("Concentración inicial:", concentracion, "mg/L"))

while (concentracion > objetivo) {
    # Diluir (agregar mismo volumen de agua)
    concentracion <- concentracion / 2
    iteracion <- iteracion + 1
    
    print(paste("Dilución", iteracion, ":", 
                round(concentracion, 1), "mg/L"))
}

print(paste("¡Listo! Concentración final:", 
            round(concentracion, 1), "mg/L"))

# Resultado:
# "Concentración inicial: 500 mg/L"
# "Dilución 1 : 250 mg/L"
# "Dilución 2 : 125 mg/L"
# "Dilución 3 : 62.5 mg/L"
# "¡Listo! Concentración final: 62.5 mg/L"

¿Cuándo usar while?

Cuando el objetivo es alcanzar un valor
Cuando no sabes cuántos pasos necesitas
En procesos de aproximación
Para validar datos hasta que sean correctos

7 / 14

Universidad Nacional de Costa Rica

Ejemplos químicos con bucle while

Ajuste de pH (simulado)

# Simular ajuste de pH agregando base
ph_actual <- 4.5      # pH inicial (ácido)
ph_objetivo <- 7.0    # pH neutro deseado
gotas_base <- 0

print(paste("pH inicial:", ph_actual))

while (ph_actual < ph_objetivo) {
    # Agregar una gota de base (simulado)
    ph_actual <- ph_actual + 0.3
    gotas_base <- gotas_base + 1
    
    print(paste("Gota", gotas_base, ": pH =", 
                round(ph_actual, 1)))
}

print(paste("¡pH neutro alcanzado!"))
print(paste("Total de gotas utilizadas:", gotas_base))

Enfriamiento de muestra

# Esperar a que la muestra se enfríe
temperatura <- 80     # °C (muy caliente)
temp_segura <- 25    # °C (temperatura ambiente)
minutos <- 0

print(paste("Temperatura inicial:", temperatura, "°C"))

while (temperatura > temp_segura) {
    # Simular enfriamiento (pierde 5°C por minuto)
    temperatura <- temperatura - 5
    minutos <- minutos + 1
    
    print(paste("Minuto", minutos, ":", 
                temperatura, "°C"))
}

print("¡Muestra lista para manipular!")

Precisión en mediciones

# Repetir medición hasta obtener precisión aceptable
mediciones <- c()
error_aceptable <- 2  # % error máximo permitido
intentos <- 0

# Simular mediciones con diferentes errores
errores_simulados <- c(5, 3, 1.5, 0.8)

while (length(mediciones) == 0 || 
       tail(mediciones, 1) > error_aceptable) {
    
    intentos <- intentos + 1
    
    # Simular medición (en la realidad sería experimental)
    error_actual <- errores_simulados[intentos]
    mediciones <- c(mediciones, error_actual)
    
    print(paste("Intento", intentos, 
                ": Error =", error_actual, "%"))
    
    if (error_actual <= error_aceptable) {
        print("¡Precisión aceptable alcanzada!")
    } else {
        print("Repetir medición...")
    }
}

print(paste("Total de intentos:", intentos))

Ventaja de while: Se adapta automáticamente a las condiciones, sin importar cuántos pasos requiera

Prevenir bucles infinitos:

Siempre cambiar la variable de condición
Incluir un contador máximo de seguridad
Verificar que la condición pueda ser falsa

8 / 14

Universidad Nacional de Costa Rica

¿Cuándo usar for vs while?

Usar bucle for cuando:

Criterio principal: Conoces el número exacto de repeticiones

Situaciones típicas:

"Analizar las 20 muestras del día"
"Calcular para cada valor en mi lista"
"Repetir el experimento 5 veces"
"Procesar datos de 7 días"

Ejemplo de decisión: for

# Tengo exactamente 6 muestras
ph_muestras <- c(6.5, 7.2, 5.8, 8.1, 7.0, 6.9)

# Uso for porque sé que son 6
for (ph in ph_muestras) {
    if (ph < 7) {
        print(paste("pH", ph, "es ácido"))
    } else {
        print(paste("pH", ph, "es básico/neutro"))
    }
}

Ventajas del for:

Seguro: No puede ser infinito
Predecible: Sabes cuánto tardará
Simple: No necesitas contador manual
Claro: Es obvio cuántas veces se ejecuta

Usar bucle while cuando:

Criterio principal: No sabes cuántas repeticiones necesitas

Situaciones típicas:

"Hasta que el pH sea neutro"
"Mientras la temperatura esté alta"
"Hasta encontrar la concentración correcta"
"Mientras haya errores en los datos"

Ejemplo de decisión: while

# No sé cuántas diluciones necesito
concentracion <- 1000  # mg/L (muy alta)
limite_seguro <- 50    # mg/L

# Uso while porque no sé cuántas veces diluir
while (concentracion > limite_seguro) {
    concentracion <- concentracion * 0.7  # Diluir 30%
    print(paste("Nueva concentración:", 
                round(concentracion, 1), "mg/L"))
}

Ventajas del while:

Flexible: Se adapta a las condiciones
Eficiente: Para exactamente cuando debe
Realista: Simula procesos naturales
Preciso: Alcanza el objetivo exacto

Regla de seguridad para while: Siempre incluir un límite máximo de iteraciones

9 / 14

Universidad Nacional de Costa Rica

Errores comunes y cómo evitarlos

Error 1: Bucle infinito en while

# ❌ MAL - Bucle infinito
contador <- 1
while (contador <= 5) {
    print(contador)
    # ¡Olvido incrementar contador!
}
# Este bucle nunca termina

# ✅ BIEN - Actualizar la variable
contador <- 1
while (contador <= 5) {
    print(contador)
    contador <- contador + 1  # ¡Importante!
}

Error 2: Usar índices incorrectos

# ❌ MAL - Índice fuera de rango
datos <- c(10, 20, 30)
for (i in 1:5) {  # ¡Solo hay 3 elementos!
    print(datos[i])  # Error en i=4 y i=5
}

# ✅ BIEN - Usar length()
datos <- c(10, 20, 30)
for (i in 1:length(datos)) {
    print(datos[i])
}

Error 3: Condición incorrecta en while

# ❌ MAL - Condición que nunca cambia
ph <- 5
while (ph != 7) {  # ph nunca será exactamente 7
    ph <- ph + 0.3  # Puede saltar sobre 7
}

# ✅ BIEN - Usar rango de tolerancia
ph <- 5
while (abs(ph - 7) > 0.1) {  # Cerca de 7
    ph <- ph + 0.3
}

Error 4: No validar datos de entrada

# ❌ MAL - No verificar datos
concentraciones <- c(50, NA, 75, 100)
for (conc in concentraciones) {
    molaridad <- conc / 58.44  # Error con NA
    print(molaridad)
}

# ✅ BIEN - Validar antes de usar
concentraciones <- c(50, NA, 75, 100)
for (conc in concentraciones) {
    if (!is.na(conc)) {
        molaridad <- conc / 58.44
        print(paste("Molaridad:", round(molaridad, 3)))
    } else {
        print("Dato faltante - saltando")
    }
}

Error 5: Modificar la lista durante el bucle

# ❌ MAL - Cambiar la lista durante el bucle
valores <- c(1, 2, 3, 4, 5)
for (i in 1:length(valores)) {
    if (valores[i] > 3) {
        valores <- valores[-i]  # ¡Modifica la lista!
    }
}

# ✅ BIEN - Crear nueva lista
valores <- c(1, 2, 3, 4, 5)
valores_filtrados <- c()
for (valor in valores) {
    if (valor <= 3) {
        valores_filtrados <- c(valores_filtrados, valor)
    }
}

Consejos para evitar errores

Siempre actualizar variables en while
Usar length() en lugar de números fijos
Validar datos antes de procesarlos
Probar con datos pequeños primero
Agregar print() para seguir el progreso

10 / 14

Universidad Nacional de Costa Rica

¿Cuándo usar bucles vs otras alternativas?

Cuándo SÍ usar bucles

Situaciones apropiadas:

Lógica compleja: Cada caso requiere decisiones diferentes
Múltiples pasos: Varios cálculos secuenciales por elemento
Condiciones especiales: Saltar elementos o cambiar comportamiento
Interacción entre elementos: Un resultado afecta el siguiente

Ejemplo: lógica compleja

# Clasificación compleja que requiere bucle
muestras <- data.frame(
    ph = c(6.5, 8.2, 3.1, 7.0),
    temperatura = c(25, 45, 20, 30),
    concentracion = c(100, 200, 50, 150)
)

for (i in 1:nrow(muestras)) {
    # Lógica compleja que combina múltiples factores
    if (muestras$ph[i] < 6 && muestras$temperatura[i] > 40) {
        clasificacion <- "Peligrosa"
    } else if (muestras$concentracion[i] > 180) {
        clasificacion <- "Muy concentrada"
    } else if (abs(muestras$ph[i] - 7) < 0.5) {
        clasificacion <- "Ideal"
    } else {
        clasificacion <- "Normal"
    }
    
    print(paste("Muestra", i, ":", clasificacion))
}

Cuándo usar vectorización (más simple)

Situaciones para vectorización:

Operaciones simples: Misma operación a todos los elementos
Cálculos matemáticos básicos: Suma, multiplicación, etc.
Transformaciones directas: Aplicar una fórmula
Sin condiciones complejas: Mismo tratamiento para todos

Ejemplo: vectorización simple

# Conversión simple - mejor SIN bucle
temperaturas_C <- c(25, 30, 35, 40, 45)

# ❌ Innecesariamente complejo con bucle
temperaturas_K_bucle <- c()
for (temp in temperaturas_C) {
    temperaturas_K_bucle <- c(temperaturas_K_bucle, temp + 273.15)
}

# ✅ Más simple con vectorización
temperaturas_K_simple <- temperaturas_C + 273.15

# Ambos dan el mismo resultado:
print(temperaturas_K_simple)
# [1] 298.15 303.15 308.15 313.15 318.15

Guía de decisión rápida

Usa bucles si necesitas:

Condiciones if/else complejas
Múltiples pasos por elemento
Imprimir progreso paso a paso
Interacción entre elementos

Usa vectorización si solo necesitas:

Aplicar una fórmula matemática
Transformación directa
Operaciones simples

11 / 14

Universidad Nacional de Costa Rica

Debugging y validación de bucles

Técnicas de debugging

1. Agregar mensajes de progreso

# Mostrar progreso durante el bucle
muestras <- c(45, 67, 89, 23, 56)

for (i in 1:length(muestras)) {
    print(paste("Procesando muestra", i, "de", length(muestras)))
    
    resultado <- muestras[i] * 2.5
    
    print(paste("Valor:", muestras[i], "-> Resultado:", resultado))
    print("---")  # Separador visual
}

2. Probar con datos pequeños

# Primero probar con pocos datos
datos_prueba <- c(10, 20, 30)  # Solo 3 elementos

for (valor in datos_prueba) {
    resultado <- valor / 5
    print(paste(valor, "/ 5 =", resultado))
}

# Si funciona bien, usar con datos completos
datos_completos <- c(10, 20, 30, 40, 50, 60, 70, 80)

3. Validar condiciones en while

# Agregar contador de seguridad
concentracion <- 1000
objetivo <- 50
iteraciones <- 0
max_iteraciones <- 20  # Límite de seguridad

while (concentracion > objetivo && iteraciones < max_iteraciones) {
    concentracion <- concentracion * 0.8
    iteraciones <- iteraciones + 1
    
    print(paste("Iteración", iteraciones, 
                ": concentración =", round(concentracion, 1)))
}

if (iteraciones >= max_iteraciones) {
    print("ADVERTENCIA: Se alcanzó el límite máximo de iteraciones")
}

Validación de datos

Verificar antes de procesar

# Función simple de validación
validar_datos_quimicos <- function(datos) {
    errores <- c()
    
    # Verificar que no estén vacíos
    if (length(datos) == 0) {
        errores <- c(errores, "No hay datos para procesar")
    }
    
    # Verificar valores NA
    if (any(is.na(datos))) {
        errores <- c(errores, "Hay valores faltantes (NA)")
    }
    
    # Verificar valores negativos (si aplica)
    if (any(datos < 0, na.rm = TRUE)) {
        errores <- c(errores, "Hay valores negativos")
    }
    
    return(errores)
}

# Usar la validación
concentraciones <- c(50, 75, NA, 100, -5)
errores <- validar_datos_quimicos(concentraciones)

if (length(errores) > 0) {
    print("ERRORES ENCONTRADOS:")
    for (error in errores) {
        print(paste("-", error))
    }
} else {
    print("Datos válidos - procesando...")
    # Aquí iría el bucle principal
}

Manejo de errores en bucles

# Continuar procesando aunque haya errores individuales
valores <- c(100, 0, 50, NA, 75)

for (i in 1:length(valores)) {
    print(paste("Procesando elemento", i))
    
    valor <- valores[i]
    
    # Verificar casos problemáticos
    if (is.na(valor)) {
        print("  Saltando: valor faltante")
        next  # Continúa con el siguiente elemento
    }
    
    if (valor == 0) {
        print("  Saltando: valor cero")
        next
    }
    
    # Procesar normalmente
    resultado <- 100 / valor
    print(paste("  Resultado:", round(resultado, 2)))
}

Lista de verificación para bucles

✓ Probar con 2-3 elementos primero
✓ Verificar condiciones de parada
✓ Validar datos de entrada
✓ Agregar mensajes de progreso
✓ Incluir límites de seguridad
✓ Manejar casos especiales (NA, 0, etc.)

12 / 14

Universidad Nacional de Costa Rica

Preparación para el notebook

Lo que haremos en el notebook R

Ejercicio 1: Procesar datos de pH con bucle for
Ejercicio 2: Calcular molaridades de múltiples soluciones
Ejercicio 3: Simular dilución con bucle while
Ejercicio 4: Control de calidad automatizado
Ejercicio 5: Conversión de unidades en lotes

Conceptos que necesitas recordar

Bucle for:

Para número conocido de repeticiones
Procesar listas de datos
Sintaxis: for (variable in lista)

Bucle while:

Para número desconocido de repeticiones
Hasta alcanzar una condición
Sintaxis: while (condición)
¡Recordar actualizar la variable!

Fórmulas químicas que usaremos

# Molaridad
M = moles / litros

# Dilución
C1 * V1 = C2 * V2

# Porcentaje de error
error % = |valor_real - valor_medido| / valor_real * 100

# Conversión de temperatura
K = °C + 273.15

Metodología del notebook

Trabajaremos juntos paso a paso:

Explicación teórica breve
Demostración en R
Práctica guiada
Ejercicios aplicados
Discusión de resultados

Tipos de datos que manejaremos

# Ejemplos de datos típicos

# Vector de pH
ph_muestras <- c(6.5, 7.2, 5.8, 8.1, 7.0)

# Vector de concentraciones (mg/L)
concentraciones <- c(45, 67, 89, 23, 56)

# Vector de temperaturas (°C)
temperaturas <- c(25, 30, 35, 40)

# Data frame con múltiples variables
datos_lab <- data.frame(
    muestra_id = c("A1", "A2", "A3"),
    ph = c(6.5, 7.2, 5.8),
    concentracion = c(45, 67, 89),
    temperatura = c(25, 30, 35)
)

Estructura típica de ejercicios

# 1. Cargar/crear datos
datos <- c(...)

# 2. Validar datos (opcional)
if (any(is.na(datos))) {
    print("Hay datos faltantes")
}

# 3. Procesar con bucle
for (valor in datos) {
    # Aplicar fórmula o lógica
    resultado <- calcular_algo(valor)
    
    # Mostrar resultado
    print(paste("Valor:", valor, "-> Resultado:", resultado))
}

# 4. Resumen final
print("Procesamiento completado")

Consejos para el notebook

Para aprovechar al máximo:

Participa activamente: Haz preguntas durante la clase
Sigue el ritmo: Ejecuta el código junto conmigo
Experimenta: Cambia valores y observa qué pasa
Toma notas: Anota conceptos importantes
Relaciona: Conecta con tu experiencia en química

Importante: El notebook es un taller práctico donde trabajamos juntos. Es diferente de los laboratorios evaluables que harán individualmente más adelante

13 / 14

Universidad Nacional de Costa Rica

Resumen y próxima clase

Lo que aprendimos hoy

Concepto de iteración: Repetir procesos automáticamente
Bucle for: Para número conocido de repeticiones
Bucle while: Para número desconocido de repeticiones
Aplicaciones químicas: Cálculos con múltiples muestras
Errores comunes: Cómo identificarlos y evitarlos
Debugging básico: Técnicas para encontrar problemas
Cuándo usar bucles: vs. otras alternativas más simples

Conceptos clave para recordar

for: "Para cada elemento en mi lista"
while: "Mientras se cumpla esta condición"
Validación: Siempre verificar datos antes de procesar
Seguridad: Evitar bucles infinitos
Simplicidad: No usar bucles para operaciones simples

Impacto en tu carrera de química

"Las sentencias iterativas te permiten procesar automáticamente datos de laboratorio, convirtiendo horas de cálculos manuales en segundos de computación precisa"

Próxima clase: notebook de sentencias iterativas

Trabajaremos en R con un notebook que incluye:

Aplicación práctica: Implementar bucles en R paso a paso
Datos químicos reales: Ejercicios con muestras de laboratorio
Taller colaborativo: Resolveremos ejercicios juntos
Debugging en tiempo real: Aprenderás a solucionar errores
Casos de uso químicos: Situaciones típicas de laboratorio
Buenas prácticas: Código limpio y eficiente

Metodología de la próxima clase

Formato del notebook:

Explicación + código: Teoría y práctica integradas
Ejercicios progresivos: De simple a complejo
Trabajo colaborativo: Discusión y resolución grupal
Código ejecutable: Resultados inmediatos

Preparación recomendada

Repasar los conceptos de bucles de hoy
Practicar crear vectores en R (opcional)
Recordar fórmulas químicas básicas
Traer preguntas sobre casos específicos

¡Gracias por su atención!

¿Preguntas sobre sentencias iterativas?

14 / 14