Operadores Lógicos

Los operadores lógicos son como los supervisores de tu almacén que toman decisiones basadas en múltiples condiciones. ¿Recuerdas cuando hablamos de las condiciones booleanas? Los operadores lógicos te permiten combinar varias de estas condiciones para tomar decisiones más complejas.

Imagina que estás revisando el inventario de tu almacén y necesitas encontrar productos que cumplan con múltiples criterios. Los operadores lógicos te ayudan a combinar estas condiciones de manera elegante.

Los Tres Operadores Lógicos Fundamentales

1. El Operador and (Y)

El operador and es como un supervisor muy estricto: ambas condiciones deben ser verdaderas para que el resultado sea True.

# Verificando inventario del almacén
stock_suficiente = True
precio_razonable = True

# Ambas condiciones deben cumplirse
comprar_producto = stock_suficiente and precio_razonable
print(f"¿Comprar producto? {comprar_producto}")  # True

# Si una falla, el resultado es False
stock_suficiente = False
comprar_producto = stock_suficiente and precio_razonable
print(f"¿Comprar producto? {comprar_producto}")  # False

Ejemplos Prácticos con and

# Sistema de acceso al almacén
usuario_autorizado = True
horario_laboral = True
sistema_activo = True

acceso_permitido = usuario_autorizado and horario_laboral and sistema_activo
print(f"Acceso permitido: {acceso_permitido}")

# Validación de pedidos
cantidad = 50
precio_unitario = 15.99

pedido_valido = cantidad > 0 and precio_unitario > 0
print(f"Pedido válido: {pedido_valido}")

# Verificación de empleado
edad = 25
experiencia_años = 3

puede_operar_montacargas = edad >= 18 and experiencia_años >= 2
print(f"Puede operar montacargas: {puede_operar_montacargas}")

2. El Operador or (O)

El operador or es más flexible: al menos una condición debe ser verdadera para que el resultado sea True.

# Métodos de pago aceptados
pago_efectivo = False
pago_tarjeta = True
pago_transferencia = False

pago_aceptado = pago_efectivo or pago_tarjeta or pago_transferencia
print(f"Pago aceptado: {pago_aceptado}")  # True (al menos uno es True)

# Horarios de atención
es_dia_laborable = False
es_sabado = True

almacen_abierto = es_dia_laborable or es_sabado
print(f"Almacén abierto: {almacen_abierto}")  # True

Ejemplos Prácticos con or

# Sistema de alertas
temperatura_alta = False
humedad_alta = True
presion_baja = False

alerta_ambiental = temperatura_alta or humedad_alta or presion_baja
print(f"Activar alerta: {alerta_ambiental}")  # True

# Descuentos por volumen
es_cliente_premium = False
compra_mayor_1000 = True

aplicar_descuento = es_cliente_premium or compra_mayor_1000
print(f"Aplicar descuento: {aplicar_descuento}")  # True

# Autorización de devolución
producto_defectuoso = False
cliente_insatisfecho = True
error_facturacion = False

autorizar_devolucion = producto_defectuoso or cliente_insatisfecho or error_facturacion
print(f"Autorizar devolución: {autorizar_devolucion}")  # True

3. El Operador not (NO)

El operador not es como invertir una decisión: convierte True en False y viceversa.

# Estado del sistema
sistema_funcionando = True
sistema_en_mantenimiento = not sistema_funcionando

print(f"Sistema funcionando: {sistema_funcionando}")      # True
print(f"Sistema en mantenimiento: {sistema_en_mantenimiento}")  # False

# Control de acceso
acceso_denegado = False
acceso_permitido = not acceso_denegado

print(f"Acceso permitido: {acceso_permitido}")  # True

Ejemplos Prácticos con not

# Gestión de inventario
producto_disponible = True
producto_agotado = not producto_disponible

if not producto_agotado:
    print("Producto disponible para venta")

# Validación de datos
campo_vacio = False
campo_completo = not campo_vacio

if not campo_vacio:
    print("Todos los campos están completos")

# Estado de empleados
empleado_activo = True
empleado_inactivo = not empleado_activo

if not empleado_inactivo:
    print("Empleado puede acceder al sistema")

Combinando Operadores Lógicos

La verdadera potencia viene cuando combinas estos operadores para crear lógica más compleja:

# Sistema integral de gestión de almacén
def evaluar_pedido(stock, precio, cliente_premium, pago_confirmado):
    # Condiciones básicas
    stock_disponible = stock > 0
    precio_valido = precio > 0
    
    # Condición de cliente
    cliente_valido = cliente_premium or pago_confirmado
    
    # Decisión final
    procesar_pedido = stock_disponible and precio_valido and cliente_valido
    
    return procesar_pedido

# Ejemplos de uso
resultado1 = evaluar_pedido(stock=10, precio=25.99, cliente_premium=True, pago_confirmado=False)
print(f"Pedido 1 aprobado: {resultado1}")  # True

resultado2 = evaluar_pedido(stock=0, precio=25.99, cliente_premium=True, pago_confirmado=True)
print(f"Pedido 2 aprobado: {resultado2}")  # False (sin stock)

resultado3 = evaluar_pedido(stock=5, precio=15.99, cliente_premium=False, pago_confirmado=True)
print(f"Pedido 3 aprobado: {resultado3}")  # True

Precedencia de Operadores Lógicos

Python evalúa los operadores lógicos en este orden:

1. not (primero)
2. and (segundo)
3. or (último)

# Sin paréntesis
resultado = True or False and not True
# Se evalúa como: True or (False and (not True))
# Se evalúa como: True or (False and False)
# Se evalúa como: True or False
# Resultado: True
print(resultado)  # True

# Con paréntesis para mayor claridad
resultado_claro = (True or False) and (not True)
# Se evalúa como: True and False
# Resultado: False
print(resultado_claro)  # False

Ejemplos del Mundo Real

Sistema de Alarmas del Almacén

def verificar_seguridad(hora, movimiento_detectado, puerta_abierta, personal_autorizado):
    # Horario fuera de oficina (antes de 7 AM o después de 6 PM)
    fuera_horario = hora < 7 or hora > 18
    
    # Actividad sospechosa
    actividad_sospechosa = movimiento_detectado and puerta_abierta
    
    # Condición de alarma
    activar_alarma = fuera_horario and actividad_sospechosa and not personal_autorizado
    
    return activar_alarma

# Pruebas del sistema
print("=== PRUEBAS DEL SISTEMA DE ALARMAS ===")
print(f"Caso 1: {verificar_seguridad(hora=20, movimiento_detectado=True, puerta_abierta=True, personal_autorizado=False)}")  # True
print(f"Caso 2: {verificar_seguridad(hora=10, movimiento_detectado=True, puerta_abierta=True, personal_autorizado=False)}")  # False
print(f"Caso 3: {verificar_seguridad(hora=20, movimiento_detectado=True, puerta_abierta=True, personal_autorizado=True)}")   # False

Sistema de Descuentos

def calcular_descuento(cliente_premium, compra_mayor_500, es_cumpleanos, primera_compra):
    # Descuento por cliente premium O compra grande
    descuento_basico = cliente_premium or compra_mayor_500
    
    # Descuento especial
    descuento_especial = es_cumpleanos or primera_compra
    
    # Descuento final
    tiene_descuento = descuento_basico or descuento_especial
    
    if tiene_descuento:
        if cliente_premium and compra_mayor_500:
            return 20  # Descuento máximo
        elif descuento_especial:
            return 15  # Descuento especial
        else:
            return 10  # Descuento básico
    
    return 0  # Sin descuento

# Ejemplos
print("=== SISTEMA DE DESCUENTOS ===")
print(f"Cliente premium con compra grande: {calcular_descuento(True, True, False, False)}%")     # 20%
print(f"Primera compra: {calcular_descuento(False, False, False, True)}%")                       # 15%
print(f"Cliente regular: {calcular_descuento(False, False, False, False)}%")                     # 0%

Trucos y Consejos Profesionales

1. Evaluación Perezosa (Short-circuit Evaluation)

Python es inteligente y no evalúa expresiones innecesarias:

# Con 'and': si el primer valor es False, no evalúa el segundo
stock = 0
precio = 100

# Como stock es 0 (False), no se evalúa precio > 0
resultado = stock > 0 and precio > 0
print(resultado)  # False

# Con 'or': si el primer valor es True, no evalúa el segundo
es_admin = True
edad_suficiente = False  # No se evalúa porque es_admin ya es True

acceso = es_admin or edad_suficiente
print(acceso)  # True

2. Usar Paréntesis para Claridad

# Difícil de leer
resultado = cliente_premium or compra_grande and not producto_agotado or es_oferta

# Más claro
resultado = cliente_premium or (compra_grande and not producto_agotado) or es_oferta

3. Variables Booleanas Descriptivas

# En lugar de esto:
if not (edad < 18 or experiencia < 1):
    print("Puede operar")

# Mejor así:
menor_de_edad = edad < 18
sin_experiencia = experiencia < 1
no_calificado = menor_de_edad or sin_experiencia

if not no_calificado:
    print("Puede operar")

Ejercicios Prácticos

# 🎯 Ejercicio 1: Sistema de Control de Calidad
def control_calidad(peso, color_correcto, sin_defectos, empaque_intacto):
    """
    Un producto pasa control de calidad si:
    - Tiene el peso correcto Y color correcto Y sin defectos
    - O si tiene empaque intacto Y sin defectos (producto de excepción)
    """
    # Tu código aquí
    pass

# 🎯 Ejercicio 2: Horario de Atención
def almacen_abierto(dia_semana, hora, es_feriado):
    """
    El almacén está abierto si:
    - Es día laborable (1-5) Y hora entre 8-18 Y no es feriado
    - O es sábado (6) Y hora entre 9-14 Y no es feriado
    """
    # Tu código aquí
    pass

# 🎯 Ejercicio 3: Sistema de Envío
def calcular_envio(peso, destino_nacional, cliente_premium, compra_mayor_100):
    """
    Envío gratis si:
    - Es destino nacional Y (cliente premium O compra mayor a $100)
    - O peso menor a 5kg Y destino nacional
    """
    # Tu código aquí
    pass

Resumen de Operadores Lógicos

Los operadores lógicos son fundamentales para crear programas inteligentes que puedan tomar decisiones complejas. ¡Dominarlos te convertirá en un programador mucho más eficiente!

En el próximo capítulo, exploraremos los operadores de comparación que trabajan de la mano con los operadores lógicos para crear condiciones poderosas.