Aprende Python desde cero | Aprende Python desde el comienzo.....!!!!!

# Esta línea es un comentario en Python, tiene el objetivo de explicar un bloque de código o sentencia, 
# En este ejemplo se imprime un texto por pantalla utilizando la sentencia Print
print("Hola Mundo, este es el inicio de la programación con Python")

# Asignación de variables de diferente tipo
nombre_servidor = "Servidor_Alpha"
puerto_conexion = 8080

# Desplegando la información usando print
print("Conectando a:", nombre_servidor, "en el puerto:", puerto_conexion)

# Ideación Conceptual de un validador:
# 1. Recibir un token de acceso
# 2. Verificar si está vacío
# 3. Notificar el estado

token = "XYZ123"
print("Verificando token de infraestructura...")

# Ejemplo práctico de Entrada y Salida de Datos
print("--- SISTEMA DE REGISTRO ACADÉMICO ---")

# Entrada: Capturando datos del alumno
nombre_estudiante = input("Ingrese el nombre del estudiante: ")

# Salida: Respuesta procesada devuelta por pantalla
print("¡Registro exitoso! Bienvenido a la plataforma:", nombre_estudiante)

# --- ANÁLISIS COMPARTIDO DE INDENTACIÓN ---
def verificar_sistema_produccion(servidor_online, almacenamiento_disponible):
    # Nivel 1: Inicio de la función
    print("[INFO] Iniciando chequeo de salud del cluster...")
    
    if servidor_online:
        # Nivel 2: Bloque interno del condicional IF
        print("[OK] Comunicación establecida con el host principal.")
        
        if almacenamiento_disponible > 80:
            # Nivel 3: Bloque anidado profundamente
            print("[ALERTA] Almacenamiento crítico. Capacidad superior al 80%.")
            AlertaEspacioInmediata = True
        else:
            # Nivel 3 alternativo
            print("[OK] Niveles de almacenamiento dentro del umbral seguro.")
            AlertaEspacioInmediata = False
            
        # Regreso al Nivel 2
        print("[INFO] Fase 1 del diagnóstico completada con éxito.")
    
    # Regreso al Nivel 1
    print("[INFO] Diagnóstico finalizado. Retornando logs.")
    return "Proceso_Exitoso"

# Un IndentationError rompería el intérprete antes de ejecutarse el software

# --- MOTOR DE EVALUACIÓN FINANCIERA EN ALTA ESCALA (FLUJO LINEAL) ---
print("--- INICIANDO ANÁLISIS DE RIESGO DE TRANSACCIÓN ---")

# Variables de Entrada de la Simulación
monto_transaccion = 25000
pais_origen = "CL"
es_usuario_verificado = True

# Regla Crítica 1: Bloqueo inmediato por Cumplimiento Normativo de Fraude Internacional
if monto_transaccion >= 50000 and not es_usuario_verificado:
    print("[CRÍTICO] Transacción sospechosa bloqueada. Alto monto sin verificación.")
    cod_respuesta = "RECHAZADA_RIESGO_PLD"
    tasa_comision = 0.0
    
# Regla 2: Cliente Corporativo VIP - Alta Prioridad y Transacción Segura
elif es_usuario_verificado and monto_transaccion >= 20000:
    print("[PROCESAMIENTO VIP] Canal prioritario activado. Ruta de baja latencia bancaria.")
    cod_respuesta = "APROBADA_CANAL_VIP"
    tasa_comision = monto_transaccion * 0.015  # 1.5% Comisión Corporativa
    
# Regla 3: Transacciones Locales Estándar de Rango Medio
elif pais_origen == "CL" and monto_transaccion > 1000:
    print("[PROCESAMIENTO NACIONAL] Enrutando a través de la Cámara de Compensación Local.")
    cod_respuesta = "APROBADA_NACIONAL"
    tasa_comision = monto_transaccion * 0.029  # 2.9% Comisión Estándar
    
# Regla 4: Transacciones Internacionales Pequeñas o Remesas Globales
elif pais_origen != "CL" and monto_transaccion <= 5000:
    print("[PROCESAMIENTO CROSS-BORDER] Enrutando a Swift Interbancario Internacional.")
    cod_respuesta = "APROBADA_INTERNACIONAL_REMESAS"
    tasa_comision = (monto_transaccion * 0.05) + 0.50  # 5% + Costo Fijo Fx
    
# Regla por Defecto (Fallback Safety): Si no cumple ningún criterio anterior
else:
    print("[PROCESAMIENTO MICRO-PAYMENT] Aplicando tarifa plana y validación básica de fondos.")
    cod_respuesta = "APROBADA_MINIMA"
    tasa_comision = 0.10  # Tarifa única fija de 10 centavos
    
# Impresión de Salida de Resultados de Negocio
print(f"[RESULTADO] Código de operación final obtenido: {cod_respuesta}")
print(f"[RESULTADO] Comisión descontada por pasarela: ${tasa_comision:.2f}")

# --- ENTORNO REFORZADO DE INGESTIÓN DE TELEMETRÍA (FLUJO LINEAL) ---
print("[NÚCLEO] Iniciando procesamiento de paquete de sensores remotos...")
conexion_base_datos_abierta = True
print("[SISTEMA] Conexión activa con el repositorio analítico.")

# Simulación de Entrada de Datos mediante un Diccionario Fijo (Caso con Error de Hardware)
json_crudo = {"sensor_id": "SENSOR_CRÍTICO_02", "voltaje": "15.0", "atenuacion": "0.0"}

try:
    # Intento de extracción de parámetros críticos de la carga útil
    sensor_id = json_crudo["sensor_id"]
    lectura_voltaje = float(json_crudo["voltaje"])
    factor_atenuacion = float(json_crudo["atenuacion"])
    
    print(f"[PROCESANDO] Telemetría del dispositivo: {sensor_id}")
    
    # Operación Matemática Inestable susceptible a un ZeroDivisionError
    indice_eficiencia = lectura_voltaje / factor_atenuacion
    print(f"[ÉXITO] Índice de eficiencia de la celda calculado: {indice_eficiencia:.4f}")
    
except KeyError as error_llave:
    print(f"[ERROR DE DATOS] Atributo obligatorio ausente en la carga útil JSON: {error_llave}")
    print("[MITIGACIÓN] Asignando identificador temporal e indexando a cola de depuración.")
    indice_eficiencia = -1.0
    
except ZeroDivisionError:
    print("[ERROR DE HARDWARE] Factor de atenuación en 0 detectado. División matemática imposible.")
    print("[MITIGACIÓN] Sobreescribiendo cálculo a constante de seguridad de disipación térmica.")
    indice_eficiencia = 999.9
    
except ValueError as error_tipo:
    print(f"[ERROR DE PARSEO] Error crítico en la conversión de tipos primitivos: {error_tipo}")
    print("[MITIGACIÓN] El sensor envió letras en lugar de números. Abortando cálculo.")
    indice_eficiencia = None
    
except Exception as error_general:
    print(f"[ERROR DESCONOCIDO] Evento catastrófico no tipificado: {error_general}")
    indice_eficiencia = 0.0
    
finally:
    # Este bloque se ejecuta SIEMPRE, garantizando la integridad de la infraestructura
    print("[MANTENIMIENTO OBLIGATORIO] Liberando canales de memoria RAM ocupados...")
    conexion_base_datos_abierta = False
    print("[SISTEMA] Conexión cerrada de forma segura. Infraestructura protegida.")
    
print(f"[FINALizado] Índice final registrado en el sistema: {indice_eficiencia}")

# --- EJEMPLO 1: EL CONTADOR ESTÁNDAR ---
print('--- Inicio del Contador ---')
contador = 1  # Inicialización de la variable de control

while contador <= 10:  # Condición de parada
    print(f'Iteración actual: {contador}')
    
    # Es crítico modificar la variable de control
    # Si olvidamos esta línea, el bucle será infinito
    contador = contador + 1 

print('Bucle finalizado con éxito.\n')

# --- EJEMPLO 2: CUENTA REGRESIVA CON PASO VARIABLE ---
print('--- Lanzamiento de Cohete ---')
cuenta_regresiva = 10

while cuenta_regresiva > 0:
    print(f'T-Minus {cuenta_regresiva} segundos...')
    cuenta_regresiva -= 1  # Forma corta de restar 1

print('¡Despegue! \n')

# --- EJEMPLO 3: ACUMULADOR DENTRO DE WHILE ---
print('--- Suma de Números Consecutivos ---')
limite = 5
numero_actual = 1
suma_total = 0  # Esta variable acumula los valores

while numero_actual <= limite:
    print(f'Sumando {numero_actual} a la suma total ({suma_total})')
    suma_total += numero_actual
    numero_actual += 1

print(f'La suma total de los números del 1 al {limite} es: {suma_total}')

# --- EJEMPLO 1: CONTROL CON BANDERA BOOLEANA ---
sistema_operativo_corriendo = True
ciclos_de_mantenimiento = 0

while sistema_operativo_corriendo:
    ciclos_de_mantenimiento += 1
    print(f'[INFO] Ejecutando análisis de rutina... Ciclo: {ciclos_de_mantenimiento}')
    
    # Simulamos que en el ciclo 4 el sistema decide apagarse
    if ciclos_de_mantenimiento == 4:
        print('[ALERTA] Se detectó solicitud de apagado seguro.')
        sistema_operativo_corriendo = False # Cambiamos el estado de la bandera

print('Sistema apagado limpiamente.\n')

# --- EJEMPLO 2: VALIDACIÓN DE ENTRADAS DE USUARIO ---
# Un caso de uso diario: obligar al usuario a ingresar lo que pedimos
entrada_valida = False

while not entrada_valida:
    edad_texto = input('Por favor, introduce tu edad (debe ser un número): ')
    
    # .isdigit() verifica si el texto contiene solo números
    if edad_texto.isdigit():
        edad = int(edad_texto)
        if edad >= 0 and edad <= 120:
            entrada_valida = True  # Rompemos el ciclo validando la bandera
            print(f'Edad registrada exitosamente: {edad}')
        else:
            print('Error: La edad debe estar entre 0 y 120 años.')
    else:
        print('Error: Eso no parece un número válido.')

# --- EJEMPLO 1: RECORRIDO BÁSICO DE LISTA ---
nombres = ['Ana', 'Carlos', 'Diana', 'Eduardo', 'Fernanda']
print('--- Lista de Invitados ---')
for nombre in nombres:
    # La variable 'nombre' toma el valor de cada elemento en cada vuelta
    print(f'Bienvenido/a a la fiesta, {nombre}!')
print('')

# --- EJEMPLO 2: OPERACIONES MATEMÁTICAS EN LISTAS ---
precios_usd = [10.0, 25.5, 4.99, 99.90, 15.0]
tasa_cambio = 920.0  # Conversión simulada de moneda
precios_locales = []

print('--- Procesando Conversión de Precios ---')
for precio in precios_usd:
    precio_convertido = precio * tasa_cambio
    precios_locales.append(precio_convertido)
    print(f'USD {precio} -> Local ${precio_convertido:,.2f}')
print(f'Lista final procesada: {precios_locales}\n')

# --- EJEMPLO 3: FILTRADO DE DATOS DENTRO DE UN FOR ---
calificaciones = [85, 42, 90, 60, 55, 78, 100, 33]
aprobados = 0
reprobados = 0

print('--- Auditoría de Calificaciones ---')
for nota in calificaciones:
    if nota >= 60:
        print(f'Nota {nota}: APROBADO')
        aprobados += 1
    else:
        print(f'Nota {nota}: REPROBADO')
        reprobados += 1

print(f'\nResumen: {aprobados} estudiantes aprobaron y {reprobados} reprobaron.')

# --- EJEMPLO 1: RANGE CON UN SOLO PARÁMETRO (STOP) ---
# Nota: Comienza por defecto en 0 y es exclusivo (no incluye el número final)
print('--- Rango Simple (0 al 4) ---')
for i in range(5):
    print(f'Valor de i: {i}')
print('')

# --- EJEMPLO 2: RANGE CON START Y STOP ---
print('--- Rango con Inicio y Fin (5 al 10) ---')
for x in range(5, 11):
    print(f'Valor de x: {x}')
print('')

# --- EJEMPLO 3: RANGE CON STEP (PASO / SALTO) ---
print('--- Números Pares del 2 al 20 ---')
# El tercer parámetro indica que irá de 2 en 2
for par in range(2, 21, 2):
    print(f'{par} es un número par.')
print('')

# --- EJEMPLO 4: RANGE INVERTIDO (HACIA ATRÁS) ---
print('--- Conteo Regresivo con Range ---')
# Para ir hacia atrás, el paso (step) debe ser negativo
for reversa in range(10, 0, -1):
    print(f'Contador en reversa: {reversa}')
print('¡Fuego! \n')

# --- EJEMPLO 5: COMBINAR RANGE CON EL LARGO DE UNA LISTA ---
print('--- Modificación por Índice ---')
productos = ['Laptop', 'Mouse', 'Teclado']
stock = [10, 50, 22]

# len(productos) nos da 3, por lo que range(3) genera: 0, 1, 2
for indice in range(len(productos)):
    print(f'Producto en posición {indice}: {productos[indice]} | Stock disponible: {stock[indice]} unidades.')

# --- EJEMPLO 1: CALCULADORA BÁSICA INTERACTIVA ---
saldo_cuenta = 1000.0

while True:
    print('\n=== CAJERO AUTOMÁTICO SIMULADO ===')
    print('1. Ver saldo disponible')
    print('2. Depositar dinero')
    print('3. Retirar dinero')
    print('4. Salir del sistema')
    
    opcion = input('Selecciona una opción (1-4): ')
    
    if opcion == '1':
        print(f'Tu saldo actual es de: ${saldo_cuenta:.2f}')
    
    elif opcion == '2':
        monto_deposito = input('Monto a depositar: ')
        if monto_deposito.replace('.', '', 1).isdigit():
            saldo_cuenta += float(monto_deposito)
            print(f'Depósito exitoso. Nuevo saldo: ${saldo_cuenta:.2f}')
        else:
            print('Monto inválido.')
            
    elif opcion == '3':
        monto_retiro = input('Monto a retirar: ')
        if monto_retiro.replace('.', '', 1).isdigit():
            monto_f = float(monto_retiro)
            if monto_f <= saldo_cuenta:
                saldo_cuenta -= monto_f
                print(f'Retiro exitoso. Retiraste: ${monto_f:.2f}')
            else:
                print('Fondos insuficientes.')
        else:
            print('Monto inválido.')
            
    elif opcion == '4':
        print('Gracias por usar nuestro servicio financiero virtual. ¡Hasta luego!')
        break  # Rompe el bucle 'While True' inmediatamente finalizando el menú
        
    else:
        print('Opción inválida. Intenta nuevamente seleccionando del 1 al 4.')

print('El flujo del programa continuó aquí afuera del While True.')

# --- EJEMPLO 1: USO DE CONTINUE PARA EVITAR ERRORES O FILTRAR ---
print('--- Filtro de Números Impares (Solo imprimiremos pares) ---')
for numero in range(1, 11):
    if numero % 2 != 0:
        # Si es impar, 'continue' ignora el resto del código abajo
        # y pasa inmediatamente al siguiente número de la secuencia
        continue 
    print(f'Número par encontrado: {numero}')
print('')

# --- EJEMPLO 2: USO DE BREAK EN BÚSQUEDA DE DATOS ---
print('--- Escáner de Seguridad de Archivos ---')
archivos_servidor = ['foto.png', 'documento.pdf', 'virus.exe', 'musica.mp3', 'tabla.xlsx']

for archivo in archivos_servidor:
    print(f'Analizando archivo: {archivo}')
    if archivo == 'virus.exe':
        print('[PELIGRO] ¡Amenaza detectada! Deteniendo escaneo del servidor de inmediato...')
        break # Detiene por completo el bucle 'for', los archivos siguientes no se analizan
    print(f'Archivo {archivo} limpio.')

print('Proceso de escaneo finalizado.')

# --- EJEMPLO 1: MATRIZ DE COORDENADAS (X, Y) ---
print('--- Generando Grilla de Coordenadas 3x2 ---')
# Bucle Externo (filas / eje X)
for x in range(1, 4):
    # Bucle Interno (columnas / eje Y)
    for y in range(1, 3):
        print(f'Punto en el espacio -> (X: {x}, Y: {y})')
print('')

# --- EJEMPLO 2: TABLAS DE MULTIPLICAR COMPLETA ---
print('--- Generador de Tablas del 1 al 3 ---')
for tabla in range(1, 4):
    print(f'\n** Tabla del {tabla} **')
    for multiplicador in range(1, 11):
        resultado = tabla * multiplicador
        print(f'{tabla} x {multiplicador} = {resultado}')
print('\nFin del generador de tablas.')

# --- POR QUÉ EXISTE: COMPARATIVA DE ARQUITECTURA ---

# Forma ineficiente (Sin listas): Caos de variables aisladas
auto1 = 'Toyota Yaris'
auto2 = 'Hyundai Accent'
auto3 = 'Suzuki Swift'
# Operar esto requiere escribir código repetitivo para cada variable.

# Forma eficiente (Con listas de Python):
inventario_autos = ['Toyota Yaris', 'Hyundai Accent', 'Suzuki Swift']

# Demostración de por qué es importante: Procesamiento automatizado
print('--- Desplegando Inventario de Autos desde una Estructura Única ---')
for posicion, auto in enumerate(inventario_autos):
    print(f'Índice o Casillero [{posicion}] -> Modelo: {auto}')

print(f'\nTotal de elementos indexados en memoria: {len(inventario_autos)}')
print('Resolución: Todas las variables aisladas ahora viven en una estructura limpia, ordenada y escalable.')

# --- ENTIDAD: ALUMNOS (Gestión de Matrículas) ---
alumnos = ['Ana Silva', 'Carlos Pérez', 'María Vial']
print(f'Listar (Inicial): {alumnos}')

# Agregar (Create)
alumnos.append('Diego Soto')
print(f'Agregar (.append): {alumnos}')

# Actualizar (Update)
alumnos[1] = 'Carlos Pérez-Cotapos'  # Modificamos la posición 1
print(f'Actualizar ([índice]): {alumnos}')

# Eliminar (Delete)
alumnos.remove('María Vial')
print(f'Eliminar (.remove): {alumnos}')

print('\n' + '='*40 + '\n')

# --- ENTIDAD: AUTOS (Gestión de Stock / Concesionario) ---
autos = ['Toyota Yaris', 'Hyundai Accent', 'Suzuki Swift']
print(f'Listar Autos: {autos}')

# Agregar nuevo vehículo al inventario
autos.append('Mazda 3')
print(f'Nuevo Stock: {autos}')

# Actualizar vehículo vendido por su modelo nuevo por índice
autos[0] = 'Toyota Yaris Cross'
print(f'Inventario Actualizado: {autos}')

# Eliminar vehículo despachado por completo
autos.pop(2)  # Remueve el elemento en la posición 2 (Suzuki Swift)
print(f'Stock tras Venta (.pop): {autos}')

# --- ENTIDAD: PRECIO DE LA BENCINA (Valores Enteros en CLP) ---
precios_bencina = [1250, 1310, 1190, 1420, 1280]
print(f'Historial de Precios Base: {precios_bencina}')

# 1. Encontrar el precio más alto (Máximo)
precio_maximo = max(precios_bencina)
print(f'Precio Máximo detectado: ${precio_maximo}')

# 2. Encontrar el precio más bajo (Mínimo)
precio_minimo = min(precios_bencina)
print(f'Precio Mínimo detectado: ${precio_minimo}')

# 3. Calcular el promedio de la bencina (Suma / Cantidad)
suma_total = sum(precios_bencina)
cantidad_registros = len(precios_bencina)
promedio = int(suma_total / cantidad_registros)  # Forzado a entero según requerimiento
print(f'Promedio del mercado de combustibles: ${promedio}')

# 4. Ordenar el histórico de menor a mayor
precios_bencina.sort()
print(f'Historial Ordenado Ascendente (.sort): {precios_bencina}')

# 5. Invertir el orden (Mayor a menor)
precios_bencina.reverse()
print(f'Historial Ordenado Descendente (.reverse): {precios_bencina}')

# Simulando creación física interna de archivos para el entorno sandbox
with open('alumnos.txt', 'w') as txt_file:
    txt_file.write('Ana Silva\nCarlos Perez\nDiego Soto\n')

with open('bencina.csv', 'w') as csv_file:
    csv_file.write('dia,precio\nLunes,1250\nMartes,1310\nMiercoles,1190\n')

# --- 1. LECTURA DE TXT LINEA POR LINEA CON FOR Y LISTAS ---
print('--- Procesando alumnos.txt ---')
lista_alumnos = []
with open('alumnos.txt', 'r') as archivo_txt:
    for linea in archivo_txt:
        # strip() elimina los saltos de línea '\n'
        alumno_limpio = linea.strip()
        lista_alumnos.append(alumno_limpio)

print(f'Lista RAM finalizada desde TXT: {lista_alumnos}\n')

# --- 2. LECTURA DE CSV CON FILTROS E HISTOGRAMA ---
print('--- Procesando bencina.csv ---')
import csv
historial_precios = []
with open('bencina.csv', mode='r') as archivo_csv:
    lector = csv.reader(archivo_csv)
    header = next(lector) # Saltamos los títulos de las columnas
    
    for fila in lector:
        dia = fila[0]
        precio_entero = int(fila[1]) # Conversión explícita a entero
        historial_precios.append(precio_entero)
        print(f'Cargado -> Dia: {dia} | Valor extraído: ${precio_entero}')

print(f'Mapeo final de bencina guardado en lista: {historial_precios}')

# Definición de subprocesos reutilizables
def calcular_promedio_combustible(lista_precios):
    """Calcula el precio promedio asegurando retorno entero"""
    if len(lista_precios) == 0:
        return 0
    return int(sum(lista_precios) / len(lista_precios))

def buscar_vehiculo_inventario(lista_autos, auto_buscado):
    """Evalúa la existencia de un elemento devolviendo un booleano"""
    if auto_buscado in lista_autos:
        return f'{auto_buscado} está disponible en sala de ventas.'
    else:
        return f'Lo sentimos, {auto_buscado} no registra stock.'

# --- EJECUCIÓN UNITARIA DE NUESTRAS FUNCIONES ---
stock_autos = ['Toyota Yaris', 'Hyundai Accent', 'Mazda 3']
precios_semana = [1200, 1340, 1290, 1150]

# Invocar funciones pasando parámetros posicionales
resultado_busqueda = buscar_vehiculo_inventario(stock_autos, 'Mazda 3')
promedio_bencina = calcular_promedio_combustible(precios_semana)

print('--- Ejecución Modular del Sistema ---')
print(resultado_busqueda)
print(f'Promedio procesado por la función: ${promedio_bencina}')

# ==============================================================================
# 1. FUNCIONES DE VALIDACIÓN (Especializadas para la Opción 4)
# ==============================================================================

def validar_codigo(codigo, juegos):
    """
    Valida las restricciones del código del videojuego.
    - No debe estar vacío ni contener solo espacios.
    - No debe existir previamente en el diccionario de juegos (case-insensitive).
    Retorna True si es válido, False si no.
    """
    # .strip() elimina espacios al inicio y al final. Si queda vacío, no es válido.
    if not codigo or codigo.strip() == "":
        return False
    
    # Convertimos a mayúsculas para asegurar que 'g001' y 'G001' se traten igual
    if codigo.upper() in juegos:
        return False # Ya existe, por ende no es válido para añadir
        
    return True


def validar_texto(texto):
    """Valida que una cadena de texto no esté vacía ni llena de espacios."""
    if not texto or texto.strip() == "":
        return False
    return True


def validar_horas(horas):
    """Valida que las horas estimadas sean un número entero mayor que cero."""
    if horas > 0:
        return True
    return False


# ==============================================================================
# 2. FUNCIONES OPERATIVAS DEL SISTEMA
# ==============================================================================

def leer_opcion():
    """
    Muestra la captura de la opción del menú.
    Usa 'try-except' para atrapar errores si el usuario ingresa letras en vez de números.
    Retorna el entero si es válido, o -1 si hubo un error o está fuera de rango.
    """
    try:
        opcion = int(input("Ingrese opción: "))
        # Validamos que esté dentro del rango de opciones del menú (1 al 6)
        if 1 <= opcion <= 6:
            return opcion
        else:
            return -1 # Opción numérica pero fuera de rango
    except ValueError:
        # Si el usuario ingresa por ejemplo 'hola', int() fallará y saltará aquí
        return -1 


def jugadores_por_plataforma(plataforma_buscar, juegos, metricas):
    """
    OPCIÓN 1: Busca juegos de una plataforma (ej. 'PC') y suma sus jugadores activos.
    - No retorna nada, muestra el resultado directamente en pantalla.
    - Es 'case-insensitive' (no distingue mayúsculas/minúsculas).
    """
    total_jugadores = 0
    
    # Usamos un ciclo FOR porque el tamaño del diccionario es conocido de antemano.
    # Recorremos el diccionario 'juegos' para filtrar por plataforma.
    for cod_juego, datos in juegos.items():
        plataforma_juego = datos[1] # El índice 1 corresponde a la plataforma
        
        # Comparamos ambas cadenas en minúsculas (.lower()) para que coincidan
        if plataforma_juego.lower() == plataforma_buscar.lower():
            # Si el código existe en el diccionario de métricas, extraemos los jugadores
            if cod_juego in metricas:
                # El índice 1 en métricas corresponde a 'jugadores_activos'
                total_jugadores += metricas[cod_juego][1]
                
    print(f"El total de jugadores activos en la plataforma es: {total_jugadores}")


def busqueda_por_precio(p_min, p_max, juegos, metricas):
    """
    OPCIÓN 2: Filtra juegos por rango de precio y que tengan jugadores activos (> 0).
    - Construye una lista de strings con formato 'Titulo-Genero--Código'.
    - Muestra los resultados ordenados alfabéticamente.
    """
    resultados = []
    
    # Usamos FOR para recorrer el diccionario operativo 'metricas'
    for cod_juego, datos_m in metricas.items():
        precio = datos_m[0]     # Índice 0: precio_usd
        jugadores = datos_m[1]  # Índice 1: jugadores_activos
        
        # Condición: El precio debe estar en el rango Y deben quedar jugadores disponibles
        if p_min <= precio <= p_max and jugadores > 0:
            # Buscamos los datos descriptivos en el otro diccionario usando la misma clave
            if cod_juego in juegos:
                titulo = juegos[cod_juego][0]
                genero = juegos[cod_juego][2]
                # Formateamos el texto según el estándar pedido
                formato_string = f"{titulo}-{genero}--{cod_juego}"
                resultados.append(formato_string)
                
    # Evaluamos si la lista quedó vacía
    if len(resultados) == 0:
        print("No hay videojuegos en ese rango de precios.")
    else:
        # .sort() ordena la lista alfabéticamente de forma automática
        resultados.sort()
        print(f"Los videojuegos encontrados son: {resultados}")


def buscar_codigo(codigo, diccionario):
    """
    Función auxiliar de búsqueda (Reutilizada por Opción 3, 4 y 5).
    Retorna True si la clave existe en el diccionario (en mayúsculas), False si no.
    """
    return codigo.upper() in diccionario


def actualizar_precio(codigo, nuevo_precio, metricas):
    """
    OPCIÓN 3: Busca un juego y actualiza su precio.
    - Reutiliza 'buscar_codigo' para verificar existencia.
    - Retorna True si se logró actualizar, False si el código no existía.
    """
    if buscar_codigo(codigo, metricas):
        # Buscamos la lista de valores y modificamos el índice 0 (precio)
        metricas[codigo.upper()][0] = nuevo_precio
        return True
    return False


def agregar_videojuego(codigo, titulo, plataforma, genero, horas, precio, jugadores, juegos, metricas):
    """
    OPCIÓN 4: Agrega de manera efectiva el registro en ambos diccionarios.
    - Solo llega aquí si el programa principal ya validó todos los campos individuales.
    - Retorna True si se agregó, False si el código se repitió a último momento.
    """
    cod_upper = codigo.upper()
    if cod_upper in juegos:
        return False # Doble seguridad: el código ya existe
        
    # Agregamos los datos respetando el orden de las listas en cada diccionario
    juegos[cod_upper] = [titulo, plataforma, genero, horas]
    metricas[cod_upper] = [precio, jugadores]
    return True


def eliminar_videojuego(codigo, juegos, metricas):
    """
    OPCIÓN 5: Elimina el registro por completo de las dos estructuras.
    - Usa 'buscar_codigo' internamente.
    - Retorna un booleano indicando el éxito de la operación.
    """
    if buscar_codigo(codigo, juegos):
        cod_upper = codigo.upper()
        # .pop() elimina la clave y su valor del diccionario
        juegos.pop(cod_upper)
        metricas.pop(cod_upper)
        return True
    return False


# ==============================================================================
# 3. PROGRAMA PRINCIPAL (Lógica de control y decisiones)
# ==============================================================================
def main():
    # Inicialización de los dos diccionarios relacionados (Base de datos local)
    juegos = {
        'G001': ['The Witcher 3', 'PC', 'RPG', 100],
        'G002': ['Halo Infinite', 'Xbox', 'Shooter', 20],
        'G003': ['Elden Ring', 'PC', 'RPG', 80],
        'G004': ['Uncharted 4', 'PS5', 'Aventura', 15],
    }
    
    metricas = {
        'G001': [40, 1500],
        'G002': [60, 0],     # Caso especial: 0 jugadores activos
        'G003': [60, 3400],
        'G004': [20, 500],
    }

    # Usamos un ciclo WHILE porque la condición de detención depende de la
    # decisión del usuario (cuando presione 6), no sabemos cuántas vueltas dará.
    ejecutando = True
    while ejecutando:
        print("\n========== MENÚ PRINCIPAL ==========")
        print("1. Jugadores activos por plataforma")
        print("2. Búsqueda de videojuegos por rango de precio")
        print("3. Actualizar precio de videojuego")
        print("4. Agregar videojuego")
        print("5. Eliminar videojuego")
        print("6. Salir")
        print("=====================================")
        
        # Invocamos la función encargada de leer y validar la entrada del menú
        opcion = leer_opcion()
        
        # ----------------------------------------------------------------------
        # OPCIÓN 1: Jugadores por Plataforma
        # ----------------------------------------------------------------------
        if opcion == 1:
            plat = input("Ingrese plataforma a consultar: ")
            # Pasamos las estructuras locales como argumentos requeridos
            jugadores_por_plataforma(plat, juegos, metricas)
            
        # ----------------------------------------------------------------------
        # OPCIÓN 2: Rango de Precios (Validación de enteros mediante Try-Except en Main)
        # ----------------------------------------------------------------------
        elif opcion == 2:
            # Ciclo infinito de captura que solo se rompe (break) si los datos son enteros válidos
            while True:
                try:
                    p_min = int(input("Ingrese precio mínimo USD: "))
                    p_max = int(input("Ingrese precio máximo USD: "))
                    
                    # Validaciones de lógica comercial básica
                    if p_min >= 0 and p_max >= p_min:
                        break # Entradas correctas, salimos del ciclo de captura
                    else:
                        print("El precio mínimo debe ser menor o igual al máximo.")
                except ValueError:
                    # Este bloque atrapa el error si el usuario digita texto
                    print("Debe ingresar valores enteros")
            
            # Una vez garantizados los enteros, llamamos a la función lógica
            busqueda_por_precio(p_min, p_max, juegos, metricas)
            
        # ----------------------------------------------------------------------
        # OPCIÓN 3: Actualizar Precio (Ciclo de repetición interno)
        # ----------------------------------------------------------------------
        elif opcion == 3:
            procesar_otro = 's'
            # El sub-proceso se repite mientras el usuario responda 's' o 'S'
            while procesar_otro.lower() == 's':
                cod = input("Ingrese código del videojuego: ")
                try:
                    n_precio = int(input("Ingrese nuevo precio USD: "))
                    if n_precio > 0:
                        # Se toma la decisión de qué imprimir basándose estrictamente en el retorno True/False
                        if actualizar_precio(cod, n_precio, metricas):
                            print("Precio actualizado")
                        else:
                            print("El código no existe")
                    else:
                        print("El precio debe ser un entero positivo.")
                except ValueError:
                    print("Precio inválido (debe ser un número entero).")
                
                procesar_otro = input("¿Desea actualizar otro precio (s/n)?: ")
                
        # ----------------------------------------------------------------------
        # OPCIÓN 4: Agregar Registro (Validaciones independientes)
        # ----------------------------------------------------------------------
        elif opcion == 4:
            cod = input("Ingrese código del videojuego: ")
            tit = input("Ingrese título: ")
            plat = input("Ingrese plataforma: ")
            gen = input("Ingrese género: ")
            
            try:
                horas = int(input("Ingrese horas estimadas: "))
                precio = int(input("Ingrese precio USD: "))
                jugadores = int(input("Ingrese jugadores activos: "))
            except ValueError:
                print("Los valores numéricos deben ser enteros válidos.")
                continue # El 'continue' interrumpe esta vuelta y vuelve a mostrar el menú principal
                
            # Evaluamos de forma independiente cada campo llamando a sus respectivas funciones
            if (validar_codigo(cod, juegos) and 
                validar_texto(tit) and 
                validar_texto(plat) and 
                validar_texto(gen) and 
                validar_horas(horas) and 
                precio >= 0 and jugadores >= 0):
                
                # Si pasa los filtros del main, se intenta agregar en los diccionarios
                if agregar_videojuego(cod, tit, plat, gen, horas, precio, jugadores, juegos, metricas):
                    print("Videojuego agregado")
                else:
                    print("El código ya existe")
            else:
                # Si una sola función de validación retornó False, se gatilla este error general
                print("Error: Uno o más datos no cumplen con las validaciones requeridas.")
                
        # ----------------------------------------------------------------------
        # OPCIÓN 5: Eliminar Registro
        # ----------------------------------------------------------------------
        elif opcion == 5:
            cod = input("Ingrese código del videojuego a eliminar: ")
            # El main decide el mensaje interactivo según el booleano devuelto
            if eliminar_videojuego(cod, juegos, metricas):
                print("Videojuego eliminado")
            else:
                print("El código no existe")
                
        # ----------------------------------------------------------------------
        # OPCIÓN 6: Salir del sistema
        # ----------------------------------------------------------------------
        elif opcion == 6:
            print("Programa finalizado.")
            ejecutando = False # Cambia la condición del ciclo principal rompiendo el bucle while
            
        # ----------------------------------------------------------------------
        # CONTROL DE OPCIÓN INVÁLIDA
        # ----------------------------------------------------------------------
        else:
            print("Debe seleccionar una opción válida")


# Punto de entrada estándar de Python para iniciar el programa
if __name__ == "__main__":
    main()