Resumen y Expresiones Complejas

Ya hemos explorado todos los tipos de operadores individualmente. Ahora es momento de combinarlos para crear expresiones complejas y poderosas, como un maestro chef que combina ingredientes básicos para crear platos extraordinarios. En tu almacén digital, estas expresiones complejas te permitirán tomar decisiones sofisticadas y automatizar procesos avanzados.

Las expresiones complejas son la verdadera magia de la programación: combinan múltiples operadores, tipos de datos y lógica para resolver problemas del mundo real de manera elegante y eficiente.

Precedencia de Operadores: El Orden Importa

Al igual que las matemáticas, Python tiene un orden específico para evaluar las operaciones. Conocer esta precedencia te evitará errores y te dará control total sobre tus expresiones.

# Precedencia de operadores (de mayor a menor)
resultado = 2 + 3 * 4  # Multiplicación primero: 2 + 12 = 14
print(f"2 + 3 * 4 = {resultado}")

# Usando paréntesis para cambiar el orden
resultado = (2 + 3) * 4  # Suma primero: 5 * 4 = 20
print(f"(2 + 3) * 4 = {resultado}")

# Ejemplo complejo con múltiples operadores
precio_base = 100
descuento = 0.1
cantidad = 5
es_cliente_premium = True

# Sin paréntesis - ¿qué se evalúa primero?
total_confuso = precio_base * cantidad - precio_base * descuento and es_cliente_premium

# Con paréntesis - intención clara
total_claro = (precio_base * cantidad) - (precio_base * descuento * (1 if es_cliente_premium else 0))

print(f"Resultado confuso: {total_confuso}")
print(f"Resultado claro: ${total_claro:.2f}")

Tabla de Precedencia Completa

# Demostrando precedencia con ejemplos prácticos

# 1. Paréntesis (mayor precedencia)
resultado = (5 + 3) * 2  # 16

# 2. Exponenciación (**)
resultado = 2 ** 3 ** 2  # 2 ** (3 ** 2) = 2 ** 9 = 512

# 3. Operadores unarios (+, -, not)
resultado = -5 ** 2  # -(5 ** 2) = -25
resultado = (-5) ** 2  # 25

# 4. Multiplicación, división, módulo (*, /, //, %)
resultado = 10 + 5 * 2  # 10 + 10 = 20

# 5. Suma y resta (+, -)
resultado = 5 * 2 + 3  # 10 + 3 = 13

# 6. Desplazamiento de bits (<<, >>)
resultado = 8 + 4 << 1  # (8 + 4) << 1 = 12 << 1 = 24

# 7. AND bit a bit (&)
resultado = 5 | 3 & 1  # 5 | (3 & 1) = 5 | 1 = 5

# 8. XOR bit a bit (^)
resultado = 5 | 3 ^ 1  # 5 | (3 ^ 1) = 5 | 2 = 7

# 9. OR bit a bit (|)
resultado = 5 + 3 | 1  # (5 + 3) | 1 = 8 | 1 = 9

# 10. Comparaciones (==, !=, <, <=, >, >=, is, is not, in, not in)
resultado = 5 + 3 > 6  # (5 + 3) > 6 = 8 > 6 = True

# 11. NOT lógico (not)
resultado = not 5 > 3  # not (5 > 3) = not True = False

# 12. AND lógico (and)
resultado = True or False and False  # True or (False and False) = True or False = True

# 13. OR lógico (or) - menor precedencia
resultado = False and True or True  # (False and True) or True = False or True = True

print("Todas las precedencias aplicadas correctamente")

Expresiones del Mundo Real: Sistema de Gestión de Almacén

Sistema de Evaluación de Pedidos

class EvaluadorPedidos:
    def __init__(self):
        self.inventario = {
            "leche": {"cantidad": 100, "precio": 3.50, "categoria": "lacteos", "perecedero": True},
            "pan": {"cantidad": 50, "precio": 2.25, "categoria": "panaderia", "perecedero": True},
            "arroz": {"cantidad": 200, "precio": 1.80, "categoria": "granos", "perecedero": False},
            "pollo": {"cantidad": 30, "precio": 8.90, "categoria": "carnes", "perecedero": True},
            "detergente": {"cantidad": 75, "precio": 4.50, "categoria": "limpieza", "perecedero": False}
        }
        
        self.descuentos_categoria = {
            "lacteos": 0.05,      # 5%
            "carnes": 0.10,       # 10%
            "limpieza": 0.15,     # 15%
            "granos": 0.03        # 3%
        }
        
        self.cliente_premium_descuento = 0.08  # 8% adicional
        self.descuento_volumen_minimo = 100    # Descuento por volumen si compra > $100
        self.descuento_volumen_porcentaje = 0.05  # 5%
    
    def evaluar_pedido(self, pedidos, es_cliente_premium=False, pago_contado=False):
        """
        Evaluar un pedido complejo con múltiples reglas de negocio
        
        Reglas:
        1. Verificar disponibilidad de stock
        2. Aplicar descuentos por categoría
        3. Descuento premium si es cliente premium
        4. Descuento por volumen si total > $100
        5. Descuento adicional por pago de contado
        6. Alerta especial para productos perecederos
        """
        
        subtotal = 0
        productos_validos = []
        productos_rechazados = []
        alertas = []
        
        # Fase 1: Validar disponibilidad y calcular subtotal
        for producto, cantidad_solicitada in pedidos:
            if (producto in self.inventario and 
                self.inventario[producto]["cantidad"] >= cantidad_solicitada and
                cantidad_solicitada > 0):
                
                info_producto = self.inventario[producto]
                precio_unitario = info_producto["precio"]
                precio_total = precio_unitario * cantidad_solicitada
                
                productos_validos.append({
                    "producto": producto,
                    "cantidad": cantidad_solicitada,
                    "precio_unitario": precio_unitario,
                    "precio_total": precio_total,
                    "categoria": info_producto["categoria"],
                    "perecedero": info_producto["perecedero"]
                })
                
                subtotal += precio_total
                
                # Alerta para productos perecederos en grandes cantidades
                if info_producto["perecedero"] and cantidad_solicitada > 10:
                    alertas.append(f"⚠️ {producto}: Gran cantidad de producto perecedero ({cantidad_solicitada} unidades)")
                
            else:
                razon = ("Producto no existe" if producto not in self.inventario else
                        f"Stock insuficiente (disponible: {self.inventario[producto]['cantidad']})" 
                        if self.inventario[producto]["cantidad"] < cantidad_solicitada else
                        "Cantidad inválida")
                
                productos_rechazados.append({
                    "producto": producto,
                    "cantidad": cantidad_solicitada,
                    "razon": razon
                })
        
        # Fase 2: Aplicar descuentos complejos
        descuento_total = 0
        detalle_descuentos = []
        
        # Descuentos por categoría
        for item in productos_validos:
            categoria = item["categoria"]
            if categoria in self.descuentos_categoria:
                descuento_categoria = item["precio_total"] * self.descuentos_categoria[categoria]
                descuento_total += descuento_categoria
                detalle_descuentos.append(f"Descuento {categoria}: -${descuento_categoria:.2f}")
        
        # Descuento cliente premium (aplica sobre el subtotal después de descuentos por categoría)
        if es_cliente_premium:
            descuento_premium = (subtotal - descuento_total) * self.cliente_premium_descuento
            descuento_total += descuento_premium
            detalle_descuentos.append(f"Descuento Premium: -${descuento_premium:.2f}")
        
        # Descuento por volumen (aplica si el subtotal supera el mínimo)
        if subtotal > self.descuento_volumen_minimo:
            descuento_volumen = (subtotal - descuento_total) * self.descuento_volumen_porcentaje
            descuento_total += descuento_volumen
            detalle_descuentos.append(f"Descuento por volumen: -${descuento_volumen:.2f}")
        
        # Descuento por pago de contado (aplica sobre el total después de otros descuentos)
        if pago_contado:
            descuento_contado = (subtotal - descuento_total) * 0.03  # 3%
            descuento_total += descuento_contado
            detalle_descuentos.append(f"Descuento pago contado: -${descuento_contado:.2f}")
        
        # Cálculos finales
        total_final = subtotal - descuento_total
        porcentaje_descuento_total = (descuento_total / subtotal * 100) if subtotal > 0 else 0
        
        # Fase 3: Evaluación final y recomendaciones
        recomendaciones = []
        
        # Recomendar cliente premium si no lo es y compra mucho
        if not es_cliente_premium and subtotal > 150:
            ahorro_potencial = subtotal * self.cliente_premium_descuento
            recomendaciones.append(f"💡 Considera membresía Premium (ahorrarías ${ahorro_potencial:.2f} en esta compra)")
        
        # Recomendar completar productos para mayor descuento
        if subtotal < self.descuento_volumen_minimo:
            faltante = self.descuento_volumen_minimo - subtotal
            recomendaciones.append(f"💡 Agrega ${faltante:.2f} más para descuento por volumen")
        
        # Verificar productos perecederos sin descuento
        productos_perecederos_sin_descuento = [
            item["producto"] for item in productos_validos
            if item["perecedero"] and item["categoria"] not in self.descuentos_categoria
        ]
        
        if productos_perecederos_sin_descuento:
            recomendaciones.append(f"⏰ Productos perecederos: {', '.join(productos_perecederos_sin_descuento)}")
        
        return {
            "pedido_valido": len(productos_validos) > 0,
            "productos_validos": productos_validos,
            "productos_rechazados": productos_rechazados,
            "subtotal": subtotal,
            "descuento_total": descuento_total,
            "total_final": total_final,
            "porcentaje_descuento": porcentaje_descuento_total,
            "detalle_descuentos": detalle_descuentos,
            "alertas": alertas,
            "recomendaciones": recomendaciones
        }

# Ejemplo de uso del sistema
evaluador = EvaluadorPedidos()

# Pedido complejo
pedido_ejemplo = [
    ("leche", 15),      # Producto perecedero con descuento
    ("pollo", 5),       # Producto perecedero con descuento alto
    ("arroz", 8),       # Producto no perecedero con descuento bajo
    ("detergente", 3),  # Producto no perecedero con descuento alto
    ("yogur", 2)        # Producto que no existe
]

# Evaluar diferentes escenarios
escenarios = [
    ("Cliente Regular - Tarjeta", False, False),
    ("Cliente Premium - Tarjeta", True, False),
    ("Cliente Regular - Contado", False, True),
    ("Cliente Premium - Contado", True, True)
]

print("=" * 80)
print("EVALUACIÓN DE PEDIDOS COMPLEJOS")
print("=" * 80)

for nombre_escenario, es_premium, pago_contado in escenarios:
    print(f"\n🔍 ESCENARIO: {nombre_escenario}")
    print("-" * 50)
    
    resultado = evaluador.evaluar_pedido(pedido_ejemplo, es_premium, pago_contado)
    
    # Mostrar productos válidos
    if resultado["productos_validos"]:
        print("✅ PRODUCTOS ACEPTADOS:")
        for item in resultado["productos_validos"]:
            print(f"  - {item['producto']}: {item['cantidad']} x ${item['precio_unitario']:.2f} = ${item['precio_total']:.2f}")
    
    # Mostrar productos rechazados
    if resultado["productos_rechazados"]:
        print("\n❌ PRODUCTOS RECHAZADOS:")
        for item in resultado["productos_rechazados"]:
            print(f"  - {item['producto']} ({item['cantidad']} unidades): {item['razon']}")
    
    # Mostrar cálculos financieros
    print(f"\n💰 RESUMEN FINANCIERO:")
    print(f"  Subtotal: ${resultado['subtotal']:.2f}")
    
    if resultado["detalle_descuentos"]:
        print("  Descuentos aplicados:")
        for descuento in resultado["detalle_descuentos"]:
            print(f"    • {descuento}")
        print(f"  Total descuentos: -${resultado['descuento_total']:.2f} ({resultado['porcentaje_descuento']:.1f}%)")
    
    print(f"  🎯 TOTAL FINAL: ${resultado['total_final']:.2f}")
    
    # Mostrar alertas y recomendaciones
    if resultado["alertas"]:
        print("\n⚠️ ALERTAS:")
        for alerta in resultado["alertas"]:
            print(f"  {alerta}")
    
    if resultado["recomendaciones"]:
        print("\n💡 RECOMENDACIONES:")
        for recomendacion in resultado["recomendaciones"]:
            print(f"  {recomendacion}")
    
    print("\n" + "=" * 50)

Expresiones Condicionales Avanzadas

Sistema de Clasificación Inteligente

class ClasificadorInteligente:
    """Sistema que combina múltiples criterios para clasificar elementos"""
    
    @staticmethod
    def clasificar_empleado(edad, experiencia, rendimiento, certificaciones, idiomas):
        """
        Clasificar empleado usando expresiones complejas
        
        Criterios de clasificación:
        - Junior: edad 18-25, experiencia < 2 años, rendimiento > 70
        - Senior: experiencia >= 5 años, rendimiento > 80, certificaciones >= 2
        - Lead: experiencia >= 8 años, rendimiento > 85, certificaciones >= 3, idiomas >= 2
        - Especialista: certificaciones >= 5, rendimiento > 90
        """
        
        # Expresiones complejas que combinan múltiples operadores
        es_junior = (18 <= edad <= 25 and 
                    experiencia < 2 and 
                    rendimiento > 70 and
                    not (certificaciones >= 3 or idiomas >= 2))
        
        es_senior = (experiencia >= 5 and 
                    rendimiento > 80 and 
                    certificaciones >= 2 and
                    not (experiencia >= 8 and certificaciones >= 3))
        
        es_lead = (experiencia >= 8 and 
                  rendimiento > 85 and 
                  certificaciones >= 3 and 
                  idiomas >= 2 and
                  not (certificaciones >= 5 and rendimiento > 90))
        
        es_especialista = (certificaciones >= 5 and 
                          rendimiento > 90)
        
        # Evaluación con prioridad
        if es_especialista:
            return "Especialista", "🏅", 5000
        elif es_lead:
            return "Lead", "👑", 4000
        elif es_senior:
            return "Senior", "⭐", 3000
        elif es_junior:
            return "Junior", "🌱", 2000
        else:
            return "Trainee", "📚", 1500
    
    @staticmethod
    def evaluar_riesgo_credito(ingresos, deudas, historial_credito, edad, empleo_estable):
        """
        Evaluar riesgo crediticio con lógica compleja
        """
        # Relación deuda-ingreso
        ratio_deuda = deudas / ingresos if ingresos > 0 else float('inf')
        
        # Expresión compleja para determinar riesgo
        riesgo_bajo = (ingresos >= 3000 and 
                      ratio_deuda <= 0.3 and 
                      historial_credito >= 750 and 
                      empleo_estable and 
                      edad >= 25)
        
        riesgo_medio = (not riesgo_bajo and 
                       ingresos >= 2000 and 
                       ratio_deuda <= 0.5 and 
                       historial_credito >= 650 and 
                       empleo_estable)
        
        riesgo_alto = (not (riesgo_bajo or riesgo_medio) and 
                      ingresos >= 1000 and 
                      ratio_deuda <= 0.7 and 
                      historial_credito >= 500)
        
        if riesgo_bajo:
            return "Bajo", "✅", 0.05  # 5% interés
        elif riesgo_medio:
            return "Medio", "⚠️", 0.12  # 12% interés
        elif riesgo_alto:
            return "Alto", "⚡", 0.25   # 25% interés
        else:
            return "Muy Alto", "❌", None  # No aprobado

# Ejemplos de clasificación
print("=" * 60)
print("SISTEMA DE CLASIFICACIÓN INTELIGENTE")
print("=" * 60)

# Datos de empleados para clasificar
empleados_datos = [
    ("Ana", 23, 1.5, 75, 1, 1),      # Junior
    ("Carlos", 30, 6, 85, 3, 1),     # Senior  
    ("María", 35, 10, 88, 4, 3),     # Lead
    ("Roberto", 28, 7, 92, 6, 2),    # Especialista
    ("Elena", 22, 0.5, 65, 0, 1)     # Trainee
]

print("🏢 CLASIFICACIÓN DE EMPLEADOS:")
for nombre, edad, exp, rend, cert, idiomas in empleados_datos:
    categoria, emoji, salario = ClasificadorInteligente.clasificar_empleado(
        edad, exp, rend, cert, idiomas
    )
    print(f"{emoji} {nombre}: {categoria} (${salario:,})")
    print(f"   Edad: {edad}, Exp: {exp} años, Rend: {rend}%, Cert: {cert}, Idiomas: {idiomas}")

print("\n💳 EVALUACIÓN DE RIESGO CREDITICIO:")
clientes_credito = [
    ("Cliente A", 5000, 1000, 800, 30, True),   # Bajo riesgo
    ("Cliente B", 2500, 1000, 700, 28, True),   # Medio riesgo
    ("Cliente C", 1500, 800, 600, 25, False),   # Alto riesgo
    ("Cliente D", 800, 600, 450, 20, False)     # Muy alto riesgo
]

for nombre, ingresos, deudas, historial, edad, empleo in clientes_credito:
    riesgo, emoji, interes = ClasificadorInteligente.evaluar_riesgo_credito(
        ingresos, deudas, historial, edad, empleo
    )
    aprobacion = "APROBADO" if interes else "RECHAZADO"
    interes_str = f"{interes*100:.1f}%" if interes else "N/A"
    
    print(f"{emoji} {nombre}: {riesgo} - {aprobacion} (Interés: {interes_str})")
    print(f"   Ingresos: ${ingresos:,}, Deudas: ${deudas:,}, Score: {historial}")

Expresiones con Operadores Ternarios

Python permite crear expresiones condicionales compactas usando el operador ternario.

# Sintaxis: valor_si_verdadero if condicion else valor_si_falso

def procesar_inventario(productos):
    """Procesar inventario con expresiones ternarias elegantes"""
    
    resultados = []
    
    for nombre, cantidad, precio in productos:
        # Expresiones ternarias anidadas y complejas
        estado = ("AGOTADO" if cantidad == 0 else
                 "BAJO" if cantidad < 10 else
                 "CRÍTICO" if cantidad < 5 else
                 "NORMAL")
        
        urgencia = ("🚨" if cantidad == 0 else
                   "⚠️" if cantidad < 10 else
                   "⚡" if cantidad < 5 else
                   "✅")
        
        # Expresión compleja para calcular descuento
        descuento = (0.20 if cantidad == 0 else  # 20% para liquidación
                    0.15 if cantidad < 5 else    # 15% por cantidad crítica  
                    0.10 if cantidad < 10 else   # 10% por cantidad baja
                    0.05 if precio > 50 else     # 5% para productos caros
                    0.0)                         # Sin descuento
        
        precio_final = precio * (1 - descuento)
        
        # Mensaje personalizado usando expresiones ternarias
        mensaje = (f"¡LIQUIDACIÓN! {descuento*100:.0f}% OFF" if descuento >= 0.15 else
                  f"Oferta especial: {descuento*100:.0f}% descuento" if descuento > 0 else
                  "Precio regular")
        
        resultados.append({
            "nombre": nombre,
            "cantidad": cantidad,
            "precio_original": precio,
            "precio_final": precio_final,
            "descuento": descuento,
            "estado": estado,
            "urgencia": urgencia,
            "mensaje": mensaje
        })
    
    return resultados

# Ejemplo de uso
productos_inventario = [
    ("Laptop Gaming", 0, 1200.00),    # Agotado
    ("Mouse Inalámbrico", 3, 45.00),  # Crítico
    ("Teclado Mecánico", 8, 85.00),   # Bajo
    ("Monitor 4K", 15, 350.00),       # Normal, producto caro
    ("Audífonos", 25, 30.00)          # Normal, producto barato
]

print("=" * 70)
print("PROCESAMIENTO DE INVENTARIO CON EXPRESIONES TERNARIAS")
print("=" * 70)

resultados = procesar_inventario(productos_inventario)

for item in resultados:
    print(f"{item['urgencia']} {item['nombre']}")
    print(f"   Estado: {item['estado']} | Cantidad: {item['cantidad']}")
    print(f"   Precio: ${item['precio_original']:.2f} → ${item['precio_final']:.2f}")
    print(f"   {item['mensaje']}")
    print()

Expresiones Lambda y Funciones de Orden Superior

Las expresiones lambda te permiten crear funciones pequeñas e inline para transformar datos.

# Procesamiento avanzado de datos con lambdas
ventas_datos = [
    {"producto": "Laptop", "cantidad": 5, "precio": 1000, "vendedor": "Ana", "mes": "Enero"},
    {"producto": "Mouse", "cantidad": 15, "precio": 25, "vendedor": "Carlos", "mes": "Enero"},
    {"producto": "Teclado", "cantidad": 8, "precio": 75, "vendedor": "Ana", "mes": "Febrero"},
    {"producto": "Monitor", "cantidad": 3, "precio": 300, "vendedor": "María", "mes": "Febrero"},
    {"producto": "Laptop", "cantidad": 2, "precio": 1000, "vendedor": "Carlos", "mes": "Marzo"},
]

print("=" * 60)
print("ANÁLISIS DE VENTAS CON EXPRESIONES LAMBDA")
print("=" * 60)

# 1. Calcular total de ventas por producto
ventas_con_total = list(map(
    lambda venta: {**venta, "total": venta["cantidad"] * venta["precio"]},
    ventas_datos
))

print("💰 VENTAS CON TOTALES:")
for venta in ventas_con_total:
    print(f"  {venta['producto']}: {venta['cantidad']} x ${venta['precio']} = ${venta['total']:,}")

# 2. Filtrar ventas importantes (total > $500)
ventas_importantes = list(filter(
    lambda venta: venta["cantidad"] * venta["precio"] > 500,
    ventas_datos
))

print(f"\n🎯 VENTAS IMPORTANTES (>$500): {len(ventas_importantes)} transacciones")

# 3. Agrupar ventas por vendedor usando expresiones complejas
from collections import defaultdict

ventas_por_vendedor = defaultdict(lambda: {"total_ventas": 0, "productos_vendidos": 0, "transacciones": 0})

for venta in ventas_datos:
    vendedor = venta["vendedor"]
    total_venta = venta["cantidad"] * venta["precio"]
    
    ventas_por_vendedor[vendedor]["total_ventas"] += total_venta
    ventas_por_vendedor[vendedor]["productos_vendidos"] += venta["cantidad"]
    ventas_por_vendedor[vendedor]["transacciones"] += 1

print("\n👥 RESUMEN POR VENDEDOR:")
for vendedor, stats in ventas_por_vendedor.items():
    promedio = stats["total_ventas"] / stats["transacciones"]
    print(f"  {vendedor}: ${stats['total_ventas']:,} ({stats['productos_vendidos']} productos, promedio: ${promedio:.0f})")

# 4. Ranking de productos usando lambdas complejas
from functools import reduce

# Agrupar por producto y calcular métricas
productos_stats = {}
for venta in ventas_datos:
    producto = venta["producto"]
    if producto not in productos_stats:
        productos_stats[producto] = {"ventas": [], "total_cantidad": 0, "total_ingresos": 0}
    
    productos_stats[producto]["ventas"].append(venta)
    productos_stats[producto]["total_cantidad"] += venta["cantidad"]
    productos_stats[producto]["total_ingresos"] += venta["cantidad"] * venta["precio"]

# Crear ranking usando lambda para ordenar
ranking_productos = sorted(
    productos_stats.items(),
    key=lambda item: (
        item[1]["total_ingresos"],      # Criterio principal: ingresos
        item[1]["total_cantidad"],      # Criterio secundario: cantidad
        len(item[1]["ventas"])          # Criterio terciario: frecuencia
    ),
    reverse=True
)

print("\n🏆 RANKING DE PRODUCTOS:")
for i, (producto, stats) in enumerate(ranking_productos, 1):
    print(f"  {i}. {producto}: ${stats['total_ingresos']:,} ({stats['total_cantidad']} unidades)")

# 5. Análisis predictivo usando expresiones complejas
tendencias = {}
for venta in ventas_datos:
    mes = venta["mes"]
    if mes not in tendencias:
        tendencias[mes] = {"ingresos": 0, "unidades": 0}
    
    tendencias[mes]["ingresos"] += venta["cantidad"] * venta["precio"]
    tendencias[mes]["unidades"] += venta["cantidad"]

# Calcular crecimiento mes a mes
meses_ordenados = ["Enero", "Febrero", "Marzo"]
print("\n📈 TENDENCIAS MENSUALES:")

for i, mes in enumerate(meses_ordenados):
    if mes in tendencias:
        ingresos = tendencias[mes]["ingresos"]
        unidades = tendencias[mes]["unidades"]
        
        if i > 0:
            mes_anterior = meses_ordenados[i-1]
            if mes_anterior in tendencias:
                crecimiento = ((ingresos - tendencias[mes_anterior]["ingresos"]) / 
                             tendencias[mes_anterior]["ingresos"] * 100)
                tendencia_emoji = "📈" if crecimiento > 0 else "📉" if crecimiento < 0 else "➡️"
                print(f"  {mes}: ${ingresos:,} ({unidades} unidades) {tendencia_emoji} {crecimiento:+.1f}%")
            else:
                print(f"  {mes}: ${ingresos:,} ({unidades} unidades)")
        else:
            print(f"  {mes}: ${ingresos:,} ({unidades} unidades) [Base]")

Mejores Prácticas para Expresiones Complejas

1. Usar Variables Intermedias para Claridad

# ❌ Expresión difícil de leer
resultado = (precio * cantidad * (1 - descuento) * (1 + impuesto) 
            if stock > cantidad and cliente_valido and pago_confirmado 
            else 0)

# ✅ Dividir en pasos claros
tiene_stock = stock > cantidad
transaccion_valida = cliente_valido and pago_confirmado
precio_base = precio * cantidad
precio_con_descuento = precio_base * (1 - descuento)
precio_final = precio_con_descuento * (1 + impuesto)

resultado = precio_final if tiene_stock and transaccion_valida else 0

2. Documentar Expresiones Complejas

def calcular_score_cliente(compras, valor_total, antiguedad, devoluciones):
    """
    Calcular score del cliente basado en múltiples factores
    
    Fórmula: (compras * 10 + valor_total / 100 + antiguedad * 5) / (devoluciones + 1)
    
    - Más compras = mejor score
    - Mayor valor total = mejor score  
    - Mayor antigüedad = mejor score
    - Más devoluciones = peor score
    """
    
    # Componentes del score
    puntos_compras = compras * 10           # 10 puntos por compra
    puntos_valor = valor_total / 100        # 1 punto por cada $100
    puntos_antiguedad = antiguedad * 5      # 5 puntos por mes de antigüedad
    
    # Penalización por devoluciones (evitar división por cero)
    factor_devoluciones = devoluciones + 1
    
    # Score final
    score = (puntos_compras + puntos_valor + puntos_antiguedad) / factor_devoluciones
    
    return min(score, 1000)  # Máximo 1000 puntos

3. Validar Entrada para Expresiones Complejas

def calcular_precio_dinamico(base, modificadores):
    """
    Calcular precio dinámico con validaciones robustas
    """
    # Validaciones de entrada
    if not isinstance(base, (int, float)) or base <= 0:
        raise ValueError("El precio base debe ser un número positivo")
    
    if not isinstance(modificadores, dict):
        raise ValueError("Los modificadores deben ser un diccionario")
    
    # Valores por defecto para evitar errores
    descuento = max(0, min(1, modificadores.get("descuento", 0)))  # Entre 0 y 1
    impuesto = max(0, modificadores.get("impuesto", 0))            # Mínimo 0
    factor_demanda = max(0.1, modificadores.get("demanda", 1))     # Mínimo 0.1
    
    # Expresión compleja con validaciones
    precio_final = (base * 
                   (1 - descuento) * 
                   (1 + impuesto) * 
                   factor_demanda)
    
    return round(precio_final, 2)

# Ejemplo de uso seguro
try:
    precio = calcular_precio_dinamico(100, {
        "descuento": 0.1,
        "impuesto": 0.16,
        "demanda": 1.2
    })
    print(f"Precio calculado: ${precio}")
except ValueError as e:
    print(f"Error en cálculo: {e}")

Resumen: Dominando las Expresiones Complejas

Las expresiones complejas son como las recetas maestras de la programación: combinan ingredientes básicos (operadores) para crear soluciones poderosas. Al dominar estos conceptos, puedes:

1. Escribir código más expresivo: Una línea bien construida puede reemplazar múltiples líneas de lógica
2. Tomar decisiones sofisticadas: Combinar múltiples criterios en evaluaciones complejas
3. Procesar datos eficientemente: Usar lambdas y funciones de orden superior para transformaciones elegantes
4. Crear sistemas inteligentes: Implementar lógica de negocio avanzada de manera clara y mantenible

Principios Clave para Recordar:

• Precedencia importa: Usa paréntesis para clarificar el orden de evaluación
• Legibilidad es clave: Divide expresiones complejas en pasos comprensibles
• Valida entradas: Las expresiones complejas son más propensas a errores
• Documenta lógica: Explica el “por qué” detrás de expresiones complicadas
• Prueba exhaustivamente: Expresiones complejas necesitan casos de prueba diversos

¡Con estas herramientas, puedes crear programas que tomen decisiones inteligentes y procesen información de manera sofisticada, como un verdadero maestro de la automatización de almacenes!