{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true,
   "name": "Intro_Ing_Industrial_Datos_para_decidir.ipynb"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2a117d69dc38"
   },
   "source": [
    "# ⚙️ Del dato a la decisión\n",
    "## Analítica aplicada al mercado inmobiliario de Bogotá\n",
    "\n",
    "**Introducción a la Ingeniería Industrial** · Universidad Jorge Tadeo Lozano · Prof. Elkin Rodríguez\n",
    "\n",
    "---\n",
    "\n",
    "### 📌 Por qué esta clase existe\n",
    "\n",
    "El ingeniero industrial diseña, mide y mejora procesos con recursos limitados. Hoy **todo proceso deja un rastro de datos**, y ese rastro es la materia prima con la que se decide.\n",
    "\n",
    "Un ingeniero industrial que no domina datos:\n",
    "\n",
    "- Mide lo que es fácil de medir, no lo que importa.\n",
    "- Acepta indicadores que nadie puede reconstruir.\n",
    "- Optimiza sobre información sucia y empeora el proceso creyendo que lo mejora.\n",
    "\n",
    "Uno que sí los domina **convierte información en decisiones defendibles**. Eso es lo que vamos a practicar hoy, de punta a punta.\n",
    "\n",
    "---\n",
    "\n",
    "### 🏭 El caso\n",
    "\n",
    "> Una constructora quiere **entrar al mercado de vivienda en Bogotá**. Nos contratan para responder una pregunta concreta:\n",
    ">\n",
    "> **¿Qué producto conviene construir, a qué precio, y bajo qué condiciones el proyecto deja de ser rentable?**\n",
    ">\n",
    "> No hay estudio de mercado. Hay datos públicos. Y hay dos horas.\n",
    "\n",
    "---\n",
    "\n",
    "### 🔄 La cadena de valor del dato\n",
    "\n",
    "Todo lo que haremos hoy recorre esta cadena, que es el esqueleto de cualquier proyecto de analítica en la industria:\n",
    "\n",
    "```\n",
    "Dato crudo  →  Dato limpio  →  Información  →  Conocimiento  →  DECISIÓN\n",
    " (extracción)   (calidad y      (indicadores    (análisis del   (simulación y\n",
    "                 limpieza)        y KPIs)          mercado)       sensibilidad)\n",
    "```\n",
    "\n",
    "**Cada flecha destruye valor si el paso anterior estaba mal.** Por eso el bloque de calidad no es un trámite: es el cimiento de todo lo demás.\n",
    "\n",
    "---\n",
    "\n",
    "### 🗺️ Ruta de la sesión (2 horas)\n",
    "\n",
    "| Bloque | Qué hacemos | Concepto de ingeniería |\n",
    "|---|---|---|\n",
    "| **1-2** | Extraer datos reales de la web | El dato como materia prima |\n",
    "| **3** | Auditar la calidad de la base | GIGO · las 5 dimensiones · regla 1-10-100 |\n",
    "| **4** | Limpiar y transformar | Trazabilidad · nulo honesto vs. cero falso |\n",
    "| **5-6** | Construir indicadores y tratar atípicos | Feature engineering · control estadístico |\n",
    "| **7** | Exportar a **Excel y Power BI** | Tabla plana · diccionario de datos · metadata |\n",
    "| **8** | Visualizar con propósito | Elegir el gráfico correcto · correlación ≠ causalidad |\n",
    "| **9** | Simular la decisión | Punto de equilibrio · análisis de sensibilidad |\n",
    "\n",
    "---\n",
    "\n",
    "### 🧭 Cómo ejecutar este notebook (léelo antes de tocar nada)\n",
    "\n",
    "1. Ve a **Archivo → Guardar una copia en Drive**. Trabaja sobre **tu copia**.\n",
    "2. Ejecuta las celdas **en orden**, de arriba hacia abajo. Cada una depende de la anterior.\n",
    "3. Para ejecutar: clic en la celda y **`Shift + Enter`**, o el botón ▶️.\n",
    "4. Si una celda falla, **no sigas**: lee el mensaje. Está diseñado para decirte qué pasó.\n",
    "5. El bloque 1 (instalación) tarda **2 a 4 minutos**. Es normal y solo ocurre una vez.\n",
    "\n",
    "> ⚠️ Si Colab dice *\"Se reinició el entorno de ejecución\"*, ejecuta de nuevo desde el bloque 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b83b50f02bae"
   },
   "source": [
    "## ✋ Antes de la primera línea de código: una advertencia importante\n",
    "\n",
    "Al terminar esta sesión **no vas a saber programar en Python**. Y está bien: ese no es el objetivo.\n",
    "\n",
    "Lo que sí te vas a llevar es algo más difícil de conseguir y más difícil de reemplazar:\n",
    "\n",
    "> **El criterio para hacerle a los datos las preguntas correctas y para desconfiar de las respuestas fáciles.**\n",
    "\n",
    "| Lo que hace la máquina | Lo que haces tú |\n",
    "|---|---|\n",
    "| Extraer 400 registros en 3 minutos | Decidir **qué medir** y por qué |\n",
    "| Calcular el promedio | Notar que el promedio **está mintiendo** |\n",
    "| Convertir textos en números | Decidir que un vacío honesto vale más que un cero inventado |\n",
    "| Dibujar el gráfico | Elegir **cuál** gráfico responde la pregunta |\n",
    "| Calcular la utilidad del proyecto | Preguntar **qué pasa si el supuesto falla** |\n",
    "\n",
    "La columna de la izquierda hoy la hace un computador, cada año mejor y más barato. **La columna de la derecha es tu profesión.**\n",
    "\n",
    "---\n",
    "\n",
    "### Entonces, ¿para qué aprender Python?\n",
    "\n",
    "Porque en ingeniería industrial **quien no entiende la herramienta no puede auditarla**, y auditar es la mitad del trabajo.\n",
    "\n",
    "- Un dashboard con un indicador mal construido es **más peligroso** que no tener dashboard.\n",
    "- Responder una pregunta del negocio en 20 minutos en vez de 3 días **cambia tu lugar** en la organización.\n",
    "- Cuando sabes qué es posible, dejas de pedir reportes y empiezas a pedir respuestas.\n",
    "\n",
    "Python es una herramienta: no reemplaza el criterio, lo **amplifica**. Igual que un torno no reemplaza al ingeniero de manufactura, pero un ingeniero que no sabe qué puede hacer un torno diseña piezas imposibles.\n",
    "\n",
    "> 💡 **Mi invitación concreta:** después de esta clase, dedícale 30 minutos diarios durante un mes. No a \"aprender Python\", sino a **resolver un problema tuyo** con Python. Al final del notebook encontrarás una ruta de 8 semanas.\n",
    "\n",
    "---\n",
    "\n",
    "**Ahora sí. Manos a la obra.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "14e39a468dd2"
   },
   "source": [
    "---\n",
    "# 🧱 BLOQUE 1 — Preparación del entorno\n",
    "\n",
    "**Qué vamos a hacer:** instalar las herramientas que necesita el robot para navegar por internet.\n",
    "\n",
    "**Analogía industrial:** esto es el *alistamiento de máquina* (setup). En una planta, antes de producir una sola unidad hay que montar el troquel, calibrar y verificar. Aquí es igual: sin alistamiento, no hay producción de datos.\n",
    "\n",
    "**Qué instalamos y para qué:**\n",
    "\n",
    "| Herramienta | Para qué sirve |\n",
    "|---|---|\n",
    "| **Google Chrome** | El navegador que el robot va a manejar |\n",
    "| **Selenium** | El \"conductor\": le da órdenes al navegador (abre, baja, lee) |\n",
    "| **Pandas** | La hoja de cálculo del programador: guarda y transforma tablas |\n",
    "| **Matplotlib / Seaborn** | Las que dibujan los gráficos |\n",
    "| **OpenPyXL** | La que permite escribir archivos de Excel |\n",
    "\n",
    "> ⏱️ Esta celda tarda entre 2 y 4 minutos. Ejecútala y aprovecha para leer el bloque 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "f04c7ba89585"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 1.1 — ALISTAMIENTO DEL ENTORNO (blindada)\n",
    "# Instala todo lo necesario y deja un \"semáforo\" con el estado del entorno.\n",
    "# Si algo falla, el notebook NO se cae: te dice qué falló y sigue funcionando.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "import sys, subprocess, importlib, warnings, os\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "ESTADO_ENTORNO = {\"chrome\": False, \"selenium\": False, \"datos\": False, \"graficos\": False, \"excel\": False}\n",
    "\n",
    "def _ejecutar(comando):\n",
    "    \"\"\"Ejecuta un comando de sistema y devuelve True si terminó bien.\"\"\"\n",
    "    try:\n",
    "        r = subprocess.run(comando, shell=True, capture_output=True, text=True, timeout=600)\n",
    "        return r.returncode == 0\n",
    "    except Exception:\n",
    "        return False\n",
    "\n",
    "def _instalar(paquetes):\n",
    "    \"\"\"Instala paquetes de Python de forma silenciosa.\"\"\"\n",
    "    return _ejecutar(f\"{sys.executable} -m pip install -q {paquetes}\")\n",
    "\n",
    "def _disponible(modulo):\n",
    "    \"\"\"Verifica si una librería se puede importar.\"\"\"\n",
    "    try:\n",
    "        importlib.import_module(modulo)\n",
    "        return True\n",
    "    except Exception:\n",
    "        return False\n",
    "\n",
    "print(\"🔧 Alistando el entorno... (esto puede tardar 2-4 minutos)\\n\")\n",
    "\n",
    "# ── 1. Librerías de datos y gráficos ─────────────────────────────────────────\n",
    "for modulo, paquete, clave in [(\"pandas\", \"pandas\", \"datos\"),\n",
    "                               (\"numpy\", \"numpy\", \"datos\"),\n",
    "                               (\"matplotlib\", \"matplotlib\", \"graficos\"),\n",
    "                               (\"seaborn\", \"seaborn\", \"graficos\"),\n",
    "                               (\"openpyxl\", \"openpyxl\", \"excel\")]:\n",
    "    if not _disponible(modulo):\n",
    "        _instalar(paquete)\n",
    "    ESTADO_ENTORNO[clave] = _disponible(modulo) and ESTADO_ENTORNO.get(clave, True)\n",
    "\n",
    "ESTADO_ENTORNO[\"datos\"] = _disponible(\"pandas\") and _disponible(\"numpy\")\n",
    "ESTADO_ENTORNO[\"graficos\"] = _disponible(\"matplotlib\") and _disponible(\"seaborn\")\n",
    "ESTADO_ENTORNO[\"excel\"] = _disponible(\"openpyxl\")\n",
    "\n",
    "# ── 2. Selenium (el conductor del navegador) ─────────────────────────────────\n",
    "if not _disponible(\"selenium\"):\n",
    "    _instalar(\"selenium\")\n",
    "ESTADO_ENTORNO[\"selenium\"] = _disponible(\"selenium\")\n",
    "\n",
    "# ── 3. Google Chrome (el navegador que manejará el robot) ────────────────────\n",
    "def _hay_chrome():\n",
    "    return any(_ejecutar(f\"which {b}\") for b in\n",
    "               [\"google-chrome\", \"google-chrome-stable\", \"chromium\", \"chromium-browser\"])\n",
    "\n",
    "if _hay_chrome():\n",
    "    ESTADO_ENTORNO[\"chrome\"] = True\n",
    "else:\n",
    "    ok = _ejecutar(\"wget -q -O /tmp/chrome.deb \"\n",
    "                   \"https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb\")\n",
    "    if ok:\n",
    "        _ejecutar(\"apt-get install -y -qq /tmp/chrome.deb > /dev/null 2>&1\")\n",
    "    if not _hay_chrome():\n",
    "        _ejecutar(\"apt-get update -qq > /dev/null 2>&1 && apt-get install -y -qq chromium-browser > /dev/null 2>&1\")\n",
    "    ESTADO_ENTORNO[\"chrome\"] = _hay_chrome()\n",
    "\n",
    "# ── 4. Semáforo final ────────────────────────────────────────────────────────\n",
    "print(\"\\n\" + \"═\" * 62)\n",
    "print(\"  SEMÁFORO DEL ENTORNO\")\n",
    "print(\"═\" * 62)\n",
    "etiquetas = {\"chrome\": \"Navegador Chrome\", \"selenium\": \"Selenium (robot)\",\n",
    "             \"datos\": \"Pandas / NumPy\", \"graficos\": \"Matplotlib / Seaborn\",\n",
    "             \"excel\": \"Exportación a Excel\"}\n",
    "for clave, ok in ESTADO_ENTORNO.items():\n",
    "    print(f\"  {'✅' if ok else '⚠️ '} {etiquetas[clave]:<28} {'listo' if ok else 'NO disponible'}\")\n",
    "print(\"═\" * 62)\n",
    "\n",
    "PUEDE_SCRAPEAR = ESTADO_ENTORNO[\"chrome\"] and ESTADO_ENTORNO[\"selenium\"]\n",
    "\n",
    "if not ESTADO_ENTORNO[\"datos\"]:\n",
    "    print(\"\\n❌ Sin Pandas no podemos continuar. Menú: Entorno de ejecución → Reiniciar y ejecutar todo.\")\n",
    "elif not PUEDE_SCRAPEAR:\n",
    "    print(\"\\n⚠️  El robot navegador no está disponible en esta sesión.\")\n",
    "    print(\"   👉 Tranquilo: el notebook usará automáticamente la BASE DE RESPALDO y la clase continúa igual.\")\n",
    "else:\n",
    "    print(\"\\n🚀 Entorno listo. Puedes continuar al Bloque 2.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8ad16827036c"
   },
   "source": [
    "---\n",
    "# 🕸️ BLOQUE 2 — Extracción: conseguir la materia prima\n",
    "\n",
    "## ¿Qué es *web scraping*?\n",
    "\n",
    "Es enseñarle a un programa a **leer una página web como la leería una persona**, pero mil veces más rápido y sin cansarse.\n",
    "\n",
    "Nuestro robot va a:\n",
    "1. Abrir el navegador (sin ventana visible, \"modo fantasma\").\n",
    "2. Ir al portal inmobiliario.\n",
    "3. Bajar la página para que carguen los avisos.\n",
    "4. Leer cada tarjeta: título, precio, ubicación, habitaciones, baños, área **y el enlace del aviso**.\n",
    "5. Guardarlo todo en una tabla.\n",
    "\n",
    "## ⚙️ El dato es materia prima\n",
    "\n",
    "En una planta nadie produce con materia prima de origen desconocido y sin control de calidad de entrada. **Con los datos pasa exactamente lo mismo**, y sin embargo la mayoría de las empresas lo hace todos los días.\n",
    "\n",
    "Antes de meter un dato al proceso, pregúntate siempre estas cuatro cosas — es la **ficha técnica del lote**:\n",
    "\n",
    "| Pregunta | En nuestro caso |\n",
    "|---|---|\n",
    "| **¿De dónde viene?** | Avisos públicos de un portal inmobiliario |\n",
    "| **¿Qué tan fresco es?** | Se extrae hoy, en vivo |\n",
    "| **¿Qué sesgo tiene?** | Son precios de **oferta**, no de **cierre**. Nadie publica lo que realmente le pagaron |\n",
    "| **¿Qué NO está?** | Ventas directas, proyectos sin publicar, estrato, antigüedad, tiempo de venta |\n",
    "\n",
    "> 🧠 **Esa última fila es la más importante del bloque.** El error más costoso en analítica no es calcular mal: es **olvidar qué no está en los datos** y decidir como si el dataset fuera el mundo entero.\n",
    ">\n",
    "> En ingeniería lo llamamos **sesgo de muestreo**, y es la razón por la que un estudio bien calculado puede llevar a una decisión desastrosa.\n",
    "\n",
    "## 🔁 Automatizar vs. hacerlo a mano\n",
    "\n",
    "Copiar 400 avisos a mano tomaría unas 6 horas, con errores de transcripción y sin posibilidad de repetirlo mañana. El robot lo hace en 3 minutos, **sin errores de digitación** y **de forma reproducible**.\n",
    "\n",
    "Esas tres palabras —rápido, exacto, **reproducible**— son el corazón de la automatización industrial aplicada a la información. La tercera es la que casi nadie valora: un proceso que no se puede repetir igual, no se puede mejorar.\n",
    "\n",
    "---\n",
    "\n",
    "### ⚖️ Nota ética y legal (no la saltes)\n",
    "\n",
    "- ✅ Extraemos **información pública**, con fines **académicos**, en volumen bajo y con pausas.\n",
    "- ❌ **No** extraemos datos personales, contactos, ni nada detrás de un login.\n",
    "- 📄 En un proyecto real: revisa el `robots.txt` del sitio y sus términos de uso antes de extraer.\n",
    "\n",
    "> **Regla profesional:** si te da pena explicarle a la empresa dueña del sitio lo que estás haciendo, no lo hagas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "a12126424e66"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 2.1 — PANEL DE CONTROL\n",
    "# Todo lo que se puede cambiar está AQUÍ. No hay que tocar el resto del código.\n",
    "# Este es el \"tablero de la máquina\": parámetros arriba, lógica abajo.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "CONFIG = {\n",
    "    # ── Qué extraer ──────────────────────────────────────────────────────────\n",
    "    \"url_base\":        \"https://www.fincaraiz.com.co/venta/bogota/bogota-dc\",\n",
    "    \"num_paginas\":     4,       # ↑ más páginas = más datos, pero más tiempo (~25 s por página)\n",
    "\n",
    "    # ── Cuánto esperar (subir si tu conexión es lenta) ────────────────────────\n",
    "    \"espera_carga\":    5,       # segundos de espera tras abrir cada página\n",
    "    \"espera_scroll\":   1.5,     # segundos entre desplazamientos\n",
    "    \"timeout\":         20,      # segundos máximos esperando un elemento\n",
    "    \"reintentos\":      2,       # veces que se reintenta una página que falló\n",
    "\n",
    "    # ── Blindaje ─────────────────────────────────────────────────────────────\n",
    "    \"minimo_aceptable\": 20,     # si extraemos menos filas que esto, activamos el respaldo\n",
    "    \"usar_respaldo_si_falla\": True,\n",
    "    \"semilla\":         42,      # para que la base de respaldo sea siempre igual\n",
    "    \"filas_respaldo\":  420,\n",
    "}\n",
    "\n",
    "# ── Selectores: las \"direcciones\" de cada dato dentro del HTML ────────────────\n",
    "# Se listan VARIAS alternativas por campo. Si el portal cambia su diseño,\n",
    "# el robot prueba la siguiente en vez de romperse. Esto es blindaje real.\n",
    "SELECTORES = {\n",
    "    \"tarjeta\":      [\"div.listingCard\", \"div.lc-cardResult\", \"article.listingCard\", \"[data-id='listing-card']\"],\n",
    "    \"titulo\":       [\"h2.lc-title\", \"h2.card-title\", \"h2\", \".lc-title\"],\n",
    "    \"precio\":       [\"p.main-price\", \"span.price\", \".lc-price\", \"[class*='price']\"],\n",
    "    \"ubicacion\":    [\"strong.lc-location\", \"span.lc-location\", \"[class*='location']\"],\n",
    "    \"atributos\":    [\"div.lc-typologyTag strong\", \".lc-typologyTag\", \"[class*='typology'] strong\"],\n",
    "    \"descripcion\":  [\"p.lc-description\", \".lc-description\"],\n",
    "    # El enlace al aviso: es lo que le demuestra al estudiante que el dato es REAL\n",
    "    \"enlace\":       [\"a.lc-cardLink\", \"a[href*='/inmueble']\", \"a[href*='/venta/']\",\n",
    "                     \"h2.lc-title a\", \"a[href]\"],\n",
    "}\n",
    "\n",
    "print(\"🎛️  Panel de control cargado.\")\n",
    "print(f\"   • Objetivo: {CONFIG['num_paginas']} páginas de {CONFIG['url_base']}\")\n",
    "print(f\"   • Tiempo estimado de extracción: ~{CONFIG['num_paginas'] * 25 // 60} min {CONFIG['num_paginas'] * 25 % 60} s\")\n",
    "print(f\"   • Mínimo aceptable de registros: {CONFIG['minimo_aceptable']} (si no, entra el respaldo)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "23b3a2aa604f"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 2.2 — EL MOTOR DEL ROBOT (funciones blindadas)\n",
    "# Aquí NO se ejecuta nada todavía: solo definimos las herramientas.\n",
    "# Cada función tiene un único trabajo. Eso se llama \"modularidad\" y es lo que\n",
    "# permite arreglar una pieza sin desarmar la máquina completa.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "import time, random, os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from urllib.parse import urljoin\n",
    "\n",
    "# Blindaje: si alguien ejecuta esta celda sin haber corrido el Bloque 1\n",
    "if \"PUEDE_SCRAPEAR\" not in globals():\n",
    "    print(\"⚠️  No se detectó el Bloque 1. Ejecuta primero la celda 1.1.\")\n",
    "    ESTADO_ENTORNO = {\"chrome\": False, \"selenium\": False, \"datos\": True, \"graficos\": True, \"excel\": True}\n",
    "    PUEDE_SCRAPEAR = False\n",
    "\n",
    "COLUMNAS = [\"Título\", \"Precio\", \"Ubicación\", \"Habitaciones\", \"Baños\", \"Área (m2)\",\n",
    "            \"URL\", \"Página\", \"Origen\"]\n",
    "DOMINIO = \"https://www.fincaraiz.com.co\"\n",
    "\n",
    "\n",
    "def crear_driver():\n",
    "    \"\"\"Enciende el navegador en modo invisible. Devuelve None si no es posible.\"\"\"\n",
    "    try:\n",
    "        from selenium import webdriver\n",
    "        from selenium.webdriver.chrome.options import Options\n",
    "        op = Options()\n",
    "        op.add_argument(\"--headless=new\")\n",
    "        op.add_argument(\"--no-sandbox\")\n",
    "        op.add_argument(\"--disable-dev-shm-usage\")\n",
    "        op.add_argument(\"--disable-gpu\")\n",
    "        op.add_argument(\"--window-size=1920,1080\")\n",
    "        op.add_argument(\"--blink-settings=imagesEnabled=false\")   # sin imágenes = más rápido\n",
    "        op.add_argument(\"user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) \"\n",
    "                        \"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36\")\n",
    "        return webdriver.Chrome(options=op)\n",
    "    except Exception as e:\n",
    "        print(f\"   ⚠️  No se pudo iniciar el navegador: {type(e).__name__}\")\n",
    "        return None\n",
    "\n",
    "\n",
    "def texto_seguro(elemento, lista_selectores):\n",
    "    \"\"\"\n",
    "    Intenta leer un texto probando varios selectores.\n",
    "    Si ninguno funciona devuelve cadena vacía, PERO NUNCA rompe el programa.\n",
    "    Esta función es el corazón del blindaje: un aviso mal formado no puede\n",
    "    tumbar la extracción de los otros 399.\n",
    "    \"\"\"\n",
    "    from selenium.webdriver.common.by import By\n",
    "    for sel in lista_selectores:\n",
    "        try:\n",
    "            t = elemento.find_element(By.CSS_SELECTOR, sel).text.strip()\n",
    "            if t:\n",
    "                return t\n",
    "        except Exception:\n",
    "            continue\n",
    "    return \"\"\n",
    "\n",
    "\n",
    "def leer_enlace(tarjeta):\n",
    "    \"\"\"\n",
    "    Extrae el enlace del aviso y lo convierte en URL absoluta.\n",
    "    Este campo es la trazabilidad del dato: permite verificar cada fila en la fuente.\n",
    "    \"\"\"\n",
    "    from selenium.webdriver.common.by import By\n",
    "    for sel in SELECTORES[\"enlace\"]:\n",
    "        try:\n",
    "            href = tarjeta.find_element(By.CSS_SELECTOR, sel).get_attribute(\"href\")\n",
    "            if href and \"javascript\" not in href.lower():\n",
    "                return urljoin(DOMINIO, href.strip())\n",
    "        except Exception:\n",
    "            continue\n",
    "    try:\n",
    "        if tarjeta.tag_name.lower() == \"a\":\n",
    "            href = tarjeta.get_attribute(\"href\")\n",
    "            if href:\n",
    "                return urljoin(DOMINIO, href.strip())\n",
    "    except Exception:\n",
    "        pass\n",
    "    return \"\"\n",
    "\n",
    "\n",
    "def leer_atributos(tarjeta):\n",
    "    \"\"\"Separa habitaciones, baños y área del bloque de etiquetas.\"\"\"\n",
    "    from selenium.webdriver.common.by import By\n",
    "    hab = ban = area = \"\"\n",
    "    for sel in SELECTORES[\"atributos\"]:\n",
    "        try:\n",
    "            etiquetas = tarjeta.find_elements(By.CSS_SELECTOR, sel)\n",
    "            if not etiquetas:\n",
    "                continue\n",
    "            for et in etiquetas:\n",
    "                txt = (et.text or \"\").strip()\n",
    "                low = txt.lower()\n",
    "                if \"hab\" in low and not hab:\n",
    "                    hab = txt\n",
    "                elif (\"baño\" in low or \"bano\" in low) and not ban:\n",
    "                    ban = txt\n",
    "                elif (\"m²\" in low or \"m2\" in low) and not area:\n",
    "                    area = txt\n",
    "            if hab or ban or area:\n",
    "                break\n",
    "        except Exception:\n",
    "            continue\n",
    "    return hab, ban, area\n",
    "\n",
    "\n",
    "def buscar_tarjetas(driver):\n",
    "    \"\"\"Busca los avisos probando cada selector alternativo hasta encontrar alguno.\"\"\"\n",
    "    from selenium.webdriver.common.by import By\n",
    "    for sel in SELECTORES[\"tarjeta\"]:\n",
    "        try:\n",
    "            encontradas = driver.find_elements(By.CSS_SELECTOR, sel)\n",
    "            if encontradas:\n",
    "                return encontradas, sel\n",
    "        except Exception:\n",
    "            continue\n",
    "    return [], None\n",
    "\n",
    "\n",
    "def extraer_pagina(driver, pagina):\n",
    "    \"\"\"Extrae TODOS los avisos de una página. Devuelve una lista de diccionarios.\"\"\"\n",
    "    from selenium.webdriver.support.ui import WebDriverWait\n",
    "    from selenium.webdriver.support import expected_conditions as EC\n",
    "    from selenium.webdriver.common.by import By\n",
    "\n",
    "    url = CONFIG[\"url_base\"] if pagina == 1 else f\"{CONFIG['url_base']}/pagina{pagina}\"\n",
    "    print(f\"   → Página {pagina}: {url}\")\n",
    "    driver.get(url)\n",
    "\n",
    "    # Espera inteligente: sigue apenas aparezca el contenido, sin perder tiempo de más\n",
    "    try:\n",
    "        WebDriverWait(driver, CONFIG[\"timeout\"]).until(\n",
    "            EC.presence_of_element_located((By.CSS_SELECTOR, SELECTORES[\"tarjeta\"][0]))\n",
    "        )\n",
    "    except Exception:\n",
    "        time.sleep(CONFIG[\"espera_carga\"])   # plan B: espera fija\n",
    "\n",
    "    # Scroll progresivo: muchos portales cargan los avisos solo al bajar\n",
    "    for fraccion in (0.3, 0.6, 1.0):\n",
    "        try:\n",
    "            driver.execute_script(f\"window.scrollTo(0, document.body.scrollHeight*{fraccion});\")\n",
    "        except Exception:\n",
    "            pass\n",
    "        time.sleep(CONFIG[\"espera_scroll\"] + random.uniform(0, 0.6))\n",
    "\n",
    "    tarjetas, usado = buscar_tarjetas(driver)\n",
    "    if not tarjetas:\n",
    "        print(\"     ⚠️  No se encontraron avisos con ningún selector conocido.\")\n",
    "        return []\n",
    "    print(f\"     ✓ {len(tarjetas)} avisos detectados (selector: {usado})\")\n",
    "\n",
    "    filas = []\n",
    "    for t in tarjetas:\n",
    "        try:\n",
    "            titulo = texto_seguro(t, SELECTORES[\"titulo\"])\n",
    "            if not titulo:\n",
    "                continue                      # sin título no es un aviso válido\n",
    "            hab, ban, area = leer_atributos(t)\n",
    "            filas.append({\n",
    "                \"Título\":       titulo,\n",
    "                \"Precio\":       texto_seguro(t, SELECTORES[\"precio\"]),\n",
    "                \"Ubicación\":    texto_seguro(t, SELECTORES[\"ubicacion\"]),\n",
    "                \"Habitaciones\": hab,\n",
    "                \"Baños\":        ban,\n",
    "                \"Área (m2)\":    area,\n",
    "                \"URL\":          leer_enlace(t),\n",
    "                \"Página\":       pagina,\n",
    "                \"Origen\":       \"REAL\",\n",
    "            })\n",
    "        except Exception:\n",
    "            continue                          # un aviso roto no detiene la producción\n",
    "    return filas\n",
    "\n",
    "\n",
    "def extraer_mercado():\n",
    "    \"\"\"Orquesta toda la extracción. NUNCA lanza un error hacia afuera.\"\"\"\n",
    "    if not PUEDE_SCRAPEAR:\n",
    "        print(\"⚠️  Robot no disponible en esta sesión.\")\n",
    "        return pd.DataFrame(columns=COLUMNAS)\n",
    "\n",
    "    driver = crear_driver()\n",
    "    if driver is None:\n",
    "        return pd.DataFrame(columns=COLUMNAS)\n",
    "\n",
    "    acumulado = []\n",
    "    try:\n",
    "        for pagina in range(1, CONFIG[\"num_paginas\"] + 1):\n",
    "            for intento in range(CONFIG[\"reintentos\"] + 1):\n",
    "                try:\n",
    "                    filas = extraer_pagina(driver, pagina)\n",
    "                    if filas:\n",
    "                        acumulado.extend(filas)\n",
    "                        print(f\"     Acumulado: {len(acumulado)} registros\")\n",
    "                        break\n",
    "                    if intento < CONFIG[\"reintentos\"]:\n",
    "                        print(f\"     ↻ Reintentando página {pagina}...\")\n",
    "                        time.sleep(3)\n",
    "                except Exception as e:\n",
    "                    print(f\"     ⚠️  Error en página {pagina} (intento {intento+1}): {type(e).__name__}\")\n",
    "                    time.sleep(3)\n",
    "            # Pausa entre páginas: cortesía con el servidor ajeno\n",
    "            time.sleep(random.uniform(1.5, 3.0))\n",
    "    finally:\n",
    "        try:\n",
    "            driver.quit()      # el navegador SIEMPRE se cierra, pase lo que pase\n",
    "        except Exception:\n",
    "            pass\n",
    "\n",
    "    return pd.DataFrame(acumulado, columns=COLUMNAS) if acumulado else pd.DataFrame(columns=COLUMNAS)\n",
    "\n",
    "\n",
    "print(\"🤖 Motor del robot cargado (5 funciones listas).\")\n",
    "print(\"   Nota: aún no se ha extraído nada. Eso pasa en la celda 2.4.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "e3963feb7c9c"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 2.3 — RED DE SEGURIDAD: base de respaldo\n",
    "# Si el portal cambia, bloquea o se cae justo hoy, la clase NO se detiene.\n",
    "# Esta función simula un mercado bogotano realista, CON los mismos defectos\n",
    "# de los datos reales (textos, símbolos, vacíos, duplicados) para que el\n",
    "# ejercicio de limpieza siga teniendo sentido.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def generar_base_respaldo(n=None, semilla=None):\n",
    "    \"\"\"Genera un dataset sintético realista del mercado inmobiliario de Bogotá.\"\"\"\n",
    "    n = n or CONFIG[\"filas_respaldo\"]\n",
    "    rng = np.random.default_rng(semilla if semilla is not None else CONFIG[\"semilla\"])\n",
    "\n",
    "    # Zonas con su valor típico por m² (millones COP) y su peso en la oferta\n",
    "    zonas = [\n",
    "        (\"Chapinero, Bogotá\",     10.5, 0.11), (\"Usaquén, Bogotá\",       11.8, 0.13),\n",
    "        (\"Suba, Bogotá\",           6.2, 0.15), (\"Engativá, Bogotá\",       5.4, 0.10),\n",
    "        (\"Kennedy, Bogotá\",        4.6, 0.11), (\"Fontibón, Bogotá\",       5.1, 0.07),\n",
    "        (\"Teusaquillo, Bogotá\",    7.4, 0.07), (\"Barrios Unidos, Bogotá\", 6.8, 0.06),\n",
    "        (\"Puente Aranda, Bogotá\",  4.9, 0.05), (\"Bosa, Bogotá\",           3.6, 0.06),\n",
    "        (\"Ciudad Bolívar, Bogotá\", 3.1, 0.04), (\"Santa Fe, Bogotá\",       4.2, 0.05),\n",
    "    ]\n",
    "    nombres  = [z[0] for z in zonas]\n",
    "    valores  = np.array([z[1] for z in zonas])\n",
    "    pesos    = np.array([z[2] for z in zonas]); pesos = pesos / pesos.sum()\n",
    "\n",
    "    idx   = rng.choice(len(zonas), size=n, p=pesos)\n",
    "    area  = np.clip(rng.lognormal(mean=4.20, sigma=0.45, size=n), 28, 420).round(1)\n",
    "\n",
    "    # Habitaciones en función del área (con algo de ruido, como en la vida real)\n",
    "    hab = np.where(area < 45, 1, np.where(area < 70, 2, np.where(area < 110, 3, 4)))\n",
    "    hab = np.clip(hab + rng.choice([-1, 0, 0, 0, 1], size=n), 1, 5)\n",
    "    ban = np.clip(np.ceil(hab / 1.6).astype(int) + rng.choice([0, 0, 1], size=n), 1, 4)\n",
    "\n",
    "    # Precio: valor de zona × factor de tamaño × factor de baños × ruido de mercado\n",
    "    v_m2 = (valores[idx]\n",
    "            * (1 + 0.10 * np.log(area / 70))          # los grandes cuestan más por m²\n",
    "            * (1 + 0.05 * (ban - 1))                  # prima por baño adicional\n",
    "            * rng.normal(1.0, 0.13, size=n))\n",
    "    v_m2 = np.clip(v_m2, 2.0, 24.0)\n",
    "    precio = (v_m2 * area * 1_000_000)\n",
    "\n",
    "    # El tipo depende del tamaño (un apartaestudio de 190 m² no existe)\n",
    "    tipos = np.where(area < 42, \"Apartaestudio\",\n",
    "             np.where(area > 130, np.where(rng.random(n) < 0.55, \"Casa\", \"Apartamento\"),\n",
    "                      np.where(rng.random(n) < 0.12, \"Casa\", \"Apartamento\")))\n",
    "\n",
    "    filas = []\n",
    "    for i in range(n):\n",
    "        filas.append({\n",
    "            \"Título\":       f\"{tipos[i]} en venta en {nombres[idx[i]].split(',')[0]}\",\n",
    "            \"Precio\":       f\"$ {int(round(precio[i], -6)):,}\".replace(\",\", \".\"),\n",
    "            \"Ubicación\":    nombres[idx[i]],\n",
    "            \"Habitaciones\": f\"{int(hab[i])} Hab.\",\n",
    "            \"Baños\":        f\"{int(ban[i])} Baños\",\n",
    "            \"Área (m2)\":    f\"{area[i]:.1f} m²\".replace(\".\", \",\"),\n",
    "            \"URL\":          \"\",   # sin enlace: los datos de respaldo NO son reales\n",
    "            \"Página\":       (i // 105) + 1,\n",
    "            \"Origen\":       \"RESPALDO\",\n",
    "        })\n",
    "    df = pd.DataFrame(filas, columns=COLUMNAS)\n",
    "\n",
    "    # \"Suciedad\" intencional: los datos reales nunca llegan limpios\n",
    "    sucios = rng.choice(n, size=max(1, int(n * 0.04)), replace=False)\n",
    "    df.loc[sucios[:len(sucios)//3],  \"Área (m2)\"]    = \"\"      # área faltante\n",
    "    df.loc[sucios[len(sucios)//3:2*len(sucios)//3], \"Baños\"] = \"\"   # baños faltantes\n",
    "    df.loc[sucios[2*len(sucios)//3:], \"Precio\"]      = \"Precio a convenir\"\n",
    "    df = pd.concat([df, df.sample(max(1, int(n * 0.03)), random_state=7)], ignore_index=True)  # duplicados\n",
    "\n",
    "    return df.sample(frac=1, random_state=11).reset_index(drop=True)\n",
    "\n",
    "\n",
    "print(\"🛟 Red de seguridad lista.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "2b331f72b79b"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 2.4 — ▶️ EJECUTAR LA EXTRACCIÓN\n",
    "# Esta es LA celda que produce la base de datos. Todo lo demás depende de ella.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "import time\n",
    "inicio = time.time()\n",
    "\n",
    "print(\"🚀 Iniciando extracción del mercado inmobiliario de Bogotá...\\n\")\n",
    "\n",
    "try:\n",
    "    df_crudo = extraer_mercado()\n",
    "except Exception as e:\n",
    "    print(f\"\\n⚠️  Falla general en la extracción: {type(e).__name__}: {e}\")\n",
    "    df_crudo = pd.DataFrame(columns=COLUMNAS)\n",
    "\n",
    "# ── Decisión automática: ¿los datos alcanzan? ────────────────────────────────\n",
    "suficientes = len(df_crudo) >= CONFIG[\"minimo_aceptable\"]\n",
    "\n",
    "if not suficientes and CONFIG[\"usar_respaldo_si_falla\"]:\n",
    "    print(\"\\n\" + \"─\" * 62)\n",
    "    print(f\"⚠️  Se obtuvieron {len(df_crudo)} registros (mínimo requerido: {CONFIG['minimo_aceptable']}).\")\n",
    "    print(\"🛟 ACTIVANDO BASE DE RESPALDO para que la clase continúe.\")\n",
    "    print(\"   Los datos son SIMULADOS pero estadísticamente realistas.\")\n",
    "    print(\"   ⚠️  No los uses para decidir en el mundo real: sirven para aprender el método.\")\n",
    "    print(\"─\" * 62)\n",
    "    df_crudo = generar_base_respaldo()\n",
    "\n",
    "# ── Higiene mínima: quitar duplicados exactos ────────────────────────────────\n",
    "antes = len(df_crudo)\n",
    "# Si hay URL, ese es el identificador único real del aviso (mejor que el título)\n",
    "if \"URL\" in df_crudo.columns and (df_crudo[\"URL\"].astype(str).str.len() > 10).mean() > 0.5:\n",
    "    df_crudo = df_crudo[~(df_crudo.duplicated(subset=[\"URL\"]) & (df_crudo[\"URL\"].astype(str) != \"\"))]\n",
    "df_crudo = df_crudo.drop_duplicates(subset=[\"Título\", \"Precio\", \"Ubicación\"]).reset_index(drop=True)\n",
    "\n",
    "ORIGEN_DATOS = df_crudo[\"Origen\"].iloc[0] if len(df_crudo) else \"SIN DATOS\"\n",
    "\n",
    "# ── Guardado inmediato: nunca pierdas lo que costó trabajo conseguir ─────────\n",
    "try:\n",
    "    df_crudo.to_csv(\"01_inmuebles_crudo.csv\", index=False, encoding=\"utf-8-sig\")\n",
    "    guardado = \"01_inmuebles_crudo.csv\"\n",
    "except Exception as e:\n",
    "    guardado = f\"(no se pudo guardar: {e})\"\n",
    "\n",
    "print(\"\\n\" + \"═\" * 62)\n",
    "print(\"  RESULTADO DE LA EXTRACCIÓN\")\n",
    "print(\"═\" * 62)\n",
    "print(f\"  Origen de los datos ....... {ORIGEN_DATOS}\")\n",
    "print(f\"  Registros extraídos ....... {antes}\")\n",
    "print(f\"  Duplicados eliminados ..... {antes - len(df_crudo)}\")\n",
    "print(f\"  Registros finales ......... {len(df_crudo)}\")\n",
    "print(f\"  Tiempo total .............. {time.time() - inicio:.1f} s\")\n",
    "print(f\"  Archivo guardado .......... {guardado}\")\n",
    "print(\"═\" * 62)\n",
    "\n",
    "from IPython.display import display\n",
    "if len(df_crudo):\n",
    "    display(df_crudo.head(8))\n",
    "else:\n",
    "    print(\"❌ No hay datos. Revisa el Bloque 1 y vuelve a ejecutar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "89fdb46c3c95"
   },
   "source": [
    "### ✅ Verificación: ¿esto es real o me lo estoy inventando?\n",
    "\n",
    "Antes de analizar un solo número, un profesional hace algo que casi nadie hace: **comprueba la fuente**.\n",
    "\n",
    "Por eso el robot no solo capturó precios: capturó también **el enlace de cada aviso**. La siguiente celda muestra una muestra con links en los que puedes hacer clic ahora mismo y verificar que el inmueble existe, que el precio coincide y que el área es la que dice.\n",
    "\n",
    "> 🔎 **Esto se llama trazabilidad.** Todo dato que uses para decidir debería poder rastrearse hasta su origen. Si no puedes decir de dónde salió una cifra, no puedes defenderla — y si no puedes defenderla, no deberías decidir con ella.\n",
    ">\n",
    "> Hazlo ahora: abre dos o tres enlaces y compáralos con la tabla. Ese gesto de 30 segundos es lo que separa un análisis auditable de una hoja de cálculo bonita."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "4aba0db8d935"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 2.5 — VERIFICACIÓN DE AUTENTICIDAD (enlaces clicables)\n",
    "# Abre 2 o 3 avisos y compáralos con la tabla. Confía, pero verifica.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "con_url = df_crudo[df_crudo[\"URL\"].astype(str).str.startswith(\"http\")] if \"URL\" in df_crudo.columns \\\n",
    "          else df_crudo.head(0)\n",
    "\n",
    "print(\"═\" * 66)\n",
    "print(\"  TRAZABILIDAD DE LA FUENTE\")\n",
    "print(\"═\" * 66)\n",
    "print(f\"  Registros totales ............... {len(df_crudo)}\")\n",
    "print(f\"  Registros con enlace verificable  {len(con_url)} \"\n",
    "      f\"({100*len(con_url)/max(len(df_crudo),1):.0f}%)\")\n",
    "print(\"═\" * 66)\n",
    "\n",
    "if len(con_url):\n",
    "    muestra = con_url.sample(min(8, len(con_url)), random_state=1)[\n",
    "        [\"Título\", \"Precio\", \"Ubicación\", \"Área (m2)\", \"URL\"]].copy()\n",
    "    muestra[\"URL\"] = muestra[\"URL\"].apply(\n",
    "        lambda u: f'<a href=\"{u}\" target=\"_blank\">🔗 Ver aviso</a>')\n",
    "    display(HTML(\n",
    "        \"<p style='font-family:sans-serif'><b>👇 Haz clic y verifica que el inmueble existe:</b></p>\"\n",
    "        + muestra.to_html(escape=False, index=False)))\n",
    "    print(\"\\n  💡 Compara el precio y el área del aviso con lo que dice la tabla.\")\n",
    "    print(\"     Si no coinciden, acabas de encontrar un problema de calidad de datos —\")\n",
    "    print(\"     y encontrarlo AHORA vale mucho más que encontrarlo después de decidir.\")\n",
    "else:\n",
    "    print(\"\\n  ⚠️  No hay enlaces disponibles.\")\n",
    "    print(\"     Esto ocurre cuando se activó la BASE DE RESPALDO: los datos son simulados\")\n",
    "    print(\"     y por eso NO tienen aviso real detrás. Es exactamente lo que debe pasar:\")\n",
    "    print(\"     un dato inventado no puede tener fuente verificable, y el notebook no\")\n",
    "    print(\"     te va a mentir sobre eso.\")\n",
    "    print(\"\\n     👉 Para trabajar con datos reales, vuelve a ejecutar la celda 2.4\")\n",
    "    print(\"        (o revisa el semáforo del Bloque 1).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bec8501eb005"
   },
   "source": [
    "### 🔍 Detente un segundo y mira la tabla de arriba\n",
    "\n",
    "Fíjate en la columna **Precio**: dice `$ 450.000.000`. Eso **no es un número**, es un texto. Python no puede sumarlo, promediarlo ni dividirlo.\n",
    "\n",
    "Lo mismo con `62,5 m²`, con `3 Hab.`, con `2 Baños`.\n",
    "\n",
    "> **Este es el momento donde se cae el 90% de los proyectos de datos en las empresas.**\n",
    "> No por falta de tecnología: por falta de disciplina en la preparación.\n",
    "\n",
    "Y fíjate también: hay celdas **vacías**, hay precios que dicen *\"Precio a convenir\"*, y probablemente hay avisos repetidos.\n",
    "\n",
    "Eso no es un error del ejercicio. **Así llega la data en la vida real.** Siempre."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0354a3d5eef1"
   },
   "source": [
    "---\n",
    "# 🔬 BLOQUE 3 — Auditoría de calidad del dato\n",
    "\n",
    "## ⚙️ Este bloque es el corazón de la clase de Ingeniería Industrial\n",
    "\n",
    "En una planta, antes de meter la materia prima al proceso, se hace **control de calidad de entrada**. Si entra basura, sale basura — y sale cara.\n",
    "\n",
    "En datos existe el mismo principio, y hasta tiene nombre propio:\n",
    "\n",
    "> **GIGO — *Garbage In, Garbage Out*.**\n",
    "> Ningún modelo, ningún dashboard y ninguna inteligencia artificial arregla un dato mal capturado.\n",
    "\n",
    "## Las 5 dimensiones de la calidad del dato\n",
    "\n",
    "| Dimensión | Pregunta que responde | Cómo la medimos aquí |\n",
    "|---|---|---|\n",
    "| **Completitud** | ¿Faltan valores? | % de celdas vacías por columna |\n",
    "| **Unicidad** | ¿Hay registros repetidos? | Conteo de duplicados |\n",
    "| **Validez** | ¿El dato tiene el formato correcto? | ¿\"Precio a convenir\" es un precio? |\n",
    "| **Consistencia** | ¿Los datos se contradicen? | Un apto de 30 m² con 5 habitaciones |\n",
    "| **Exactitud** | ¿Corresponde a la realidad? | Solo se verifica contra una fuente externa |\n",
    "\n",
    "> ⚠️ Ojo con la última: **la exactitud no se puede medir desde adentro del dataset**. Es la dimensión más importante y la única que exige salir a mirar el mundo real. Ese es tu trabajo, no el del computador.\n",
    "\n",
    "## 💰 ¿Por qué esto importa en plata?\n",
    "\n",
    "Un estudio clásico de gestión de calidad (**la regla 1-10-100**) sostiene que:\n",
    "\n",
    "- Prevenir un error de datos cuesta **$1**\n",
    "- Corregirlo después cuesta **$10**\n",
    "- Y las consecuencias de no corregirlo cuestan **$100**\n",
    "\n",
    "Traducido a nuestro caso: si tu base tiene precios mal capturados y decides construir en el segmento equivocado, el error no vale $10. Vale **un proyecto inmobiliario completo**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "9e8a043bf79b"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 3.1 — PERFILADO AUTOMÁTICO DE LA BASE\n",
    "# En la industria esto se llama \"data profiling\". Es lo primero que hace\n",
    "# cualquier analista serio antes de tocar un solo número.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def auditar(df, nombre=\"dataset\"):\n",
    "    \"\"\"Genera un informe de calidad de datos. Funciona con cualquier tabla.\"\"\"\n",
    "    if df is None or len(df) == 0:\n",
    "        print(\"❌ No hay datos que auditar.\")\n",
    "        return None\n",
    "\n",
    "    print(\"═\" * 70)\n",
    "    print(f\"  INFORME DE CALIDAD — {nombre.upper()}\")\n",
    "    print(\"═\" * 70)\n",
    "    print(f\"  Filas: {len(df):,}   |   Columnas: {df.shape[1]}   |   \"\n",
    "          f\"Memoria: {df.memory_usage(deep=True).sum()/1024:.1f} KB\")\n",
    "    print(\"─\" * 70)\n",
    "\n",
    "    informe = pd.DataFrame({\n",
    "        \"Tipo\":            df.dtypes.astype(str),\n",
    "        \"No nulos\":        df.notna().sum(),\n",
    "        \"Vacíos\": [(df[c].isna() | (df[c].astype(str).str.strip() == \"\")).sum() for c in df.columns],\n",
    "        \"Valores únicos\":  df.nunique(dropna=True),\n",
    "    })\n",
    "    informe[\"% Completitud\"] = (100 * (1 - informe[\"Vacíos\"] / len(df))).round(1)\n",
    "    informe[\"Ejemplo\"] = [\n",
    "        str(df[c].dropna().astype(str).replace(\"\", np.nan).dropna().iloc[0])[:34]\n",
    "        if df[c].notna().any() and (df[c].astype(str).str.strip() != \"\").any() else \"—\"\n",
    "        for c in df.columns\n",
    "    ]\n",
    "    display(informe)\n",
    "\n",
    "    dup = df.duplicated().sum()\n",
    "    print(f\"\\n  🔁 Filas 100% duplicadas: {dup}\")\n",
    "\n",
    "    criticas = informe[informe[\"% Completitud\"] < 95]\n",
    "    if len(criticas):\n",
    "        print(\"  ⚠️  Columnas con completitud bajo el 95%:\")\n",
    "        for c, r in criticas.iterrows():\n",
    "            print(f\"      • {c}: {r['% Completitud']}% completo ({r['Vacíos']} vacíos)\")\n",
    "    else:\n",
    "        print(\"  ✅ Todas las columnas superan el 95% de completitud.\")\n",
    "    print(\"═\" * 70)\n",
    "    return informe\n",
    "\n",
    "\n",
    "informe_crudo = auditar(df_crudo, \"Base cruda (recién extraída)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d21057a93efd"
   },
   "source": [
    "### 🗣️ Pausa para discutir (5 minutos)\n",
    "\n",
    "Mira el informe y responde en voz alta:\n",
    "\n",
    "1. **¿Cuál es la columna más débil?** ¿Qué decisiones dejarías de poder tomar si esa columna no existiera?\n",
    "2. Si eliminaras **toda fila incompleta**, ¿cuántos datos perderías? ¿Compensa?\n",
    "3. Un registro sin precio, ¿es un error del sistema o **información en sí misma**?\n",
    "\n",
    "> ⚙️ **La pregunta 2 tiene nombre técnico y no tiene respuesta única.** Eliminar filas incompletas se llama *listwise deletion*: es la opción más simple y la más costosa en información. Las alternativas —imputar con la mediana, modelar el faltante, o reportar el análisis por subconjuntos— tienen ventajas y riesgos distintos.\n",
    ">\n",
    "> Lo que **nunca** es aceptable es borrar sin decirlo. Un análisis serio siempre reporta cuántos registros se descartaron y por qué. Ese párrafo de dos líneas es la diferencia entre un informe auditable y uno que nadie puede verificar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "abf6930b8989"
   },
   "source": [
    "---\n",
    "# 🧼 BLOQUE 4 — Limpieza y transformación\n",
    "\n",
    "## La verdad incómoda de la profesión\n",
    "\n",
    "Encuestas del sector (CrowdFlower, Anaconda y otras) llevan una década repitiendo lo mismo: **los analistas de datos gastan entre el 60% y el 80% de su tiempo limpiando y preparando datos**, y solo el resto analizando.\n",
    "\n",
    "No es un desperdicio. **Es el trabajo.** El análisis es la punta del iceberg.\n",
    "\n",
    "## Qué vamos a hacer, en lenguaje humano\n",
    "\n",
    "| Columna | Cómo llega | Cómo la necesitamos | Qué hacemos |\n",
    "|---|---|---|---|\n",
    "| `Precio` | `\"$ 450.000.000\"` | `450000000` | Borrar todo lo que no sea dígito |\n",
    "| `Área (m2)` | `\"62,5 m²\"` | `62.5` | Quitar el texto, cambiar coma por punto |\n",
    "| `Habitaciones` | `\"3 Hab.\"` | `3` | Extraer el primer número |\n",
    "| `Baños` | `\"2 Baños\"` | `2` | Extraer el primer número |\n",
    "\n",
    "## 🛡️ Dos principios de blindaje que vas a ver en el código\n",
    "\n",
    "**1. Nunca destruyas el original.**\n",
    "Creamos columnas *nuevas* (`Precio_Millones`, `Area_m2`) y conservamos las originales. Si mañana descubrimos que la limpieza estaba mal, podemos volver atrás. En ingeniería esto se llama **trazabilidad**: poder reconstruir cómo se llegó a cada número.\n",
    "\n",
    "**2. Los errores se marcan, no se ocultan.**\n",
    "Cuando un valor no se puede convertir, no ponemos cero (¡un cero es una mentira que sí se puede promediar!). Ponemos **nulo** (`NaN`), que significa honestamente *\"no sé\"*.\n",
    "\n",
    "> 🧠 **Esta distinción vale toda la clase:** un cero falso contamina todos los promedios silenciosamente. Un nulo se ve, se cuenta y se puede reportar. **Prefiere siempre el vacío honesto al número inventado.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "39d5892613df"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 4.1 — FUNCIONES DE LIMPIEZA (blindadas)\n",
    "# Cada función soporta texto, números, vacíos y basura sin romperse.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def a_numero_moneda(serie):\n",
    "    \"\"\"'$ 450.000.000' → 450000000.0   |   'Precio a convenir' → NaN\"\"\"\n",
    "    s = serie.astype(str)\n",
    "    s = s.str.replace(r\"[^\\d]\", \"\", regex=True)     # deja solo dígitos\n",
    "    s = s.replace(\"\", np.nan)\n",
    "    return pd.to_numeric(s, errors=\"coerce\")        # lo que no se pueda convertir → NaN\n",
    "\n",
    "\n",
    "def a_numero_decimal(serie):\n",
    "    \"\"\"'62,5 m²' → 62.5   |   '' → NaN\"\"\"\n",
    "    s = serie.astype(str)\n",
    "    s = s.str.replace(r\"[^\\d,\\.]\", \"\", regex=True)  # deja dígitos, comas y puntos\n",
    "    # Si hay coma y punto, el punto es separador de miles ('1.234,5')\n",
    "    tiene_ambos = s.str.contains(\",\") & s.str.contains(r\"\\.\")\n",
    "    s = s.mask(tiene_ambos, s.str.replace(\".\", \"\", regex=False))\n",
    "    s = s.str.replace(\",\", \".\", regex=False)\n",
    "    s = s.replace(\"\", np.nan)\n",
    "    return pd.to_numeric(s, errors=\"coerce\")\n",
    "\n",
    "\n",
    "def a_entero(serie):\n",
    "    \"\"\"'3 Hab.' → 3   |   '' → NaN\"\"\"\n",
    "    s = serie.astype(str).str.extract(r\"(\\d+)\", expand=False)\n",
    "    return pd.to_numeric(s, errors=\"coerce\")\n",
    "\n",
    "\n",
    "def limpiar_base(df_entrada):\n",
    "    \"\"\"Aplica toda la limpieza y devuelve una copia nueva + un reporte.\"\"\"\n",
    "    df = df_entrada.copy()\n",
    "\n",
    "    # Blindaje: si falta una columna esperada, la creamos vacía en vez de fallar\n",
    "    for col in COLUMNAS:\n",
    "        if col not in df.columns:\n",
    "            df[col] = np.nan\n",
    "            print(f\"   ⚠️  La columna '{col}' no venía en los datos. Se creó vacía.\")\n",
    "\n",
    "    df[\"Precio_COP\"]       = a_numero_moneda(df[\"Precio\"])\n",
    "    df[\"Precio_Millones\"]  = (df[\"Precio_COP\"] / 1_000_000).round(1)\n",
    "    df[\"Area_m2\"]          = a_numero_decimal(df[\"Área (m2)\"])\n",
    "    df[\"Habitaciones_Num\"] = a_entero(df[\"Habitaciones\"])\n",
    "    df[\"Banos_Num\"]        = a_entero(df[\"Baños\"])\n",
    "\n",
    "    # Localidad: primera parte de la ubicación ('Suba, Bogotá' → 'Suba')\n",
    "    df[\"Localidad\"] = (df[\"Ubicación\"].astype(str)\n",
    "                       .str.split(\",\").str[0]\n",
    "                       .str.strip().replace({\"\": np.nan, \"nan\": np.nan}))\n",
    "\n",
    "    # Tipo de inmueble a partir del título\n",
    "    titulo = df[\"Título\"].astype(str).str.lower()\n",
    "    df[\"Tipo\"] = np.select(\n",
    "        [titulo.str.contains(\"apartaestudio\"), titulo.str.contains(\"casa\"),\n",
    "         titulo.str.contains(\"apartamento|apto\"), titulo.str.contains(\"local|oficina|bodega\")],\n",
    "        [\"Apartaestudio\", \"Casa\", \"Apartamento\", \"Comercial\"],\n",
    "        default=\"Otro\")\n",
    "    return df\n",
    "\n",
    "\n",
    "print(\"🧼 Aplicando limpieza...\\n\")\n",
    "df = limpiar_base(df_crudo)\n",
    "\n",
    "# ── Reporte antes / después ──────────────────────────────────────────────────\n",
    "reporte = pd.DataFrame({\n",
    "    \"Campo\":            [\"Precio\", \"Área\", \"Habitaciones\", \"Baños\"],\n",
    "    \"Convertidos\":      [df[\"Precio_Millones\"].notna().sum(), df[\"Area_m2\"].notna().sum(),\n",
    "                         df[\"Habitaciones_Num\"].notna().sum(), df[\"Banos_Num\"].notna().sum()],\n",
    "    \"No convertibles\":  [df[\"Precio_Millones\"].isna().sum(), df[\"Area_m2\"].isna().sum(),\n",
    "                         df[\"Habitaciones_Num\"].isna().sum(), df[\"Banos_Num\"].isna().sum()],\n",
    "})\n",
    "reporte[\"% Éxito\"] = (100 * reporte[\"Convertidos\"] / max(len(df), 1)).round(1)\n",
    "\n",
    "print(\"═\" * 62)\n",
    "print(\"  RESULTADO DE LA CONVERSIÓN TEXTO → NÚMERO\")\n",
    "print(\"═\" * 62)\n",
    "display(reporte)\n",
    "\n",
    "print(\"\\n  Antes y después (primeras filas):\")\n",
    "display(df[[\"Precio\", \"Precio_Millones\", \"Área (m2)\", \"Area_m2\",\n",
    "            \"Habitaciones\", \"Habitaciones_Num\", \"Localidad\", \"Tipo\"]].head(8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6e1f5b9fa2e4"
   },
   "source": [
    "---\n",
    "# 📐 BLOQUE 5 — De dato a indicador: *feature engineering*\n",
    "\n",
    "## El salto que separa a un capturador de datos de un analista\n",
    "\n",
    "Tenemos precio. Tenemos área. Por separado, **ninguno de los dos sirve para comparar**.\n",
    "\n",
    "- Un apartamento de $900 millones, ¿es caro? *No se sabe.*\n",
    "- Uno de 150 m², ¿es grande? *Comparado con qué.*\n",
    "\n",
    "Pero al dividirlos nace algo nuevo:\n",
    "\n",
    "$$\\text{Valor por m}^2 = \\frac{\\text{Precio}}{\\text{Área}}$$\n",
    "\n",
    "Y esa métrica **sí es comparable**.\n",
    "\n",
    "## ⚙️ Esto ya lo conoces de otro nombre\n",
    "\n",
    "Acabas de hacer **ingeniería de características** (*feature engineering*): crear una variable nueva y más informativa a partir de las existentes. Es exactamente el mismo razonamiento que ya usa tu profesión:\n",
    "\n",
    "| Indicador industrial | Fórmula | Qué logra |\n",
    "|---|---|---|\n",
    "| **Productividad** | Unidades / hora-hombre | Comparar plantas de tamaños distintos |\n",
    "| **Costo unitario** | Costo total / unidades | Comparar lotes de producción distintos |\n",
    "| **OEE** | Disponibilidad × Rendimiento × Calidad | Comparar máquinas distintas |\n",
    "| **Valor por m²** | Precio / área | Comparar inmuebles distintos |\n",
    "\n",
    "> 🧠 **Ninguno de esos números \"existe\" en la realidad. Los construimos** porque permiten comparar, y comparar es la condición previa para decidir. Un ingeniero industrial que no sabe construir indicadores está condenado a reportar datos en vez de dirigir procesos.\n",
    "\n",
    "## Los 4 filtros de un buen indicador\n",
    "\n",
    "| Filtro | Pregunta |\n",
    "|---|---|\n",
    "| **Comparable** | ¿Puedo poner dos cosas distintas en la misma escala? |\n",
    "| **Accionable** | Si se mueve, ¿sé qué hacer al respecto? |\n",
    "| **Sensible** | ¿Cambia cuando la realidad cambia? |\n",
    "| **Difícil de manipular** | ¿Alguien puede \"mejorarlo\" sin mejorar la realidad? |\n",
    "\n",
    "> ⚠️ El cuarto filtro es el que más organizaciones ignoran, y el que más daño hace. Un indicador que se puede maquillar **se maquilla**: entonces el tablero mide comportamiento político en vez de desempeño real. Si alguna vez viste un área \"cumplir la meta\" mientras el proceso empeoraba, viste este filtro fallar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "b4827851f174"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 5.1 — CONSTRUCCIÓN DE INDICADORES\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "# ── Métrica reina: valor por metro cuadrado ──────────────────────────────────\n",
    "# Blindaje: el área 0 o nula se convierte en NaN ANTES de dividir.\n",
    "# Sin esto, Python devolvería \"infinito\" y contaminaría todos los promedios.\n",
    "area_segura = df[\"Area_m2\"].replace(0, np.nan)\n",
    "df[\"Valor_m2_Millones\"] = (df[\"Precio_Millones\"] / area_segura).round(2)\n",
    "\n",
    "# ── Segmento comercial por tamaño ────────────────────────────────────────────\n",
    "df[\"Segmento\"] = pd.cut(\n",
    "    df[\"Area_m2\"],\n",
    "    bins=[0, 45, 70, 110, 180, np.inf],\n",
    "    labels=[\"Apartaestudio (<45)\", \"Compacto (45-70)\", \"Familiar (70-110)\",\n",
    "            \"Amplio (110-180)\", \"Premium (>180)\"]\n",
    ")\n",
    "\n",
    "# ── Tabla de trabajo: solo filas completas y con sentido ─────────────────────\n",
    "columnas_analisis = [\"Título\", \"Localidad\", \"Tipo\", \"Segmento\", \"Precio_Millones\",\n",
    "                     \"Area_m2\", \"Habitaciones_Num\", \"Banos_Num\", \"Valor_m2_Millones\", \"URL\"]\n",
    "columnas_analisis = [c for c in columnas_analisis if c in df.columns]\n",
    "\n",
    "df_estrategico = df[columnas_analisis].dropna(\n",
    "    subset=[\"Precio_Millones\", \"Area_m2\", \"Valor_m2_Millones\"]\n",
    ").copy()\n",
    "\n",
    "# ── Reglas de validez del negocio (no todo número es un dato válido) ─────────\n",
    "reglas = {\n",
    "    \"Área entre 20 y 1000 m²\":        df_estrategico[\"Area_m2\"].between(20, 1000),\n",
    "    \"Precio entre 50 y 15.000 M\":     df_estrategico[\"Precio_Millones\"].between(50, 15000),\n",
    "    \"Valor m² entre 1 y 40 M\":        df_estrategico[\"Valor_m2_Millones\"].between(1, 40),\n",
    "}\n",
    "print(\"═\" * 62)\n",
    "print(\"  VALIDACIÓN CONTRA REGLAS DE NEGOCIO\")\n",
    "print(\"═\" * 62)\n",
    "mascara = pd.Series(True, index=df_estrategico.index)\n",
    "for nombre, regla in reglas.items():\n",
    "    fuera = (~regla).sum()\n",
    "    print(f\"  {'✅' if fuera == 0 else '⚠️ '} {nombre:<34} → {fuera} registros fuera de rango\")\n",
    "    mascara &= regla\n",
    "\n",
    "antes = len(df_estrategico)\n",
    "df_estrategico = df_estrategico[mascara].reset_index(drop=True)\n",
    "\n",
    "print(\"─\" * 62)\n",
    "print(f\"  Registros antes de validar ..... {antes}\")\n",
    "print(f\"  Registros descartados .......... {antes - len(df_estrategico)}\")\n",
    "print(f\"  ✅ BASE ANALÍTICA FINAL ......... {len(df_estrategico)} inmuebles\")\n",
    "print(\"═\" * 62)\n",
    "\n",
    "DATOS_OK = len(df_estrategico) >= 15\n",
    "if not DATOS_OK:\n",
    "    print(\"\\n⚠️  Muy pocos registros válidos. Vuelve a la celda 2.4 y ejecútala de nuevo,\")\n",
    "    print(\"    o sube CONFIG['num_paginas'] y repite la extracción.\")\n",
    "else:\n",
    "    display(df_estrategico.head(6))\n",
    "    print(\"\\n📊 Resumen estadístico del mercado:\")\n",
    "    display(df_estrategico[[\"Precio_Millones\", \"Area_m2\", \"Valor_m2_Millones\"]].describe().round(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cb15db07a1ed"
   },
   "source": [
    "### 📖 Cómo leer la tabla `describe()` de arriba (te va a servir toda la vida)\n",
    "\n",
    "| Fila | Qué significa | Por qué importa |\n",
    "|---|---|---|\n",
    "| `count` | Cuántos datos válidos hay | Si es mucho menor que tu total, algo se perdió |\n",
    "| `mean` | El promedio | **Engaña** cuando hay valores extremos |\n",
    "| `std` | Desviación estándar | Qué tan disperso está el mercado. **Alta dispersión = espacio para diferenciarse** |\n",
    "| `min` / `max` | El más barato y el más caro | Detecta errores y detecta nichos |\n",
    "| `25%` | Un cuarto del mercado está por debajo | El piso del mercado |\n",
    "| `50%` | La **mediana**: la mitad exacta | Más confiable que el promedio |\n",
    "| `75%` | Tres cuartos están por debajo | El techo del mercado \"normal\" |\n",
    "\n",
    "> 🧠 **La lección de negocio más rentable de esta tabla:**\n",
    "> Si `mean` es mucho mayor que `50%` (la mediana), significa que **unos pocos inmuebles carísimos están inflando el promedio**.\n",
    ">\n",
    "> Un gerente que decide con el promedio en ese mercado, **fija sus precios por encima de lo que la mayoría puede pagar** — y no vende. Compara siempre las dos cifras antes de usar un promedio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "61502ccb6929"
   },
   "source": [
    "---\n",
    "# 🎯 BLOQUE 6 — Valores atípicos: control estadístico del dato\n",
    "\n",
    "## ¿Qué es un valor atípico (*outlier*)?\n",
    "\n",
    "Una observación tan alejada del resto que **distorsiona cualquier cálculo**: la mansión de $12.000 millones en la misma tabla que el apartaestudio de $130 millones.\n",
    "\n",
    "## ⚙️ Esto es control estadístico, y ya lo conoces\n",
    "\n",
    "En control de procesos trazas límites y todo lo que cae fuera se investiga. Aquí es lo mismo, con el **rango intercuartílico (IQR)** en vez de las 3 sigmas:\n",
    "\n",
    "1. Q1 = valor que deja abajo el 25% de los datos\n",
    "2. Q3 = valor que deja abajo el 75%\n",
    "3. IQR = Q3 − Q1 (donde vive la mitad central)\n",
    "4. **Es atípico todo lo que esté fuera de** `[Q1 − 1.5·IQR , Q3 + 1.5·IQR]`\n",
    "\n",
    "> ¿Por qué IQR y no la desviación estándar? Porque **la desviación estándar la calculan los propios atípicos y se infla con ellos**. Los cuartiles no: son robustos. Cuando la distribución no es normal —y los precios nunca lo son—, IQR es el criterio correcto.\n",
    "\n",
    "## La decisión que el algoritmo NO puede tomar por ti\n",
    "\n",
    "| Si tu pregunta es... | Entonces el atípico es... |\n",
    "|---|---|\n",
    "| \"¿Cuánto vale el m² del mercado masivo?\" | **Ruido** → sepáralo |\n",
    "| \"¿Existe un nicho de ultra-lujo desatendido?\" | **La respuesta** → estúdialo |\n",
    "| \"¿Hay errores en mi captura de datos?\" | **Una alerta** → investígalo |\n",
    "\n",
    "> 🧠 **Regla profesional: nunca borres, siempre marca.** Aquí creamos dos vistas del mismo mercado y conservamos ambas. Un pipeline que elimina silenciosamente lo raro es un pipeline que **destruye evidencia** — y en una auditoría, eso no se puede defender."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "671116f67678"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 6.1 — DETECCIÓN DE ATÍPICOS (marcar, no borrar)\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def marcar_atipicos(serie, factor=1.5):\n",
    "    \"\"\"Devuelve (máscara de normales, límite inferior, límite superior).\"\"\"\n",
    "    q1, q3 = serie.quantile(0.25), serie.quantile(0.75)\n",
    "    iqr = q3 - q1\n",
    "    li, ls = q1 - factor * iqr, q3 + factor * iqr\n",
    "    return serie.between(li, ls), li, ls\n",
    "\n",
    "if DATOS_OK:\n",
    "    n_precio, li_p, ls_p = marcar_atipicos(df_estrategico[\"Precio_Millones\"])\n",
    "    n_area,   li_a, ls_a = marcar_atipicos(df_estrategico[\"Area_m2\"])\n",
    "\n",
    "    df_estrategico[\"Es_Atipico\"] = ~(n_precio & n_area)\n",
    "    df_real = df_estrategico[~df_estrategico[\"Es_Atipico\"]].copy()   # mercado masivo\n",
    "    df_lujo = df_estrategico[df_estrategico[\"Es_Atipico\"]].copy()    # nicho / extremos\n",
    "\n",
    "    print(\"═\" * 66)\n",
    "    print(\"  DETECCIÓN DE VALORES ATÍPICOS (método IQR)\")\n",
    "    print(\"═\" * 66)\n",
    "    print(f\"  Rango 'normal' de precio ... {li_p:>8.0f} a {ls_p:>8.0f} millones\")\n",
    "    print(f\"  Rango 'normal' de área ..... {li_a:>8.0f} a {ls_a:>8.0f} m²\")\n",
    "    print(\"─\" * 66)\n",
    "    print(f\"  🏘️  MERCADO MASIVO (df_real) ....... {len(df_real):>4} inmuebles \"\n",
    "          f\"({100*len(df_real)/len(df_estrategico):.1f}%)\")\n",
    "    print(f\"  💎 EXTREMOS / NICHO (df_lujo) ..... {len(df_lujo):>4} inmuebles \"\n",
    "          f\"({100*len(df_lujo)/len(df_estrategico):.1f}%)\")\n",
    "    print(\"═\" * 66)\n",
    "\n",
    "    if len(df_real) < 10:\n",
    "        print(\"⚠️  El filtro dejó muy pocos registros. Trabajaremos con la base completa.\")\n",
    "        df_real = df_estrategico.copy()\n",
    "\n",
    "    comparativo = pd.DataFrame({\n",
    "        \"Mercado masivo\": df_real[[\"Precio_Millones\", \"Area_m2\", \"Valor_m2_Millones\"]].mean(),\n",
    "        \"Base completa\":  df_estrategico[[\"Precio_Millones\", \"Area_m2\", \"Valor_m2_Millones\"]].mean(),\n",
    "    }).round(2)\n",
    "    comparativo[\"Distorsión %\"] = (100 * (comparativo[\"Base completa\"] / comparativo[\"Mercado masivo\"] - 1)).round(1)\n",
    "    print(\"\\n  💡 Cuánto distorsionan los atípicos a los promedios:\")\n",
    "    display(comparativo)\n",
    "\n",
    "    if len(df_lujo):\n",
    "        print(\"  Ejemplos del segmento extremo:\")\n",
    "        display(df_lujo.nlargest(min(5, len(df_lujo)), \"Precio_Millones\")\n",
    "                [[\"Título\", \"Localidad\", \"Precio_Millones\", \"Area_m2\", \"Valor_m2_Millones\"]])\n",
    "else:\n",
    "    df_real = df_estrategico.copy()\n",
    "    df_lujo = df_estrategico.head(0).copy()\n",
    "    print(\"⚠️  Sin datos suficientes para el análisis de atípicos.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c639ef6147c5"
   },
   "source": [
    "### 🗣️ Discusión (3 minutos)\n",
    "\n",
    "Mira la columna **\"Distorsión %\"**. Ese número te dice **cuánto se equivocaría** un gerente que usa el promedio de toda la base.\n",
    "\n",
    "**Pregunta:** si la distorsión del precio promedio es, digamos, del 18%, y tu empresa fija el precio de lanzamiento con esa cifra... ¿cuántas unidades dejas de vender?\n",
    "\n",
    "> **Ese porcentaje no es estadística. Es dinero.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "19fbe4eec465"
   },
   "source": [
    "---\n",
    "# 💾 BLOQUE 7 — Exportar: llevar los datos a Excel y Power BI\n",
    "\n",
    "## ⚙️ Bloque central para Ingeniería Industrial\n",
    "\n",
    "Un análisis que **vive solo dentro de un notebook no sirve en una empresa**. El gerente no va a abrir Colab. El área comercial tampoco.\n",
    "\n",
    "Tu trabajo como ingeniero no termina en el hallazgo: termina cuando **el hallazgo llega a quien decide, en el formato en que esa persona trabaja**.\n",
    "\n",
    "## Qué vamos a exportar y por qué\n",
    "\n",
    "| Hoja / archivo | Contenido | Para quién |\n",
    "|---|---|---|\n",
    "| `datos` | La base analítica limpia, una fila por inmueble | Power BI, análisis propio |\n",
    "| `diccionario` | Qué significa cada columna, su unidad y su origen | **El que reciba el archivo en 6 meses** |\n",
    "| `resumen_segmento` | Métricas agregadas por segmento | La presentación al comité |\n",
    "| `resumen_localidad` | Métricas por zona de la ciudad | El equipo de tierras |\n",
    "\n",
    "> 📋 **El diccionario de datos es lo que separa un archivo de un activo.**\n",
    "> Una tabla sin diccionario es un archivo que alguien tendrá que descifrar. Una tabla con diccionario es información que la organización puede reutilizar. En gobierno de datos esto se llama **metadata**, y es lo primero que exige cualquier auditoría.\n",
    "\n",
    "## 🔗 Y en Power BI, ¿qué hago con esto?\n",
    "\n",
    "El archivo que vamos a generar es una **tabla plana** (*flat table*): una fila por observación, una columna por atributo, sin celdas combinadas, sin títulos decorativos, sin totales en medio de los datos.\n",
    "\n",
    "Ese formato no es casual — es el único que Power BI, Tableau o Excel pueden modelar bien.\n",
    "\n",
    "**Ruta en Power BI:** `Obtener datos` → `Excel` → selecciona la hoja `datos` → `Transformar datos` para revisar tipos → `Cerrar y aplicar`.\n",
    "\n",
    "**Tres visuales que puedes armar en 10 minutos:**\n",
    "1. **Mapa de árbol** de oferta por localidad (tamaño = cantidad, color = valor m² promedio)\n",
    "2. **Gráfico de dispersión** área vs. precio, con segmentador por número de habitaciones\n",
    "3. **Tarjetas KPI**: valor m² promedio, mediana de precio, total de oferta analizada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "92e1d0a48264"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 7.1 — EXPORTACIÓN A EXCEL Y CSV (con diccionario de datos)\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "import os\n",
    "\n",
    "DICCIONARIO = pd.DataFrame([\n",
    "    (\"Título\",            \"Texto\",   \"—\",              \"Portal inmobiliario\", \"Titular del aviso publicado\"),\n",
    "    (\"Localidad\",         \"Texto\",   \"—\",              \"Derivado de Ubicación\", \"Primera parte de la ubicación publicada\"),\n",
    "    (\"Tipo\",              \"Texto\",   \"—\",              \"Derivado del Título\",   \"Apartamento / Casa / Apartaestudio / Comercial\"),\n",
    "    (\"Segmento\",          \"Texto\",   \"—\",              \"Derivado del Área\",     \"Clasificación comercial por tamaño\"),\n",
    "    (\"Precio_Millones\",   \"Decimal\", \"Millones COP\",   \"Limpieza de Precio\",    \"Precio de OFERTA publicado, no de cierre\"),\n",
    "    (\"Area_m2\",           \"Decimal\", \"m²\",             \"Limpieza de Área\",      \"Área construida publicada\"),\n",
    "    (\"Habitaciones_Num\",  \"Entero\",  \"unidades\",       \"Limpieza\",              \"Número de habitaciones\"),\n",
    "    (\"Banos_Num\",         \"Entero\",  \"unidades\",       \"Limpieza\",              \"Número de baños\"),\n",
    "    (\"Valor_m2_Millones\", \"Decimal\", \"Millones COP/m²\",\"Calculado\",             \"Precio_Millones / Area_m2 — métrica de comparación\"),\n",
    "    (\"Es_Atipico\",        \"Lógico\",  \"—\",              \"Calculado (IQR)\",       \"Verdadero si el registro está fuera del rango normal\"),\n",
    "    (\"URL\",               \"Texto\",   \"—\",              \"Portal inmobiliario\",   \"Enlace al aviso original: permite verificar cada fila en la fuente\"),\n",
    "], columns=[\"Columna\", \"Tipo de dato\", \"Unidad\", \"Origen\", \"Definición\"])\n",
    "\n",
    "if DATOS_OK:\n",
    "    # ── Tablas resumen para el tablero ───────────────────────────────────────\n",
    "    resumen_segmento = (df_real.groupby(\"Segmento\", observed=True)\n",
    "                        .agg(Oferta=(\"Título\", \"count\"),\n",
    "                             Precio_Prom=(\"Precio_Millones\", \"mean\"),\n",
    "                             Precio_Mediana=(\"Precio_Millones\", \"median\"),\n",
    "                             Area_Prom=(\"Area_m2\", \"mean\"),\n",
    "                             Valor_m2_Prom=(\"Valor_m2_Millones\", \"mean\"),\n",
    "                             Valor_m2_Desv=(\"Valor_m2_Millones\", \"std\"))\n",
    "                        .round(2).reset_index())\n",
    "    resumen_segmento[\"Participacion_%\"] = (100 * resumen_segmento[\"Oferta\"] /\n",
    "                                           max(resumen_segmento[\"Oferta\"].sum(), 1)).round(1)\n",
    "\n",
    "    resumen_localidad = (df_real.groupby(\"Localidad\", observed=True)\n",
    "                         .agg(Oferta=(\"Título\", \"count\"),\n",
    "                              Precio_Prom=(\"Precio_Millones\", \"mean\"),\n",
    "                              Valor_m2_Prom=(\"Valor_m2_Millones\", \"mean\"),\n",
    "                              Area_Prom=(\"Area_m2\", \"mean\"))\n",
    "                         .round(2).sort_values(\"Valor_m2_Prom\", ascending=False).reset_index())\n",
    "\n",
    "    archivos = []\n",
    "\n",
    "    # ── CSV (universal, entra en cualquier herramienta) ──────────────────────\n",
    "    try:\n",
    "        df_estrategico.to_csv(\"02_base_analitica.csv\", index=False, encoding=\"utf-8-sig\")\n",
    "        archivos.append(\"02_base_analitica.csv\")\n",
    "    except Exception as e:\n",
    "        print(f\"⚠️  No se pudo escribir el CSV: {e}\")\n",
    "\n",
    "    # ── Excel multi-hoja ─────────────────────────────────────────────────────\n",
    "    if ESTADO_ENTORNO.get(\"excel\"):\n",
    "        try:\n",
    "            with pd.ExcelWriter(\"03_mercado_inmobiliario_bogota.xlsx\", engine=\"openpyxl\") as xl:\n",
    "                df_estrategico.to_excel(xl, sheet_name=\"datos\", index=False)\n",
    "                DICCIONARIO.to_excel(xl, sheet_name=\"diccionario\", index=False)\n",
    "                resumen_segmento.to_excel(xl, sheet_name=\"resumen_segmento\", index=False)\n",
    "                resumen_localidad.to_excel(xl, sheet_name=\"resumen_localidad\", index=False)\n",
    "                pd.DataFrame({\n",
    "                    \"Campo\": [\"Fuente\", \"Fecha de extracción\", \"Registros\", \"Origen de los datos\",\n",
    "                              \"Advertencia\"],\n",
    "                    \"Valor\": [CONFIG[\"url_base\"],\n",
    "                              pd.Timestamp.now().strftime(\"%Y-%m-%d %H:%M\"),\n",
    "                              len(df_estrategico), ORIGEN_DATOS,\n",
    "                              \"Precios de OFERTA publicada, no de transacción cerrada.\"]\n",
    "                }).to_excel(xl, sheet_name=\"ficha_tecnica\", index=False)\n",
    "            archivos.append(\"03_mercado_inmobiliario_bogota.xlsx\")\n",
    "        except Exception as e:\n",
    "            print(f\"⚠️  No se pudo escribir el Excel: {e}\")\n",
    "\n",
    "    print(\"═\" * 62)\n",
    "    print(\"  ARCHIVOS GENERADOS\")\n",
    "    print(\"═\" * 62)\n",
    "    for a in archivos:\n",
    "        tam = os.path.getsize(a) / 1024 if os.path.exists(a) else 0\n",
    "        print(f\"  ✅ {a:<42} {tam:>7.1f} KB\")\n",
    "    print(\"═\" * 62)\n",
    "    print(\"\\n  📥 Para descargarlos: panel izquierdo → ícono de carpeta 📁 →\")\n",
    "    print(\"     clic derecho sobre el archivo → Descargar.\")\n",
    "    print(\"     (O ejecuta la celda 7.2 para descargarlos automáticamente.)\")\n",
    "\n",
    "    print(\"\\n  📖 Diccionario de datos:\")\n",
    "    display(DICCIONARIO)\n",
    "    print(\"\\n  📊 Resumen por segmento:\")\n",
    "    display(resumen_segmento)\n",
    "else:\n",
    "    print(\"⚠️  Sin base analítica válida no hay nada que exportar.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "d377e46e4df6"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 7.2 — (OPCIONAL) Descargar los archivos al computador\n",
    "# Solo funciona dentro de Google Colab.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "import os\n",
    "\n",
    "try:\n",
    "    from google.colab import files\n",
    "    for archivo in [\"02_base_analitica.csv\", \"03_mercado_inmobiliario_bogota.xlsx\"]:\n",
    "        if os.path.exists(archivo):\n",
    "            print(f\"📥 Descargando {archivo}...\")\n",
    "            files.download(archivo)\n",
    "except ImportError:\n",
    "    print(\"ℹ️  No estás en Colab. Descarga los archivos desde el explorador de tu entorno.\")\n",
    "except Exception as e:\n",
    "    print(f\"ℹ️  La descarga automática no funcionó ({type(e).__name__}).\")\n",
    "    print(\"   Usa el panel izquierdo 📁 → clic derecho → Descargar.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "97e94c72ee41"
   },
   "source": [
    "---\n",
    "# 📊 BLOQUE 8 — Visualización con propósito\n",
    "\n",
    "## Una regla antes de graficar\n",
    "\n",
    "> **Un gráfico no es decoración. Es un argumento.**\n",
    "\n",
    "Si no puedes decir en una frase qué decisión cambia el gráfico, ese gráfico sobra en tu informe. Por eso cada visualización viene con tres cosas: **la pregunta** que responde, **qué mirar**, y **qué decisión** habilita.\n",
    "\n",
    "## ⚙️ Elegir el gráfico correcto no es estética: es rigor\n",
    "\n",
    "| Si quieres... | Usa | Error típico |\n",
    "|---|---|---|\n",
    "| Relación entre dos variables numéricas | **Dispersión** (scatter) | Usar barras y perder la relación |\n",
    "| Cómo se reparte una variable | **Histograma** | Reportar solo el promedio |\n",
    "| Comparar distribuciones entre grupos | **Caja** (boxplot) o **violín** | Comparar solo promedios y ocultar la dispersión |\n",
    "| Intensidad de un cruce de categorías | **Mapa de calor** | Una tabla de 40 filas que nadie lee |\n",
    "| Dónde se concentra la masa de datos | **Mapa de densidad** | Un scatter saturado de puntos superpuestos |\n",
    "\n",
    "> 🧠 **El error de la columna derecha es el mismo siempre: mostrar el centro y esconder la variabilidad.** En ingeniería industrial eso es imperdonable — la variabilidad *es* el problema que gestionamos. Un proceso con la media perfecta y desviación enorme está fuera de control, y un gráfico que solo muestra promedios te lo oculta.\n",
    "\n",
    "Vamos a construir cuatro gráficos, cada uno respondiendo una pregunta distinta del negocio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "0140e8c1dc81"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.0 — Preparación de gráficos (compatible con cualquier versión)\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "import matplotlib\n",
    "matplotlib.use(\"Agg\") if False else None\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set_theme(style=\"whitegrid\", palette=\"deep\")\n",
    "plt.rcParams.update({\n",
    "    \"figure.dpi\": 110, \"savefig.dpi\": 130,\n",
    "    \"axes.titlesize\": 15, \"axes.titleweight\": \"bold\",\n",
    "    \"axes.labelsize\": 12, \"font.size\": 11,\n",
    "    \"figure.autolayout\": False,\n",
    "})\n",
    "\n",
    "def hay_datos(df, minimo=5, nombre=\"gráfico\"):\n",
    "    \"\"\"Verifica que haya datos suficientes antes de intentar dibujar.\"\"\"\n",
    "    if df is None or len(df) < minimo:\n",
    "        print(f\"⚠️  Datos insuficientes para {nombre} \"\n",
    "              f\"({0 if df is None else len(df)} registros, se requieren {minimo}).\")\n",
    "        return False\n",
    "    return True\n",
    "\n",
    "def grafico_categoria(tipo, data, x, y, ax=None, **kwargs):\n",
    "    \"\"\"\n",
    "    Dibuja boxplot/violinplot de forma compatible con seaborn 0.11 → 0.14+.\n",
    "    Las versiones nuevas exigen 'hue' para usar paleta; las viejas no lo aceptan.\n",
    "    Este envoltorio prueba lo nuevo y, si falla, usa lo viejo. Blindaje puro.\n",
    "    \"\"\"\n",
    "    fn = {\"box\": sns.boxplot, \"violin\": sns.violinplot}[tipo]\n",
    "    try:\n",
    "        return fn(data=data, x=x, y=y, hue=x, legend=False, ax=ax, **kwargs)\n",
    "    except Exception:\n",
    "        kwargs.pop(\"palette\", None)\n",
    "        return fn(data=data, x=x, y=y, ax=ax, **kwargs)\n",
    "\n",
    "print(\"🎨 Estilo gráfico configurado.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "58415f654197"
   },
   "source": [
    "### 📍 Gráfico 1 — Dispersión: la relación entre dos variables\n",
    "\n",
    "**La pregunta:** ¿cómo se relacionan el tamaño y el precio en este mercado?\n",
    "\n",
    "**Qué mirar:**\n",
    "- La **nube principal**: dónde se concentra la mayoría de las observaciones.\n",
    "- La **forma**: ¿la relación es lineal, curva, o no hay relación?\n",
    "- Los **espacios vacíos**: combinaciones que no existen en los datos.\n",
    "- El **color** (habitaciones) y el **tamaño del punto** (valor del m²) añaden dos variables más al mismo gráfico.\n",
    "\n",
    "**La decisión que habilita:** dónde ubicar el producto que vamos a diseñar.\n",
    "\n",
    "> ⚙️ **Por qué un scatter y no una tabla:** con 400 filas, una tabla no te deja ver la estructura. Un gráfico de dispersión muestra en un segundo la relación, la dispersión y las excepciones — las tres cosas que necesitas antes de modelar nada.\n",
    ">\n",
    "> Y fíjate en algo que se aprende mirando: **un espacio vacío no siempre es una oportunidad**. Puede ser que ese producto no se pueda construir, o que ya lo intentaron y no funcionó. El dato te muestra el hueco; averiguar por qué está vacío requiere salir a preguntar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ab2b2934d225"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.1 — Mapa de posicionamiento competitivo\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 5, \"el mapa de posicionamiento\"):\n",
    "    fig, ax = plt.subplots(figsize=(12, 7))\n",
    "    sns.scatterplot(\n",
    "        data=df_real, x=\"Area_m2\", y=\"Precio_Millones\",\n",
    "        hue=\"Habitaciones_Num\", size=\"Valor_m2_Millones\",\n",
    "        sizes=(40, 380), palette=\"viridis\", alpha=0.75,\n",
    "        edgecolor=\"white\", linewidth=0.5, ax=ax\n",
    "    )\n",
    "    ax.set_title(\"Mapa de posicionamiento competitivo: tamaño vs. precio\")\n",
    "    ax.set_xlabel(\"Área del inmueble (m²)\")\n",
    "    ax.set_ylabel(\"Precio total (millones de COP)\")\n",
    "    ax.legend(bbox_to_anchor=(1.02, 1), loc=\"upper left\", borderaxespad=0., fontsize=9)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    print(f\"👀 Estás viendo {len(df_real)} competidores reales del mercado bogotano.\")\n",
    "    print(\"   Pregunta para el grupo: ¿dónde ves un espacio vacío? ¿Y por qué crees que está vacío?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "76d24bc4cc86"
   },
   "source": [
    "### 🌡️ Gráfico 2 — Histograma: cómo se distribuye una variable\n",
    "\n",
    "**La pregunta:** ¿cuánto se cobra por metro cuadrado en este mercado, y qué tan de acuerdo están los oferentes entre sí?\n",
    "\n",
    "**Qué mirar:**\n",
    "- La **línea roja** = promedio. La **línea azul** = mediana. Si están separadas, la distribución es asimétrica.\n",
    "- El **ancho** de la campana = la variabilidad del mercado.\n",
    "- ¿Hay **una sola joroba o dos**? Dos jorobas (distribución bimodal) casi siempre significan **dos poblaciones distintas mezcladas** en la misma tabla.\n",
    "\n",
    "**La decisión que habilita:** el precio de referencia con el que vamos a simular el proyecto.\n",
    "\n",
    "> ⚙️ **La lectura que separa a un analista de un capturador de datos:**\n",
    "> Reportar solo el promedio de esta variable sería un error profesional. El promedio es **un** número; la distribución es **la información completa**.\n",
    ">\n",
    "> - Campana **estrecha** (baja variabilidad) → el producto se comporta como un *commodity*: la competencia se resuelve por costo.\n",
    "> - Campana **ancha** (alta variabilidad) → hay factores no capturados en tus datos que explican la diferencia. **Encontrarlos es donde está el valor.**\n",
    ">\n",
    "> Ese segundo caso es el trabajo real del ingeniero: cuando la variabilidad es alta, la pregunta no es \"¿cuál es el promedio?\" sino **\"¿qué explica la diferencia?\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ab0a0f101b43"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.2 — Distribución del valor por m²\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 5, \"la distribución de valor\"):\n",
    "    fig, ax = plt.subplots(figsize=(11, 6))\n",
    "    sns.histplot(data=df_real, x=\"Valor_m2_Millones\", kde=True,\n",
    "                 color=\"teal\", bins=min(20, max(6, len(df_real) // 12)), ax=ax)\n",
    "\n",
    "    prom = df_real[\"Valor_m2_Millones\"].mean()\n",
    "    med  = df_real[\"Valor_m2_Millones\"].median()\n",
    "    desv = df_real[\"Valor_m2_Millones\"].std()\n",
    "\n",
    "    ax.axvline(prom, color=\"red\",   linestyle=\"--\", lw=2.5, label=f\"Promedio: ${prom:.2f} M/m²\")\n",
    "    ax.axvline(med,  color=\"navy\",  linestyle=\":\",  lw=2.5, label=f\"Mediana:  ${med:.2f} M/m²\")\n",
    "    ax.set_title(\"¿Cuánto cobra la competencia por metro cuadrado?\")\n",
    "    ax.set_xlabel(\"Valor del m² (millones de COP)\")\n",
    "    ax.set_ylabel(\"Cantidad de inmuebles\")\n",
    "    ax.legend()\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    cv = desv / prom if prom else 0\n",
    "    print(\"═\" * 62)\n",
    "    print(f\"  Promedio ......... ${prom:.2f} M/m²\")\n",
    "    print(f\"  Mediana .......... ${med:.2f} M/m²\")\n",
    "    print(f\"  Dispersión (CV) .. {cv:.0%}\")\n",
    "    print(\"─\" * 62)\n",
    "    if cv < 0.20:\n",
    "        print(\"  📉 Mercado HOMOGÉNEO: precios muy parecidos entre competidores.\")\n",
    "        print(\"     → Implicación: la competencia se resolverá por COSTO. Optimiza el proceso, no el producto.\")\n",
    "    elif cv < 0.40:\n",
    "        print(\"  📊 Mercado MIXTO: hay franjas de precio diferenciadas.\")\n",
    "        print(\"     → Implicación: conviene ESPECIALIZARSE en una franja concreta del mercado.\")\n",
    "    else:\n",
    "        print(\"  📈 Mercado HETEROGÉNEO: enorme variación de precios por m².\")\n",
    "        print(\"     → Implicación: hay factores no capturados que explican la diferencia. Vale la pena buscarlos.\")\n",
    "    print(\"═\" * 62)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "577f75b89b5d"
   },
   "source": [
    "### 🏢 Gráfico 3 — Análisis de portafolio: ¿qué producto conviene producir?\n",
    "\n",
    "**La pregunta:** con la misma capacidad instalada, ¿conviene producir muchas unidades pequeñas o pocas grandes?\n",
    "\n",
    "**Qué mirar:** en un diagrama de cajas, la **línea del medio** es la mediana, la **caja** contiene la mitad central de los datos y los **puntos sueltos** son atípicos. Caja alta = ese producto se vende más caro por m².\n",
    "\n",
    "**La decisión que habilita:** la **mezcla de producto** (*product mix*) del proyecto.\n",
    "\n",
    "> ⚙️ **Esto es un problema clásico de ingeniería industrial.** Tienes un recurso escaso (metros cuadrados de lote, horas de obra, capital) y varias líneas de producto que lo consumen a ritmos distintos y aportan márgenes distintos. Decidir la mezcla que maximiza el aporte total con recursos limitados es, literalmente, un problema de **programación lineal** — el mismo que verás formalizado en Investigación de Operaciones.\n",
    ">\n",
    "> Hoy lo resolvemos con datos y criterio. Más adelante lo resolverás con un modelo. **Pero el modelo sin estos datos no vale nada:** los coeficientes de la función objetivo tienen que salir de algún lado, y ese lado es exactamente este bloque.\n",
    ">\n",
    "> ⚠️ Y no olvides la restricción invisible: que un segmento sea el más rentable **no significa que tu operación esté preparada para producirlo**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ac7bc66a9a06"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.3 — Rentabilidad por número de habitaciones\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 5, \"el análisis de portafolio\"):\n",
    "    # Solo tipologías con muestra suficiente para no sacar conclusiones de 1 dato\n",
    "    conteo = df_real[\"Habitaciones_Num\"].value_counts()\n",
    "    validas = conteo[conteo >= 3].index.tolist()\n",
    "    df_port = df_real[df_real[\"Habitaciones_Num\"].isin(validas)].copy()\n",
    "\n",
    "    if hay_datos(df_port, 5, \"el boxplot por habitaciones\"):\n",
    "        fig, ax = plt.subplots(figsize=(11, 6))\n",
    "        grafico_categoria(\"box\", df_port, \"Habitaciones_Num\", \"Valor_m2_Millones\",\n",
    "                          ax=ax, palette=\"Set2\")\n",
    "        ax.set_title(\"Rentabilidad del m² según el número de habitaciones\")\n",
    "        ax.set_xlabel(\"Número de habitaciones (segmento de mercado)\")\n",
    "        ax.set_ylabel(\"Valor del m² (millones de COP)\")\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    resumen_portafolio = (df_real.groupby(\"Habitaciones_Num\", observed=True)\n",
    "                          .agg(Oferta=(\"Título\", \"count\"),\n",
    "                               Precio_Prom=(\"Precio_Millones\", \"mean\"),\n",
    "                               Area_Prom=(\"Area_m2\", \"mean\"),\n",
    "                               Valor_m2_Prom=(\"Valor_m2_Millones\", \"mean\"))\n",
    "                          .round(2))\n",
    "    resumen_portafolio[\"Participacion_%\"] = (100 * resumen_portafolio[\"Oferta\"] /\n",
    "                                             resumen_portafolio[\"Oferta\"].sum()).round(1)\n",
    "    print(\"\\n  📋 RESUMEN DE PORTAFOLIO POR TIPOLOGÍA\")\n",
    "    display(resumen_portafolio)\n",
    "\n",
    "    conf = resumen_portafolio[resumen_portafolio[\"Oferta\"] >= 3]\n",
    "    if len(conf):\n",
    "        mejor = conf[\"Valor_m2_Prom\"].idxmax()\n",
    "        print(f\"  🏆 Mayor valor por m²: tipología de {int(mejor)} habitación(es) \"\n",
    "              f\"→ ${conf.loc[mejor, 'Valor_m2_Prom']:.2f} M/m² \"\n",
    "              f\"con {int(conf.loc[mejor, 'Oferta'])} competidores \"\n",
    "              f\"({conf.loc[mejor, 'Participacion_%']}% de la oferta).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4c7bc7dd235f"
   },
   "source": [
    "### 🔗 Gráfico 4 — ¿Qué atributos paga realmente el cliente?\n",
    "\n",
    "**La pregunta:** si agrego un baño extra a los planos, ¿el mercado me lo paga o solo me sube el costo?\n",
    "\n",
    "**Qué mirar:** la matriz de correlación va de **−1 a +1**.\n",
    "- Cerca de **+1**: cuando una sube, la otra sube.\n",
    "- Cerca de **0**: no tienen relación.\n",
    "- Cerca de **−1**: cuando una sube, la otra baja.\n",
    "\n",
    "**La decisión que habilita:** qué atributos incluir en el diseño arquitectónico.\n",
    "\n",
    "> ⚠️ **La advertencia más importante de toda la analítica de datos:**\n",
    ">\n",
    "> ## Correlación no es causalidad.\n",
    ">\n",
    "> Que el número de baños correlacione con el precio **no significa** que poner baños suba el precio. Puede ser que las casas grandes tengan más baños **y** cuesten más — el baño es un acompañante, no la causa.\n",
    ">\n",
    "> El dato te muestra **qué va junto con qué**. Decidir **qué causa qué** exige conocimiento del negocio, experimentación o un diseño estadístico serio. **Confundir las dos cosas es el error que más dinero ha costado en la historia de las decisiones \"basadas en datos\".**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "b2185677aa93"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.4 — Matriz de correlación\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 5, \"la matriz de correlación\"):\n",
    "    cols_num = [\"Precio_Millones\", \"Area_m2\", \"Habitaciones_Num\", \"Banos_Num\", \"Valor_m2_Millones\"]\n",
    "    cols_num = [c for c in cols_num if c in df_real.columns and df_real[c].nunique() > 1]\n",
    "    matriz = df_real[cols_num].corr()\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(8.5, 6.5))\n",
    "    sns.heatmap(matriz, annot=True, cmap=\"coolwarm\", fmt=\".2f\",\n",
    "                linewidths=0.6, center=0, vmin=-1, vmax=1,\n",
    "                cbar_kws={\"label\": \"Correlación\"}, ax=ax)\n",
    "    ax.set_title(\"¿Qué atributos se mueven junto con el precio?\")\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    if \"Precio_Millones\" in matriz.columns:\n",
    "        corr_precio = (matriz[\"Precio_Millones\"].drop(\"Precio_Millones\")\n",
    "                       .sort_values(ascending=False))\n",
    "        print(\"  📌 Correlación de cada atributo con el PRECIO TOTAL:\\n\")\n",
    "        for var, val in corr_precio.items():\n",
    "            if abs(val) >= 0.7:   fuerza = \"🔴 MUY FUERTE\"\n",
    "            elif abs(val) >= 0.4: fuerza = \"🟠 MODERADA  \"\n",
    "            elif abs(val) >= 0.2: fuerza = \"🟡 DÉBIL     \"\n",
    "            else:                 fuerza = \"⚪ CASI NULA \"\n",
    "            print(f\"     {fuerza}  {var:<20} {val:+.2f}\")\n",
    "        print(\"\\n  🧠 Recuerda: esto muestra ASOCIACIÓN, no causa. El área probablemente\")\n",
    "        print(\"     explica buena parte de lo que parecen aportar habitaciones y baños.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c44888720f64"
   },
   "source": [
    "## ⏸️ Pausa: ¿qué acabamos de hacer, realmente?\n",
    "\n",
    "Cuatro gráficos. Ninguno fue difícil de programar — son entre 5 y 15 líneas de código que puedes copiar.\n",
    "\n",
    "**Lo difícil fue otra cosa:**\n",
    "\n",
    "- Decidir que el **valor por m²** era la métrica que permitía comparar.\n",
    "- Notar que el **promedio mentía** por culpa de los atípicos.\n",
    "- Elegir el **gráfico correcto** para cada pregunta.\n",
    "- Reconocer que la **correlación no prueba causalidad**.\n",
    "- Saber que un promedio de 2 datos **no es una conclusión**.\n",
    "\n",
    "> Ninguna de esas cinco decisiones las tomó Python. **Las tomaste tú.**\n",
    ">\n",
    "> Un modelo de lenguaje puede escribirte el código de los cuatro gráficos en 20 segundos. Lo que no puede hacer —todavía, y no por mucho tiempo— es **responder por la decisión**. Esa firma sigue siendo tuya, y por eso el criterio se paga.\n",
    "\n",
    "Ahora vamos a lo que define a un ingeniero industrial: **usar todo esto para decidir con recursos limitados y bajo incertidumbre**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d3232e1986ae"
   },
   "source": [
    "---\n",
    "# 🏭 BLOQUE 9 — De los datos a la decisión: simulación y sensibilidad\n",
    "\n",
    "## ⚙️ Bloque central para Introducción a la Ingeniería Industrial\n",
    "\n",
    "Hasta aquí describimos el mercado. Ahora vamos a hacer lo que define a un ingeniero industrial: **usar el dato para decidir con recursos limitados y bajo incertidumbre**.\n",
    "\n",
    "## El modelo, en lenguaje de negocio\n",
    "\n",
    "$$\\text{Utilidad} = (\\text{Precio de venta} - \\text{Costo}) \\times \\text{Unidades} - \\text{Costos fijos}$$\n",
    "\n",
    "Nada sofisticado. Lo poderoso está en **de dónde sale cada número**:\n",
    "\n",
    "| Variable | De dónde viene | Nivel de confianza |\n",
    "|---|---|---|\n",
    "| **Precio de venta** | 📊 Del mercado real que acabamos de medir | Alta |\n",
    "| **Costo por m²** | 🏗️ De tu operación (supuesto declarado) | Media |\n",
    "| **Unidades** | 🏗️ De tu capacidad instalada | Alta |\n",
    "| **Costos fijos** | 🏗️ De tu estructura | Media |\n",
    "\n",
    "> 🧠 **El aporte de los datos no es \"hacer la cuenta\" — eso lo hace Excel.**\n",
    "> El aporte es que **el precio de venta ya no es un deseo**: es el percentil real de un mercado que observamos. Ahí está toda la diferencia entre un modelo financiero y una ilusión con decimales.\n",
    "\n",
    "## Dos conceptos que valen la carrera\n",
    "\n",
    "**1. Punto de equilibrio:** cuántas unidades tienes que vender para no perder plata. Debajo de eso, cada día de operación te cuesta.\n",
    "\n",
    "**2. Análisis de sensibilidad:** *¿qué pasa si me equivoqué?* Ningún supuesto es exacto. Un buen ingeniero no entrega un número: entrega **un rango y las condiciones bajo las cuales el negocio deja de funcionar**.\n",
    "\n",
    "> El gerente no te va a preguntar *\"¿cuánto da?\"*. Te va a preguntar *\"¿y si el costo sube 15%?\"*. **Llegar con esa respuesta ya calculada es lo que te convierte en indispensable.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "b8cc250ce9d4"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 9.0 — 👤 SUPUESTOS DE LA EMPRESA  (¡EDITA ESTOS NÚMEROS!)\n",
    "# Todo modelo de decisión descansa sobre supuestos. La diferencia entre un\n",
    "# modelo serio y una ilusión con decimales es que el serio los DECLARA.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "MI_EMPRESA = {\n",
    "    \"nombre\":                  \"Constructora Nueva S.A.S.\",\n",
    "    \"costo_construccion_m2\":   4.2,     # millones COP por m² construido (incluye tierra prorrateada)\n",
    "    \"capital_disponible\":      16000,   # millones COP para el primer proyecto\n",
    "    \"capacidad_anual_unidades\": 60,     # unidades que puedo construir y entregar al año\n",
    "}\n",
    "\n",
    "print(\"🏢 Supuestos declarados para:\", MI_EMPRESA[\"nombre\"])\n",
    "print(\"─\" * 62)\n",
    "print(f\"  Costo de construcción ... ${MI_EMPRESA['costo_construccion_m2']:.2f} M/m²\")\n",
    "print(f\"  Capital disponible ...... ${MI_EMPRESA['capital_disponible']:,} millones\")\n",
    "print(f\"  Capacidad anual ......... {MI_EMPRESA['capacidad_anual_unidades']} unidades\")\n",
    "print(\"─\" * 62)\n",
    "print(\"\\n💡 Cambia estos valores y vuelve a ejecutar las celdas 9.1 y 9.2.\")\n",
    "print(\"   Observar cómo se mueve la conclusión al mover un supuesto ES el ejercicio.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "b9e56186b753"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 9.1 — 🎛️ SIMULADOR DE PROYECTO  (¡EDITA EL ESCENARIO!)\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "ESCENARIO = {\n",
    "    \"area_unidad\":       62,     # m² por unidad a construir\n",
    "    \"habitaciones\":      2,\n",
    "    \"banos\":             2,\n",
    "    \"unidades\":          48,     # unidades del proyecto\n",
    "    \"costo_m2\":          MI_EMPRESA[\"costo_construccion_m2\"],   # millones COP / m²\n",
    "    \"costos_fijos\":      2600,   # millones COP: licencias, diseño, administración, ventas\n",
    "    \"percentil_precio\":  0.50,   # 0.50 = vender al precio mediano del mercado\n",
    "                                 # 0.25 = estrategia agresiva · 0.75 = posicionamiento premium\n",
    "    \"comision_venta\":    0.03,   # 3% sobre ingresos\n",
    "}\n",
    "\n",
    "\n",
    "def simular_proyecto(df_mercado, esc, verbose=True):\n",
    "    \"\"\"Calcula la viabilidad económica de un proyecto usando precios reales del mercado.\"\"\"\n",
    "    # ── Precio de referencia: mercado comparable, no invento ─────────────────\n",
    "    tolerancia = 0.30\n",
    "    comparables = df_mercado[\n",
    "        df_mercado[\"Area_m2\"].between(esc[\"area_unidad\"] * (1 - tolerancia),\n",
    "                                      esc[\"area_unidad\"] * (1 + tolerancia))\n",
    "    ]\n",
    "    if len(comparables) < 5:\n",
    "        comparables = df_mercado     # blindaje: si no hay comparables, usamos todo el mercado\n",
    "        nota = \"⚠️  Pocos comparables por área: se usó el mercado completo como referencia.\"\n",
    "    else:\n",
    "        nota = f\"✅ Referencia construida con {len(comparables)} inmuebles comparables.\"\n",
    "\n",
    "    vm2_ref   = comparables[\"Valor_m2_Millones\"].quantile(esc[\"percentil_precio\"])\n",
    "    precio_u  = vm2_ref * esc[\"area_unidad\"]\n",
    "    costo_u   = esc[\"costo_m2\"] * esc[\"area_unidad\"]\n",
    "\n",
    "    ingresos  = precio_u * esc[\"unidades\"]\n",
    "    comision  = ingresos * esc[\"comision_venta\"]\n",
    "    costo_var = costo_u * esc[\"unidades\"]\n",
    "    utilidad  = ingresos - comision - costo_var - esc[\"costos_fijos\"]\n",
    "    margen    = utilidad / ingresos if ingresos else 0\n",
    "\n",
    "    contrib_u = precio_u * (1 - esc[\"comision_venta\"]) - costo_u\n",
    "    pe_unid   = esc[\"costos_fijos\"] / contrib_u if contrib_u > 0 else float(\"inf\")\n",
    "    pe_pct    = pe_unid / esc[\"unidades\"] if esc[\"unidades\"] else float(\"inf\")\n",
    "\n",
    "    r = {\"vm2_ref\": vm2_ref, \"precio_u\": precio_u, \"costo_u\": costo_u,\n",
    "         \"ingresos\": ingresos, \"comision\": comision, \"costo_var\": costo_var,\n",
    "         \"utilidad\": utilidad, \"margen\": margen, \"contrib_u\": contrib_u,\n",
    "         \"pe_unid\": pe_unid, \"pe_pct\": pe_pct, \"n_comparables\": len(comparables), \"nota\": nota}\n",
    "\n",
    "    if verbose:\n",
    "        print(\"═\" * 70)\n",
    "        print(f\"  SIMULACIÓN DE PROYECTO — {MI_EMPRESA['nombre']}\")\n",
    "        print(\"═\" * 70)\n",
    "        print(f\"  {nota}\")\n",
    "        print(f\"  Producto: {esc['unidades']} unidades de {esc['area_unidad']} m² \"\n",
    "              f\"({esc['habitaciones']}H / {esc['banos']}B)\")\n",
    "        print(\"─\" * 70)\n",
    "        print(f\"  Precio de referencia (percentil {esc['percentil_precio']:.0%}) .. ${vm2_ref:>8.2f} M/m²\")\n",
    "        print(f\"  Precio de venta por unidad ..................... ${precio_u:>8.1f} M\")\n",
    "        print(f\"  Costo de construcción por unidad ............... ${costo_u:>8.1f} M\")\n",
    "        print(f\"  Margen de contribución por unidad .............. ${contrib_u:>8.1f} M\")\n",
    "        print(\"─\" * 70)\n",
    "        print(f\"  Ingresos totales ............................... ${ingresos:>10,.0f} M\")\n",
    "        print(f\"  (−) Comisión de ventas ......................... ${comision:>10,.0f} M\")\n",
    "        print(f\"  (−) Costo de construcción ...................... ${costo_var:>10,.0f} M\")\n",
    "        print(f\"  (−) Costos fijos del proyecto .................. ${esc['costos_fijos']:>10,.0f} M\")\n",
    "        print(\"  \" + \"─\" * 66)\n",
    "        print(f\"  = UTILIDAD DEL PROYECTO ........................ ${utilidad:>10,.0f} M\")\n",
    "        print(f\"    Margen sobre ingresos ........................ {margen:>10.1%}\")\n",
    "        print(\"─\" * 70)\n",
    "        if pe_unid == float(\"inf\"):\n",
    "            print(\"  ⛔ PUNTO DE EQUILIBRIO: INALCANZABLE.\")\n",
    "            print(\"     El precio de venta no cubre el costo variable. El negocio pierde\")\n",
    "            print(\"     dinero en CADA unidad vendida: vender más empeora el resultado.\")\n",
    "        else:\n",
    "            print(f\"  🎯 Punto de equilibrio ......................... {pe_unid:>8.1f} unidades \"\n",
    "                  f\"({pe_pct:.0%} del proyecto)\")\n",
    "            if   pe_pct <= 0.50: print(\"     🟢 Holgado: el proyecto resiste una venta lenta.\")\n",
    "            elif pe_pct <= 0.75: print(\"     🟡 Ajustado: exige un ritmo de ventas sostenido.\")\n",
    "            elif pe_pct <= 1.00: print(\"     🔴 Crítico: hay que vender casi todo para no perder.\")\n",
    "            else:                print(\"     ⛔ Inviable: ni vendiendo el 100% se alcanza el equilibrio.\")\n",
    "        print(f\"\\n  Capital requerido estimado ..................... ${costo_var + esc['costos_fijos']:>10,.0f} M\")\n",
    "        disp = MI_EMPRESA[\"capital_disponible\"]\n",
    "        req  = costo_var + esc[\"costos_fijos\"]\n",
    "        print(f\"  Capital disponible ............................. ${disp:>10,.0f} M\")\n",
    "        print(f\"  {'✅ Capital suficiente.' if disp >= req else '⚠️  Faltan $' + format(req - disp, ',.0f') + ' M: requiere preventa, crédito o socio.'}\")\n",
    "        print(\"═\" * 70)\n",
    "    return r\n",
    "\n",
    "\n",
    "if DATOS_OK:\n",
    "    resultado = simular_proyecto(df_real, ESCENARIO)\n",
    "else:\n",
    "    resultado = None\n",
    "    print(\"⚠️  Sin datos válidos no se puede simular.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "19cf99790153"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 9.2 — ANÁLISIS DE SENSIBILIDAD\n",
    "# ¿Qué tan frágil es la decisión? Movemos costo y precio y vemos qué sobrevive.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if DATOS_OK and resultado is not None:\n",
    "    variacion_costo  = [-0.15, -0.075, 0.0, 0.075, 0.15, 0.225]   # ± sobre el costo por m²\n",
    "    percentiles      = [0.25, 0.40, 0.50, 0.60, 0.75]             # posicionamiento de precio\n",
    "\n",
    "    matriz_util, matriz_marg = [], []\n",
    "    for vc in variacion_costo:\n",
    "        fila_u, fila_m = [], []\n",
    "        for pc in percentiles:\n",
    "            esc = dict(ESCENARIO)\n",
    "            esc[\"costo_m2\"] = ESCENARIO[\"costo_m2\"] * (1 + vc)\n",
    "            esc[\"percentil_precio\"] = pc\n",
    "            r = simular_proyecto(df_real, esc, verbose=False)\n",
    "            fila_u.append(r[\"utilidad\"])\n",
    "            fila_m.append(r[\"margen\"] * 100)\n",
    "        matriz_util.append(fila_u)\n",
    "        matriz_marg.append(fila_m)\n",
    "\n",
    "    idx  = [f\"{v:+.1%} costo\" for v in variacion_costo]\n",
    "    cols = [f\"P{int(p*100)} precio\" for p in percentiles]\n",
    "    tabla_util = pd.DataFrame(matriz_util, index=idx, columns=cols).round(0)\n",
    "    tabla_marg = pd.DataFrame(matriz_marg, index=idx, columns=cols).round(1)\n",
    "\n",
    "    if ESTADO_ENTORNO.get(\"graficos\"):\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(15, 5.5))\n",
    "        sns.heatmap(tabla_util, annot=True, fmt=\".0f\", cmap=\"RdYlGn\", center=0,\n",
    "                    linewidths=0.6, ax=axes[0], cbar_kws={\"label\": \"Millones COP\"})\n",
    "        axes[0].set_title(\"Utilidad del proyecto (millones COP)\")\n",
    "        sns.heatmap(tabla_marg, annot=True, fmt=\".1f\", cmap=\"RdYlGn\", center=0,\n",
    "                    linewidths=0.6, ax=axes[1], cbar_kws={\"label\": \"%\"})\n",
    "        axes[1].set_title(\"Margen sobre ingresos (%)\")\n",
    "        for a in axes:\n",
    "            a.set_xlabel(\"Posicionamiento de precio (percentil del mercado)\")\n",
    "            a.set_ylabel(\"Variación del costo de construcción\")\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "    total = tabla_util.size\n",
    "    positivos = int((tabla_util > 0).sum().sum())\n",
    "    print(\"═\" * 70)\n",
    "    print(\"  LECTURA DEL ANÁLISIS DE SENSIBILIDAD\")\n",
    "    print(\"═\" * 70)\n",
    "    print(f\"  Escenarios evaluados ............. {total}\")\n",
    "    print(f\"  Escenarios con utilidad positiva . {positivos} ({100*positivos/total:.0f}%)\")\n",
    "    print(\"─\" * 70)\n",
    "    if positivos == total:\n",
    "        print(\"  🟢 ROBUSTO: el proyecto es rentable en TODOS los escenarios probados.\")\n",
    "        print(\"     La decisión no depende de acertarle al supuesto.\")\n",
    "    elif positivos >= total * 0.6:\n",
    "        print(\"  🟡 CONDICIONADO: rentable en la mayoría de escenarios, pero no en todos.\")\n",
    "        print(\"     Identifica cuál es tu supuesto crítico y monitorearlo se vuelve obligatorio.\")\n",
    "    elif positivos > 0:\n",
    "        print(\"  🔴 FRÁGIL: solo funciona en escenarios favorables.\")\n",
    "        print(\"     Estás apostando a que todo salga bien. Eso no es una estrategia.\")\n",
    "    else:\n",
    "        print(\"  ⛔ INVIABLE: no hay escenario rentable con estos supuestos.\")\n",
    "        print(\"     Cambia el producto, el segmento o la estructura de costos.\")\n",
    "    print(\"═\" * 70)\n",
    "    print(\"\\n  🧠 La pregunta profesional no es «¿cuánto da?» sino:\")\n",
    "    print(\"     «¿bajo qué condiciones esta decisión deja de funcionar?»\")\n",
    "    print(\"     Esa tabla es tu respuesta, y es lo que un comité directivo espera ver.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1319071cea2b"
   },
   "source": [
    "### 🗣️ Actividad de cierre para Ingeniería Industrial (15 minutos)\n",
    "\n",
    "Trabajen en `ESCENARIO` y respondan con evidencia:\n",
    "\n",
    "1. **Encuentren el producto óptimo.** Prueben distintas combinaciones de `area_unidad` y `percentil_precio`. ¿Cuál maximiza la utilidad sin exceder el capital disponible?\n",
    "2. **Encuentren el punto de quiebre.** ¿Cuánto puede subir el costo por m² antes de que el proyecto deje de ser viable? Ese número tiene nombre en la industria: **margen de seguridad**.\n",
    "3. **Decidan y justifiquen.** ¿Prefieren 48 unidades al percentil 40 (venta rápida, margen bajo) o 30 unidades al percentil 75 (venta lenta, margen alto)? **¿Qué información NO tienen y necesitarían para decidir bien?**\n",
    "\n",
    "> 💡 **La pregunta 3 es la más importante de todo el notebook.**\n",
    "> Reconocer lo que no sabes —la velocidad de absorción del mercado, el costo financiero del inventario, el ciclo de ventas— es más valioso que cualquier cálculo. **Un analista que sabe qué le falta es confiable. Uno que cree tenerlo todo es peligroso.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c3340ace64e2"
   },
   "source": [
    "---\n",
    "# 🎓 BLOQUE 10 — Cierre: qué te llevas de esta clase\n",
    "\n",
    "## Lo que hicimos, en una línea\n",
    "\n",
    "Convertimos **una página web pública** en una **decisión de inversión sustentada**, recorriendo la cadena completa: extracción → calidad → limpieza → indicadores → visualización → simulación → sensibilidad.\n",
    "\n",
    "```\n",
    "Dato crudo  →  Dato limpio  →  Información  →  Conocimiento  →  DECISIÓN\n",
    " (Bloque 2)     (Bloques 3-4)   (Bloques 5-6)   (Bloque 8)      (Bloque 9)\n",
    "```\n",
    "\n",
    "**Cada flecha destruye valor si el paso anterior estaba mal.** Por eso el bloque de calidad no era un trámite: era el cimiento.\n",
    "\n",
    "---\n",
    "\n",
    "## 🔨 Volvamos al principio: Python es el martillo, no la casa\n",
    "\n",
    "| El computador hizo | **Tú hiciste** |\n",
    "|---|---|\n",
    "| Leer 400 registros | Decidir qué medir y por qué |\n",
    "| Convertir textos en números | Decidir que un vacío honesto vale más que un cero falso |\n",
    "| Calcular promedios | **Notar que el promedio mentía** |\n",
    "| Marcar los atípicos | Decidir si eran ruido, error u oportunidad |\n",
    "| Cruzar habitaciones y baños | Entender que 2 observaciones no son evidencia |\n",
    "| Calcular la utilidad | **Preguntar qué pasa si el supuesto falla** |\n",
    "\n",
    "> La columna de la izquierda se automatiza. **La columna de la derecha es tu carrera.**\n",
    "\n",
    "Y sin embargo — y esto no es contradictorio — **te conviene muchísimo dominar la izquierda**:\n",
    "\n",
    "- **Quien no entiende la herramienta no puede auditarla.** Un dashboard bonito con una métrica mal construida es más peligroso que no tener dashboard.\n",
    "- **La velocidad es una ventaja real.** Responder una pregunta de negocio en 20 minutos en vez de 3 días cambia tu lugar en la organización.\n",
    "- **Preguntas mejor.** Cuando sabes qué es posible, dejas de pedir reportes y empiezas a pedir respuestas.\n",
    "\n",
    "---\n",
    "\n",
    "## 🗺️ Ruta sugerida para dominar Python (30 min al día, 8 semanas)\n",
    "\n",
    "| Semanas | Enfócate en | Meta concreta |\n",
    "|---|---|---|\n",
    "| **1-2** | Fundamentos: variables, listas, condicionales, ciclos, funciones | Escribir una función que resuelva algo tuyo |\n",
    "| **3-4** | **Pandas**: leer, filtrar, agrupar, unir tablas | Analizar un Excel real de tu carrera o trabajo |\n",
    "| **5-6** | Visualización: Matplotlib y Seaborn | Reemplazar un informe manual por uno automático |\n",
    "| **7-8** | Automatización: leer archivos, generar reportes, programar tareas | Automatizar algo que hoy haces a mano cada semana |\n",
    "\n",
    "**Recursos gratuitos:** *Python for Everybody* (Universidad de Michigan), `10 minutes to pandas` de la documentación oficial, Kaggle Learn, y este mismo notebook — modifícalo, rómpelo y arréglalo.\n",
    "\n",
    "> ⚡ **El único consejo que de verdad importa:** no aprendas Python \"en general\". Escoge **un problema tuyo, real y molesto** —una consolidación que haces a mano, un informe repetitivo— y resuélvelo con Python. Aprender sin un problema propio se abandona en la semana tres. Con un problema propio, no se abandona.\n",
    "\n",
    "---\n",
    "\n",
    "## ✅ Checklist: lo que deberías poder hacer al salir de aquí\n",
    "\n",
    "- [ ] Explicar por qué un dato de **oferta** no es un dato de **transacción**, y qué decisiones cambia esa diferencia\n",
    "- [ ] Auditar la calidad de una base antes de usarla (completitud, unicidad, validez, consistencia)\n",
    "- [ ] Verificar la **trazabilidad** de un dato hasta su fuente original\n",
    "- [ ] Justificar por qué un **valor nulo** es mejor que un **cero inventado**\n",
    "- [ ] Construir un **indicador** comparable a partir de variables crudas\n",
    "- [ ] Aplicar el criterio **IQR** y decidir si un atípico es ruido, error u oportunidad\n",
    "- [ ] Entregar una **tabla plana con diccionario de datos** lista para Excel o Power BI\n",
    "- [ ] Elegir el **gráfico correcto** para cada tipo de pregunta\n",
    "- [ ] Distinguir **correlación** de **causalidad** y decir por qué importa en plata\n",
    "- [ ] Calcular un **punto de equilibrio** y un **análisis de sensibilidad**\n",
    "- [ ] Nombrar **qué información te falta** para decidir mejor\n",
    "\n",
    "---\n",
    "\n",
    "## 🚀 Reto abierto\n",
    "\n",
    "Modifica `CONFIG[\"url_base\"]` y apunta el robot a otro mercado: **arriendo** en vez de venta, otra ciudad, otro tipo de inmueble.\n",
    "\n",
    "Y responde la pregunta que ningún gráfico de hoy contesta:\n",
    "\n",
    "> ### ¿Cuántos años tarda un inmueble en pagarse con su propio arriendo, y en qué zona de Bogotá ese número es menor?\n",
    "\n",
    "Necesitas cruzar dos mercados que analizamos por separado. **Ahí ya no estás haciendo un ejercicio de clase: estás haciendo investigación de mercado real.**\n",
    "\n",
    "Usa la celda de abajo. Está en blanco a propósito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "d97ad3dea8a4"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# 🚀 TU TURNO — Espacio de trabajo libre\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "#\n",
    "# Pistas para arrancar:\n",
    "#\n",
    "#   1. Cambia CONFIG[\"url_base\"] a la sección de arriendos y vuelve a ejecutar\n",
    "#      las celdas 2.4 → 5.1. Guarda el resultado con otro nombre:\n",
    "#         df_arriendo = df_estrategico.copy()\n",
    "#\n",
    "#   2. Calcula el canon promedio por m² por localidad:\n",
    "#         canon = df_arriendo.groupby(\"Localidad\")[\"Valor_m2_Millones\"].mean()\n",
    "#\n",
    "#   3. Crúzalo con el valor de venta por m² por localidad y calcula:\n",
    "#         años_de_retorno = valor_venta_m2 / (canon_m2 * 12)\n",
    "#\n",
    "#   4. Grafícalo y responde: ¿dónde conviene invertir?\n",
    "#\n",
    "#   Y la pregunta que separa al analista del profesional:\n",
    "#   ¿qué costos NO estás considerando en ese cálculo?\n",
    "#   (administración, predial, vacancia, mantenimiento, valorización, impuestos...)\n",
    "#\n",
    "# ══════════════════════════════════════════════════════════════════════════════"
   ]
  }
 ]
}