Operadores de Comparación
Los operadores de comparación son como los inspectores de calidad de tu almacén: constantemente evalúan y comparan valores para tomar decisiones. Estos operadores te permiten crear condiciones que determinan el flujo de tu programa, como decidir si un producto está en stock, si un precio es competitivo, o si un empleado tiene la experiencia suficiente.
Imagina que eres el supervisor de un almacén y necesitas tomar decisiones basadas en comparaciones: ¿Este producto cuesta más que el límite del presupuesto? ¿Tenemos suficiente inventario? ¿Este empleado es mayor de edad? Los operadores de comparación te dan las herramientas para hacer estas evaluaciones.
Los Seis Operadores de Comparación Fundamentales
1. Igualdad (==)
El operador == verifica si dos valores son iguales.
# Comparaciones básicas
precio_producto = 25.99
precio_limite = 25.99
print(f"¿El precio es igual al límite? {precio_producto == precio_limite}") # True
# Con cadenas
nombre_producto = "Leche"
producto_buscado = "Leche"
print(f"¿Es el producto correcto? {nombre_producto == producto_buscado}") # True
# Con listas
inventario_esperado = [10, 20, 15]
inventario_actual = [10, 20, 15]
print(f"¿El inventario coincide? {inventario_esperado == inventario_actual}") # True
Casos Prácticos de Igualdad
# Sistema de validación de pedidos
class ValidadorPedidos:
def __init__(self):
self.productos_validos = {"leche", "pan", "huevos", "queso"}
self.precio_fijo = {"pan": 2.50, "leche": 3.00}
def validar_pedido(self, producto, cantidad, precio_unitario):
"""Validar un pedido completo"""
errores = []
# Verificar producto válido
if producto not in self.productos_validos:
errores.append(f"Producto '{producto}' no válido")
# Verificar cantidad positiva
if cantidad == 0:
errores.append("La cantidad no puede ser cero")
# Verificar precio para productos con precio fijo
if producto in self.precio_fijo:
precio_correcto = self.precio_fijo[producto]
if precio_unitario != precio_correcto:
errores.append(f"Precio incorrecto para {producto}: esperado ${precio_correcto}, recibido ${precio_unitario}")
return len(errores) == 0, errores
# Ejemplos de validación
validador = ValidadorPedidos()
pedidos_test = [
("pan", 5, 2.50), # Válido
("leche", 0, 3.00), # Error: cantidad cero
("pan", 3, 2.75), # Error: precio incorrecto
("cerveza", 2, 5.00), # Error: producto no válido
]
print("=== VALIDACIÓN DE PEDIDOS ===")
for producto, cantidad, precio in pedidos_test:
valido, errores = validador.validar_pedido(producto, cantidad, precio)
estado = "✅ VÁLIDO" if valido else "❌ INVÁLIDO"
print(f"{producto} (x{cantidad} @${precio}): {estado}")
if errores:
for error in errores:
print(f" - {error}")
2. Desigualdad (!=)
El operador != verifica si dos valores son diferentes.
# Verificar cambios en el inventario
inventario_anterior = {"leche": 50, "pan": 25, "huevos": 100}
inventario_actual = {"leche": 45, "pan": 25, "huevos": 95}
for producto in inventario_anterior:
cantidad_anterior = inventario_anterior[producto]
cantidad_actual = inventario_actual[producto]
if cantidad_actual != cantidad_anterior:
diferencia = cantidad_actual - cantidad_anterior
print(f"{producto}: {cantidad_anterior} → {cantidad_actual} (cambio: {diferencia:+d})")
else:
print(f"{producto}: sin cambios ({cantidad_actual})")
# Control de acceso
def verificar_acceso(usuario_actual, usuario_autorizado):
if usuario_actual != usuario_autorizado:
print(f"❌ Acceso denegado. Usuario: {usuario_actual}")
return False
else:
print(f"✅ Acceso permitido. Bienvenido, {usuario_actual}")
return True
# Ejemplos
verificar_acceso("juan", "juan") # Permitido
verificar_acceso("maria", "juan") # Denegado
3. Menor que (<)
El operador < verifica si el valor de la izquierda es menor que el de la derecha.
# Control de stock mínimo
def verificar_stock_minimo(producto, cantidad_actual, stock_minimo):
if cantidad_actual < stock_minimo:
print(f"⚠️ ALERTA: {producto} tiene stock bajo ({cantidad_actual} < {stock_minimo})")
return True
else:
print(f"✅ {producto}: stock suficiente ({cantidad_actual} unidades)")
return False
# Ejemplos de verificación
productos_inventario = [
("Leche", 15, 20),
("Pan", 45, 30),
("Huevos", 8, 25),
("Queso", 35, 15)
]
print("=== CONTROL DE STOCK MÍNIMO ===")
productos_bajo_stock = []
for producto, cantidad, minimo in productos_inventario:
if verificar_stock_minimo(producto, cantidad, minimo):
productos_bajo_stock.append(producto)
if productos_bajo_stock:
print(f"\n📋 Productos para reordenar: {', '.join(productos_bajo_stock)}")
4. Menor o igual que (<=)
El operador <= verifica si el valor de la izquierda es menor o igual que el de la derecha.
# Sistema de descuentos por volumen
class CalculadorDescuento:
def __init__(self):
# Niveles de descuento por cantidad
self.niveles_descuento = [
(10, 0), # 0-10 unidades: sin descuento
(50, 5), # 11-50 unidades: 5% descuento
(100, 10), # 51-100 unidades: 10% descuento
(500, 15), # 101-500 unidades: 15% descuento
(float('inf'), 20) # 501+ unidades: 20% descuento
]
def calcular_descuento(self, cantidad):
"""Calcular porcentaje de descuento basado en cantidad"""
for limite, descuento in self.niveles_descuento:
if cantidad <= limite:
return descuento
return 0 # Por si acaso, aunque no debería llegar aquí
# Ejemplos de cálculo
calculadora = CalculadorDescuento()
cantidades_test = [5, 25, 75, 150, 600]
print("=== SISTEMA DE DESCUENTOS ===")
for cantidad in cantidades_test:
descuento = calculadora.calcular_descuento(cantidad)
print(f"{cantidad} unidades → {descuento}% de descuento")
# Sistema de clasificación de empleados por experiencia
def clasificar_empleado(años_experiencia):
if años_experiencia <= 1:
return "Principiante"
elif años_experiencia <= 3:
return "Junior"
elif años_experiencia <= 7:
return "Intermedio"
elif años_experiencia <= 15:
return "Senior"
else:
return "Experto"
# Ejemplos
empleados = [
("Ana", 0.5),
("Carlos", 2),
("María", 5),
("Roberto", 12),
("Elena", 20)
]
print("\n=== CLASIFICACIÓN DE EMPLEADOS ===")
for nombre, experiencia in empleados:
categoria = clasificar_empleado(experiencia)
print(f"{nombre} ({experiencia} años): {categoria}")
5. Mayor que (>)
El operador > verifica si el valor de la izquierda es mayor que el de la derecha.
# Sistema de alertas por temperatura
class MonitorTemperatura:
def __init__(self):
self.temperatura_maxima = {
"lacteos": 4,
"carnes": 2,
"congelados": -18,
"ambiente": 25
}
def verificar_temperatura(self, seccion, temperatura_actual):
"""Verificar si la temperatura está dentro del rango seguro"""
if seccion not in self.temperatura_maxima:
return "Sección no reconocida"
temp_max = self.temperatura_maxima[seccion]
if temperatura_actual > temp_max:
diferencia = temperatura_actual - temp_max
return f"🚨 TEMPERATURA ALTA: {temperatura_actual}°C (límite: {temp_max}°C, exceso: +{diferencia}°C)"
else:
return f"✅ Temperatura normal: {temperatura_actual}°C (límite: {temp_max}°C)"
# Sistema de monitoreo
monitor = MonitorTemperatura()
lecturas_temperatura = [
("lacteos", 6),
("carnes", 1),
("congelados", -15),
("ambiente", 28),
("lacteos", 3)
]
print("=== MONITOREO DE TEMPERATURA ===")
for seccion, temp in lecturas_temperatura:
resultado = monitor.verificar_temperatura(seccion, temp)
print(f"{seccion.title()}: {resultado}")
# Control de presupuesto
def evaluar_compra(precio_producto, presupuesto_disponible):
if precio_producto > presupuesto_disponible:
exceso = precio_producto - presupuesto_disponible
return False, f"Exceso de presupuesto: ${exceso:.2f}"
else:
restante = presupuesto_disponible - precio_producto
return True, f"Compra autorizada. Restante: ${restante:.2f}"
# Ejemplos
presupuesto = 1000.00
compras_propuestas = [750.50, 1200.00, 999.99, 1000.01]
print("\n=== CONTROL DE PRESUPUESTO ===")
for precio in compras_propuestas:
autorizada, mensaje = evaluar_compra(precio, presupuesto)
estado = "✅ AUTORIZADA" if autorizada else "❌ RECHAZADA"
print(f"${precio:.2f}: {estado} - {mensaje}")
6. Mayor o igual que (>=)
El operador >= verifica si el valor de la izquierda es mayor o igual que el de la derecha.
# Sistema de control de edad para productos restringidos
class ControlEdad:
def __init__(self):
self.productos_restringidos = {
"alcohol": 18,
"tabaco": 18,
"medicamentos": 16,
"herramientas_electricas": 18,
"productos_quimicos": 21
}
def puede_comprar(self, producto, edad_cliente):
"""Verificar si el cliente puede comprar el producto"""
if producto not in self.productos_restringidos:
return True, "Producto sin restricción de edad"
edad_minima = self.productos_restringidos[producto]
if edad_cliente >= edad_minima:
return True, f"Edad suficiente ({edad_cliente} >= {edad_minima})"
else:
diferencia = edad_minima - edad_cliente
return False, f"Edad insuficiente. Faltan {diferencia} años"
# Ejemplos de control
control = ControlEdad()
transacciones = [
("alcohol", 20),
("tabaco", 17),
("medicamentos", 16),
("productos_quimicos", 19),
("leche", 15) # Sin restricción
]
print("=== CONTROL DE EDAD ===")
for producto, edad in transacciones:
puede, razon = control.puede_comprar(producto, edad)
estado = "✅ PERMITIDO" if puede else "❌ DENEGADO"
print(f"{producto} (cliente {edad} años): {estado} - {razon}")
# Sistema de calificación de rendimiento
def evaluar_rendimiento(puntuacion):
"""Evaluar rendimiento basado en puntuación"""
if puntuacion >= 95:
return "Excelente", "🏆"
elif puntuacion >= 85:
return "Muy bueno", "🥉"
elif puntuacion >= 75:
return "Bueno", "👍"
elif puntuacion >= 65:
return "Satisfactorio", "👌"
else:
return "Necesita mejorar", "📈"
# Evaluaciones de empleados
empleados_evaluacion = [
("Ana", 97),
("Carlos", 88),
("María", 76),
("Roberto", 63),
("Elena", 91)
]
print("\n=== EVALUACIONES DE RENDIMIENTO ===")
for nombre, puntuacion in empleados_evaluacion:
categoria, emoji = evaluar_rendimiento(puntuacion)
print(f"{nombre}: {puntuacion} puntos → {categoria} {emoji}")
Comparaciones con Diferentes Tipos de Datos
Comparaciones Numéricas
# Trabajando con diferentes tipos numéricos
precio_entero = 25
precio_decimal = 25.0
precio_string = "25"
print(f"Entero == Decimal: {precio_entero == precio_decimal}") # True
print(f"Entero == String: {precio_entero == int(precio_string)}") # True (después de conversión)
print(f"Decimal > Entero: {precio_decimal > precio_entero}") # False
# Comparaciones con flotantes - cuidado con la precisión
precio1 = 0.1 + 0.2
precio2 = 0.3
print(f"0.1 + 0.2 == 0.3: {precio1 == precio2}") # False! (problema de precisión)
print(f"Valores: {precio1} vs {precio2}")
# Solución para flotantes
def comparar_flotantes(a, b, tolerancia=1e-9):
return abs(a - b) < tolerancia
print(f"Comparación segura: {comparar_flotantes(precio1, precio2)}") # True
Comparaciones de Cadenas
# Comparaciones alfabéticas
productos = ["Manzana", "Banana", "Cereza", "Durazno"]
# Ordenamiento alfabético
for i in range(len(productos) - 1):
for j in range(i + 1, len(productos)):
if productos[i] > productos[j]: # Comparación alfabética
productos[i], productos[j] = productos[j], productos[i]
print(f"Productos ordenados: {productos}")
# Comparaciones sensibles a mayúsculas/minúsculas
nombre1 = "Juan"
nombre2 = "juan"
print(f"'Juan' == 'juan': {nombre1 == nombre2}") # False
print(f"'Juan' == 'juan' (insensible): {nombre1.lower() == nombre2.lower()}") # True
# Búsqueda de productos
def buscar_producto(lista_productos, producto_buscado, case_sensitive=False):
"""Buscar un producto en la lista"""
if not case_sensitive:
producto_buscado = producto_buscado.lower()
lista_productos = [p.lower() for p in lista_productos]
for i, producto in enumerate(lista_productos):
if producto == producto_buscado:
return i
return -1
productos_almacen = ["Leche", "Pan", "Huevos", "Queso"]
print(f"Buscar 'leche': {buscar_producto(productos_almacen, 'leche')}") # 0 (encontrado)
print(f"Buscar 'HUEVOS': {buscar_producto(productos_almacen, 'HUEVOS')}") # 2 (encontrado)
print(f"Buscar 'Yogur': {buscar_producto(productos_almacen, 'Yogur')}") # -1 (no encontrado)
Aplicaciones Prácticas Avanzadas
Sistema de Gestión de Inventario
class GestorInventario:
def __init__(self):
self.productos = {}
self.alertas_stock = {}
self.historial_movimientos = []
def agregar_producto(self, nombre, cantidad, precio, stock_minimo):
"""Agregar un producto al inventario"""
self.productos[nombre] = {
"cantidad": cantidad,
"precio": precio,
"stock_minimo": stock_minimo
}
self.alertas_stock[nombre] = False
def actualizar_stock(self, nombre, nueva_cantidad, motivo="Actualización manual"):
"""Actualizar el stock de un producto"""
if nombre not in self.productos:
return False, "Producto no encontrado"
cantidad_anterior = self.productos[nombre]["cantidad"]
# Registrar movimiento
movimiento = {
"producto": nombre,
"cantidad_anterior": cantidad_anterior,
"cantidad_nueva": nueva_cantidad,
"diferencia": nueva_cantidad - cantidad_anterior,
"motivo": motivo
}
self.historial_movimientos.append(movimiento)
# Actualizar cantidad
self.productos[nombre]["cantidad"] = nueva_cantidad
return True, f"Stock actualizado: {cantidad_anterior} → {nueva_cantidad}"
def verificar_alertas(self):
"""Verificar qué productos necesitan reabastecimiento"""
alertas = []
for nombre, info in self.productos.items():
cantidad = info["cantidad"]
minimo = info["stock_minimo"]
# Verificar diferentes niveles de alerta
if cantidad == 0:
nivel = "AGOTADO"
urgencia = "🚨"
elif cantidad < minimo:
nivel = "STOCK BAJO"
urgencia = "⚠️"
elif cantidad <= minimo * 1.2: # 20% por encima del mínimo
nivel = "PRECAUCIÓN"
urgencia = "⚡"
else:
continue
alertas.append({
"producto": nombre,
"cantidad": cantidad,
"minimo": minimo,
"nivel": nivel,
"urgencia": urgencia
})
return alertas
def generar_reporte_stock(self):
"""Generar reporte completo del stock"""
print("=" * 60)
print("REPORTE DE INVENTARIO")
print("=" * 60)
for nombre, info in self.productos.items():
cantidad = info["cantidad"]
precio = info["precio"]
minimo = info["stock_minimo"]
valor_total = cantidad * precio
# Determinar estado
if cantidad == 0:
estado = "🚨 AGOTADO"
elif cantidad < minimo:
estado = "⚠️ BAJO"
elif cantidad <= minimo * 1.2:
estado = "⚡ PRECAUCIÓN"
else:
estado = "✅ OK"
print(f"{nombre:20} | {cantidad:3d} u. | ${precio:6.2f} | ${valor_total:8.2f} | {estado}")
# Mostrar alertas
alertas = self.verificar_alertas()
if alertas:
print("\n" + "=" * 40)
print("ALERTAS DE STOCK")
print("=" * 40)
for alerta in alertas:
print(f"{alerta['urgencia']} {alerta['producto']}: {alerta['cantidad']} u. "
f"(mín: {alerta['minimo']}) - {alerta['nivel']}")
# Ejemplo de uso del sistema
gestor = GestorInventario()
# Agregar productos
productos_iniciales = [
("Leche", 45, 3.50, 20),
("Pan", 12, 2.25, 30),
("Huevos", 8, 4.80, 25),
("Queso", 25, 8.90, 15),
("Yogur", 0, 2.75, 10)
]
for nombre, cantidad, precio, minimo in productos_iniciales:
gestor.agregar_producto(nombre, cantidad, precio, minimo)
# Simular algunas ventas
gestor.actualizar_stock("Leche", 38, "Venta")
gestor.actualizar_stock("Pan", 5, "Venta")
gestor.actualizar_stock("Huevos", 3, "Venta")
# Generar reporte
gestor.generar_reporte_stock()
Sistema de Clasificación de Clientes
class ClasificadorClientes:
def __init__(self):
self.criterios = {
"vip": {"compras_min": 50, "valor_min": 5000, "antiguedad_min": 12},
"premium": {"compras_min": 20, "valor_min": 2000, "antiguedad_min": 6},
"regular": {"compras_min": 5, "valor_min": 500, "antiguedad_min": 1},
"nuevo": {"compras_min": 0, "valor_min": 0, "antiguedad_min": 0}
}
def clasificar_cliente(self, num_compras, valor_total, meses_antiguedad):
"""Clasificar cliente basado en sus métricas"""
# Verificar VIP (todos los criterios deben cumplirse)
vip = self.criterios["vip"]
if (num_compras >= vip["compras_min"] and
valor_total >= vip["valor_min"] and
meses_antiguedad >= vip["antiguedad_min"]):
return "VIP", "🌟"
# Verificar Premium
premium = self.criterios["premium"]
if (num_compras >= premium["compras_min"] and
valor_total >= premium["valor_min"] and
meses_antiguedad >= premium["antiguedad_min"]):
return "Premium", "💎"
# Verificar Regular
regular = self.criterios["regular"]
if (num_compras >= regular["compras_min"] and
valor_total >= regular["valor_min"] and
meses_antiguedad >= regular["antiguedad_min"]):
return "Regular", "👤"
# Por defecto, Nuevo
return "Nuevo", "🆕"
def calcular_descuento(self, categoria):
"""Calcular descuento basado en la categoría del cliente"""
descuentos = {
"VIP": 15,
"Premium": 10,
"Regular": 5,
"Nuevo": 0
}
return descuentos.get(categoria, 0)
# Ejemplo de clasificación
clasificador = ClasificadorClientes()
clientes_datos = [
("Ana García", 65, 7500, 18),
("Carlos López", 25, 2800, 8),
("María Rodríguez", 8, 650, 3),
("Roberto Silva", 2, 150, 1),
("Elena Martínez", 45, 4200, 10)
]
print("=== CLASIFICACIÓN DE CLIENTES ===")
for nombre, compras, valor, antiguedad in clientes_datos:
categoria, emoji = clasificador.clasificar_cliente(compras, valor, antiguedad)
descuento = clasificador.calcular_descuento(categoria)
print(f"{nombre:20} | {compras:2d} compras | ${valor:6.0f} | {antiguedad:2d} meses")
print(f"{'':20} | {emoji} {categoria:8} | Descuento: {descuento}%")
print("-" * 60)
Trucos y Consejos Profesionales
Comparaciones Encadenadas
# Python permite encadenar comparaciones de forma elegante
edad = 25
salario = 35000
# En lugar de: edad >= 18 and edad <= 65 and salario >= 30000
if 18 <= edad <= 65 and salario >= 30000:
print("Candidato elegible para el puesto")
# Verificar rangos de valores
temperatura = 22
if 18 <= temperatura <= 25:
print("Temperatura confortable")
# Múltiples comparaciones
precio = 150
if 100 <= precio <= 200:
print("Precio en rango medio")
Comparaciones Seguras con None
def comparar_seguro(valor1, valor2):
"""Comparar valores manejando casos especiales"""
# Manejar None
if valor1 is None and valor2 is None:
return True
if valor1 is None or valor2 is None:
return False
# Comparación normal
return valor1 == valor2
# Ejemplos
print(comparar_seguro(None, None)) # True
print(comparar_seguro(None, 5)) # False
print(comparar_seguro(5, 5)) # True
Tabla de Referencia Rápida
| Operador | Significado | Ejemplo | Resultado |
|---|---|---|---|
== | Igual a | 5 == 5 | True |
!= | No igual a | 5 != 3 | True |
< | Menor que | 3 < 5 | True |
<= | Menor o igual que | 5 <= 5 | True |
> | Mayor que | 7 > 3 | True |
>= | Mayor o igual que | 5 >= 5 | True |
Errores Comunes y Cómo Evitarlos
❌ Error: Confundir asignación (=) con comparación (==)
# ❌ INCORRECTO
precio = 100
if precio = 50: # Error de sintaxis
print("Precio es 50")
# ✅ CORRECTO
precio = 100
if precio == 50: # Comparación
print("Precio es 50")
❌ Error: Comparar flotantes directamente
# ❌ PROBLEMÁTICO
precio1 = 0.1 + 0.2
precio2 = 0.3
if precio1 == precio2: # Puede fallar por precisión
print("Precios iguales")
# ✅ CORRECTO
def flotantes_iguales(a, b, tolerancia=1e-9):
return abs(a - b) < tolerancia
if flotantes_iguales(precio1, precio2):
print("Precios iguales")
Los operadores de comparación son la base para tomar decisiones inteligentes en tus programas. ¡Combínalos con operadores lógicos para crear condiciones poderosas y flexibles!