Saber Básico A.1.2: Estructuras de control condicionales e iterativas. Estructuras de datos en Python.

🚦 1. Control del Flujo: Condicionales y Lógica Booleana

Las estructuras condicionales permiten bifurcar la ejecución de un programa en función de la evaluación booleana (True o False) de expresiones lógicas.

• if: Determina el bloque inicial a ejecutar si la condición es verdadera.
• elif: Evalúa condiciones secuenciales alternativas cuando las anteriores resultan falsas.
• else: Establece la rama por defecto si ninguna condición previa se ha satisfecho.

📊 Tabla de Operadores Relacionales y Lógicos

Operador	Operación	Ejemplo	Resultado
== / !=	Igualdad / Desigualdad	10 != 5	True
>, <, >=, <=	Comparación numérica	7.5 >= 5.0	True
and	Conjunción (ambas verdaderas)	(x > 0) and (x < 10)	True si x∈(0,10)
or	Disyunción (al menos una)	(x == 0) or (y == 0)	True si alguno es cero
not	Negación lógica	not (5 > 2)	False

Python

# Ejemplo: Validación de parámetros en un script de cómputo
rendimiento_cpu = 88.5
memoria_disponible_gb = 1.2

if rendimiento_cpu > 90.0 or memoria_disponible_gb < 0.5:
    estado = "ALERTA: Recursos críticos"
elif rendimiento_cpu > 75.0 and memoria_disponible_gb < 2.0:
    estado = "PRECAUCIÓN: Carga elevada"
else:
    estado = "NORMAL: Sistema estable"

print(f"Estado del servidor: {estado}")

🔄 2. Estructuras Iterativas y Control de Bucle

Los bucles permiten ejecutar un bloque de instrucciones de manera repetida mientras se mantenga la condición de parada o sobre una secuencia finita de datos.

⚖️ Comparativa: for vs while

Característica	Bucle for	Bucle while
Naturaleza	Defenido / Determinado	Indefinido / Condicional
Mecanismo	Recorre iterables o rangos (range()).	Se evalúa mientras la condición sea True.
Uso típico	Colecciones, rangos fijos de iteración.	Bucles de eventos, lecturas hasta fin de archivo (EOF).

🛠️ Control Avanzado: break y continue

• break: Interrumpe y sale inmediatamente del bucle.
• continue: Salta el resto del código del ciclo actual y pasa a la siguiente iteración.

Python

# Bucle FOR con control de flujo
print("Procesando datos...")
for i in range(1, 10):
    if i % 2 == 0:
        continue  # Omitir números pares
    if i == 7:
        print("Interrupción por valor crítico (7).")
        break     # Detener el bucle
    print(f"Valor impar procesado: {i}")

# Bucle WHILE controlado por centinela
intentos = 0
autenticado = False

while intentos < 3 and not autenticado:
    intentos += 1
    # Simulación de validación
    if intentos == 2:
        autenticado = True

print(f"Resultado tras {intentos} intento(s): Autenticado={autenticado}")

📦 3. Estructuras de Datos

Python proporciona tipos de datos compuestos nativos para estructurar y gestionar colecciones de información de forma eficiente en memoria.

🧩 Comparativa de Estructuras Nativas

Estructura	Sintaxis	Mutabilidad	Indexada	Elementos duplicados	Caso de uso informático
Lista (list)	[a, b]	Sí	Sí (base 0)	Permitidos	Secuencias mutables de datos dinámicos.
Tupla (tuple)	(a, b)	Inmutable	Sí (base 0)	Permitidos	Estructuras de lectura rápida, constantes, datos GPS/registros.
Diccionario (dict)	{"k": v}	Sí	No (por clave)	Claves únicas	Tablas hash, archivos JSON, perfiles de datos.
Conjunto (set)	{a, b}	Sí	No	No (solo únicos)	Operaciones matemáticas de conjuntos, filtrado de duplicados.

Python

# 1. LISTAS (Manipulación vectorial básica)
muestras = [12.4, 15.1, 10.8]
muestras.append(14.2)
muestras.sort()
print(f"Muestras ordenadas: {muestras}")

# 2. TUPLAS (Inmutabilidad y empaquetado)
coordenadas_iss = (41.40338, 2.17403)  # (Latitud, Longitud)

# 3. DICCIONARIOS (Estructura clave-valor / JSON-like)
sensor = {
    "id": "SENSOR-01",
    "tipo": "Telemetría",
    "lecturas": [21.5, 22.0, 21.8],
    "activo": True
}
print(f"Última lectura del {sensor['id']}: {sensor['lecturas'][-1]}°C")

# 4. CONJUNTOS (Búsqueda eficiente y unicidad)
ids_unicos = {101, 102, 103, 101}  # El 101 duplicado se elimina automáticamente
print(f"IDs registrados: {ids_unicos}")

⚡ Reto Algorítmico (Evaluación Continua)

Implementa un programa en Python que procese un registro de datos informáticos:

1. Define un diccionario que contenga el nombre de un servidor como clave y una lista con las latencias (en ms) registradas durante 5 pruebas: {"Servidor_A": [45, 120, 38, 250, 60]}.
2. Utiliza un bucle for junto con una estructura condicional para filtrar las latencias superiores a 100 ms e identificarlas como picos de red.
3. Almacena las latencias anómalas (>100 ms) en una nueva lista e imprime el número total de anomalías detectadas y el promedio de latencia global.

Ejercicios

📝 Boletín de Ejercicios Prácticos: Estructuras de Control y Datos en Python

Asignatura: Programación y Computación (2º Bachillerato)

Saber Básico A.1.2: Estructuras condicionales, iterativas y estructuras de datos.

🚦 Bloque 1: Condicionales y Lógica Booleana

Ejercicio 1: Validador de Calidad de Conexión de Red

Una empresa de telecomunicaciones necesita clasificar el estado de sus conexiones de fibra según el Ping (ms) y la Pérdida de Paquetes (%). Crea un programa que pida estos dos datos al usuario y determine la categoría:

• Excelente: Ping $< 30\text{ ms}$ y Pérdida $= 0\%$.
• Aceptable: Ping entre $30$ y $100\text{ ms}$ y Pérdida $\le 2\%$.
• Crítica: Ping $> 100\text{ ms}$o Pérdida $> 2\%$.

Python

ping = float(input("Introduce el Ping (ms): "))
perdida = float(input("Introduce la pérdida de paquetes (%): "))

if ping < 30 and perdida == 0:
    print("Estado: Excelente 🟢")
elif 30 <= ping <= 100 and perdida <= 2:
    print("Estado: Aceptable 🟡")
else:
    print("Estado: Crítica 🔴")

🔄 Bloque 2: Estructuras Iterativas (Bucles)

Ejercicio 2: Control de Calentamiento de CPU

Simula un sistema de monitorización de temperatura para una CPU.

1. Mediante un bucle while, genera o solicita la lectura de temperatura (°C) en cada iteración.
2. Si la temperatura está entre 40 °C y 75 °C, muestra "Temperatura normal".
3. Si la temperatura supera los 75 °C, muestra "Advertencia: Temperatura elevada" y usa continue para pasar a la siguiente lectura sin registrar la iteración como estable.
4. Si la temperatura alcanza o supera los 90 °C, el bucle debe interrumpirse de inmediato (break) e imprimir "¡APAGADO DE EMERGENCIA!".

Python

# Lista de lecturas simuladas para el ejercicio
lecturas_cpu = [45, 60, 78, 65, 82, 91, 50]
indice = 0

while indice < len(lecturas_cpu):
    temp = lecturas_cpu[indice]
    indice += 1
    
    if temp >= 90:
        print(f"[{temp}°C] ¡APAGADO DE EMERGENCIA! Crítico alcanzado.")
        break
    
    if temp > 75:
        print(f"[{temp}°C] Advertencia: Temperatura elevada. Saltando ciclo...")
        continue
        
    print(f"[{temp}°C] Estado del procesador: Normal")

📦 Bloque 3: Estructuras de Datos (list, dict, set)

Ejercicio 3: Depuración de Direcciones IP Duplicadas y Filtro por Subred

El departamento de ciberseguridad ha extraído una lista de direcciones IP que han intentado acceder a un servidor, pero contiene registros duplicados:

Python

ips_registradas = [
    "192.168.1.15", "10.0.0.5", "192.168.1.15", 
    "172.16.0.1", "10.0.0.5", "192.168.1.100"
]

Escribe un programa que:

1. Elimine todas las IP duplicadas utilizando un conjunto (set).
2. Convierta el resultado de nuevo a una lista y muestre cuántas IP únicas fueron detectadas.
3. Recorra la lista resultante con un bucle for e imprima únicamente las IP que pertenezcan a la red local 192.168.1.X (puedes usar .startswith()).

Python

ips_registradas = [
    "192.168.1.15", "10.0.0.5", "192.168.1.15", 
    "172.16.0.1", "10.0.0.5", "192.168.1.100"
]

# 1 y 2. Eliminar duplicados mediante set
ips_unicas = list(set(ips_registradas))
print(f"Total de IP únicas detectadas: {len(ips_unicas)}")

# 3. Filtrar por subred local
print("\nDirecciones pertenecientes a la red 192.168.1.X:")
for ip in ips_unicas:
    if ip.startswith("192.168.1."):
        print(f" - {ip}")

🚀 Bloque 4: Reto Integrador (Nivel Examen / EvAU)

Ejercicio 4: Analizador de Logs de Servidores

Una granja de servidores guarda la información de sus nodos en una lista de diccionarios con el siguiente formato:

Python

servidores = [
    {"nombre": "Node-01", "ram_gb": 16, "carga_pct": 45.0, "so": "Linux"},
    {"nombre": "Node-02", "ram_gb": 8,  "carga_pct": 88.5, "so": "Windows"},
    {"nombre": "Node-03", "ram_gb": 32, "carga_pct": 92.0, "so": "Linux"},
    {"nombre": "Node-04", "ram_gb": 16, "carga_pct": 12.3, "so": "Linux"},
    {"nombre": "Node-05", "ram_gb": 4,  "carga_pct": 95.1, "so": "Windows"}
]

Crea un script completo que realice las siguientes operaciones:

1. Calcula la carga media (%) de todos los servidores registrados.
2. Genera una lista llamada servidores_criticos que guarde los nombres de los servidores que cumplan ambas condiciones:
   • Carga superior al $80\%$.
   • Memoria RAM inferior o igual a $16\text{ GB}$.
3. Muestra una tabla de resumen por pantalla indicando el total de nodos analizables, la carga media global y los nombres de los nodos que requieren intervención urgente.

Python

servidores = [
    {"nombre": "Node-01", "ram_gb": 16, "carga_pct": 45.0, "so": "Linux"},
    {"nombre": "Node-02", "ram_gb": 8,  "carga_pct": 88.5, "so": "Windows"},
    {"nombre": "Node-03", "ram_gb": 32, "carga_pct": 92.0, "so": "Linux"},
    {"nombre": "Node-04", "ram_gb": 16, "carga_pct": 12.3, "so": "Linux"},
    {"nombre": "Node-05", "ram_gb": 4,  "carga_pct": 95.1, "so": "Windows"}
]

suma_carga = 0
servidores_criticos = []

# Procesamiento de datos mediante bucle FOR
for s in servidores:
    suma_carga += s["carga_pct"]
    
    # Condicional con operadores lógicos
    if s["carga_pct"] > 80.0 and s["ram_gb"] <= 16:
        servidores_criticos.append(s["nombre"])

carga_promedio = suma_carga / len(servidores)

# Resultados y formateo de salida
print("=" * 45)
print("     INFORME DE ESTADO DE LA RED DE NODOS    ")
print("=" * 45)
print(f"Total de servidores analizados: {len(servidores)}")
print(f"Carga media global del sistema: {carga_promedio:.2f}%")
print(f"Nodos críticos identificados  : {len(servidores_criticos)}")
print("Lista de atención prioritaria :", ", ".join(servidores_criticos))
print("=" * 45)