Aprende Python desde cero o el comienzo o del inicio

# Características clave de Python: Legible y potente
print("Hola Mundo, este es el inicio de la ingeniería 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}')