Sentencias Condicionales en Python

La orquestación de sistemas no se reduce a encadenar comandos en secuencia. Necesitas evaluar métricas, detectar umbrales superados y redirigir el flujo según lo que encuentres. Sin eso, no tienes automatización: tienes un script que falla en silencio la primera vez que algo sale diferente. Eso es lo más común que veo en principiantes: scripts que parecen funcionar hasta que no funcionan.

En Python, esa lógica se expresa con sentencias condicionales. Evalúan una expresión que siempre colapsa en True o False, y según ese resultado ejecutan el bloque correspondiente.

Estructura Base: La Sentencia if

El bloque if se ejecuta solo si la condición es True. Sin rodeos.

# Validamos si la carga actual del servidor supera el umbral crítico

cpu_load_actual = 85.5
umbral_critico = 80.0

if cpu_load_actual > umbral_critico:
    print(f"ALERTA: Carga de CPU elevada ({cpu_load_actual}%). Iniciando mitigación.")

if 50.0 == 100.0:
    print("Este mensaje jamás se procesará en el flujo de ejecución (False).")

Para manejar estados alternativos sin escribir bloques if desconectados entre sí, usas if-else y elif (Else-If).

# Script para evaluar el estado HTTP de un servicio web

http_status = int(input("Ingresa el código de estado HTTP recibido (ej. 200, 404, 503): "))

if http_status >= 500:
    print("Estado Crítico: El servidor de backend está fallando.")
elif http_status >= 400:
    print("Error del Cliente: Endpoint no encontrado o acceso denegado.")
elif http_status == 200:
    print("Servicio Operativo: OK.")
else:
    print("Estado Desconocido/Inesperado.")

Python evalúa de arriba hacia abajo y sale en el primer match. Si el status es 503, entra al primer bloque y no sigue evaluando el resto. Esto no es un detalle menor. Es lo que evita que un script dispare acciones contradictorias sobre el mismo evento, algo que he visto romper pipelines de producción más de una vez.

Operadores Lógicos (Booleanos)

Las decisiones reales raramente dependen de una sola variable. Python tiene operadores lógicos que siguen álgebra booleana estándar, con orden de precedencia not, and, or.

# Evaluando métricas múltiples para el autoescalado

memoria_disponible_mb = int(input("Por favor, registra los MB disponibles: "))
latencia_api_ms = 450

# Escalaremos si la memoria es muy baja O la latencia es demasiado alta
if memoria_disponible_mb < 512 or latencia_api_ms > 300:
    print("Se disparó la regla de Autoescalado: Agregando un nuevo nodo al clúster.")

# Comprobación estricta de ambos umbrales
if memoria_disponible_mb > 2048 and latencia_api_ms < 50:
    print("El clúster está sobre-aprovisionado. Considerar apagar un nodo.")

Evaluando Existencia y Valores Especiales

Aquí es donde los scripts mal escritos se rompen. Si una llamada a la API devuelve None o una lista vacía y no lo verificas, el script colapsa con un NoneType que tarda dos minutos en rastrear. No es un edge case raro: en infraestructura pasa todo el tiempo.

Tengo una regla personal: si algo puede llegar vacío, asumo que va a llegar vacío. El código que no anticipa None es código que ya tiene una fecha de expiración.

Python tiene sintaxis directa para esto. if not variable: cubre listas vacías, cadenas vacías y False. Para distinguir None de un falso legítimo, usas is None o is not None, que compara identidad en memoria, no equivalencia de valor.

# Evaluación de colecciones y variables nulas en un entorno de red

nodos_activos = []
configuracion_actual = False
backup_id = "None"
token_auth = None

if not nodos_activos:
    # Equivalente idiomático a: if nodos_activos == []
    print("ERROR FATAL: El clúster no tiene nodos activos. Tráfico no ruteable.")

if not configuracion_actual is True:
    print("Advertencia: Se está operando con la configuración por defecto.")

if token_auth is None:
    # `is None` comprueba el objeto de memoria, no solo que sea evaluado como falso (0, "", [])
    print("Autorización denegada: Falta el token de API.")