{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true,
   "name": "Estrategia_Organizacional_DOFA_VRIO_con_datos.ipynb"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5194f31bd075"
   },
   "source": [
    "# 🎯 Estrategia desde los datos\n",
    "## DOFA y VRIO aplicados al mercado inmobiliario de Bogotá\n",
    "\n",
    "**Estrategia Organizacional** · Universidad Jorge Tadeo Lozano · Prof. Elkin Rodríguez\n",
    "\n",
    "---\n",
    "\n",
    "### 📌 La situación\n",
    "\n",
    "> Somos el equipo directivo de una constructora nueva. Tenemos capital y queremos **entrar al mercado de construcción y venta de inmuebles en Bogotá**.\n",
    ">\n",
    "> No conocemos el mercado. Nadie nos va a regalar un estudio de $80 millones. Lo único que tenemos es **acceso a los datos públicos de la competencia** y la capacidad de leerlos bien.\n",
    ">\n",
    "> En las próximas tres horas vamos a pasar de *\"creo que\"* a *\"los datos muestran que\"*.\n",
    "\n",
    "---\n",
    "\n",
    "### 🧭 Lo que vamos a hacer distinto\n",
    "\n",
    "En casi todas las clases de estrategia, DOFA y VRIO se enseñan así: *\"DOFA es Debilidades, Oportunidades, Fortalezas y Amenazas\"*. Se llena una matriz en un taller, cada quien opina, y el documento termina en un cajón.\n",
    "\n",
    "**Hoy no vamos a hacer eso.** Vamos a construir un DOFA y un VRIO donde **cada casilla tiene una cifra detrás** que se puede auditar.\n",
    "\n",
    "| El DOFA de taller dice | El DOFA con datos dice |\n",
    "|---|---|\n",
    "| \"El mercado inmobiliario está creciendo\" | \"El segmento de 45-70 m² concentra el 12% de la oferta pero se transa 18% por encima del promedio; tiene 9 competidores directos frente a 47 en el familiar\" |\n",
    "| \"Tenemos buenos costos\" | \"Construimos a $4.20 M/m² frente a un precio mediano de mercado de $6.07 M/m²: 31% de margen bruto, que no aguanta un sobrecosto del 20%\" |\n",
    "| \"Nuestra ubicación es un recurso valioso\" | \"La zona donde tenemos tierra se transa +69% sobre el promedio y solo el 15% de la oferta compite ahí\" |\n",
    "\n",
    "**La primera columna se puede decir sin trabajar. La segunda mueve capital.**\n",
    "\n",
    "---\n",
    "\n",
    "### 🗺️ Ruta de la sesión (3 horas)\n",
    "\n",
    "| Bloque | Qué hacemos | Concepto de estrategia |\n",
    "|---|---|---|\n",
    "| **1-2** | Extraer datos reales de la competencia | Ventaja informacional |\n",
    "| **3-4** | Verificar y limpiar la evidencia | Trazabilidad del argumento |\n",
    "| **5-6** | Construir la métrica que permite comparar | Base de comparabilidad competitiva |\n",
    "| **7-8** | Leer el mercado en 8 mapas | Grupos estratégicos (Porter), océanos azules |\n",
    "| **9** | Construir el **DOFA con evidencia** | Diagnóstico y estrategias cruzadas |\n",
    "| **10** | Aplicar **VRIO** con señales de mercado | Ventaja competitiva sostenida |\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": "ed38c8b365bb"
   },
   "source": [
    "## ✋ Antes de la primera línea de código\n",
    "\n",
    "Al terminar esta sesión **no vas a saber programar en Python**. Y está bien: ese no es el objetivo de una clase de estrategia.\n",
    "\n",
    "Lo que sí te vas a llevar es algo más difícil de conseguir y mucho más difícil de reemplazar:\n",
    "\n",
    "> **El criterio para hacerle al mercado las preguntas que valen dinero.**\n",
    "\n",
    "| Lo que hace la máquina | Lo que hace el estratega |\n",
    "|---|---|\n",
    "| Extraer 400 avisos de la competencia en 3 minutos | Decidir **qué mercado** vale la pena observar |\n",
    "| Calcular el precio promedio por m² | Entender que ese promedio **esconde dos mercados distintos** |\n",
    "| Dibujar el mapa de posicionamiento | Ver un espacio vacío y preguntar **por qué nadie está ahí** |\n",
    "| Llenar las cuatro casillas del DOFA | Decidir **cuál de esos hallazgos merece capital** |\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é meterse con Python?\n",
    "\n",
    "Porque **quien no entiende la herramienta no puede exigirle nada**. Un directivo que no sabe qué se puede pedir con datos:\n",
    "\n",
    "- Acepta como verdad el primer gráfico bonito que le presentan.\n",
    "- No detecta cuando el indicador está mal construido.\n",
    "- Pide reportes que ya no sirven cuando llegan.\n",
    "- Depende de un tercero para cada pregunta nueva del negocio.\n",
    "\n",
    "Python no te vuelve programador. Te vuelve **un directivo que puede verificar, cuestionar y pedir mejor**. Y en una sala de junta, esa capacidad se nota en 30 segundos.\n",
    "\n",
    "> 💡 Si te interesa, al final de la sesión encontrarás una ruta concreta para dominarlo. No hace falta para esta clase, pero cambia el techo de tu carrera.\n",
    "\n",
    "**Ahora sí. Vamos a mirar el mercado.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a57add43baff"
   },
   "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",
    "Piénsalo como el alistamiento previo a cualquier operación: antes de salir a campo hay que verificar que el equipo funcione. Aquí es lo mismo, y toma tres minutos.\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 mapas competitivos |\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": "d1ec4c4961be"
   },
   "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": "0b13bf9c3775"
   },
   "source": [
    "---\n",
    "# 🕸️ BLOQUE 2 — Extracción: mirar el tablero completo\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 abrir el portal inmobiliario, bajar la página para que carguen los avisos, leer cada tarjeta (título, precio, ubicación, habitaciones, baños, área y **el enlace del aviso**) y guardarlo todo en una tabla.\n",
    "\n",
    "## 🎯 Por qué esto es estrategia, no informática\n",
    "\n",
    "En estrategia competitiva, la **asimetría de información** es una fuente real de ventaja.\n",
    "\n",
    "Mientras un competidor fija precios con la intuición de su gerente comercial, tú los fijas con 400 observaciones del mercado tomadas esta mañana.\n",
    "\n",
    "> No es que tú seas más inteligente. Es que **tú ves el tablero y él ve solo su ficha.**\n",
    "\n",
    "Esto es exactamente lo que Porter llamaría **inteligencia competitiva**: el proceso sistemático de observar a los rivales para anticipar sus movimientos y encontrar espacios sin atender.\n",
    "\n",
    "## ⚠️ Los cuatro límites de tu evidencia\n",
    "\n",
    "Antes de usar cualquier dato para decidir, un estratega serio pregunta:\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 sobre planos sin publicar, estrato, antigüedad, tiempo de venta |\n",
    "\n",
    "> 🧠 **Esa última fila es la que separa un análisis competitivo de una ilusión.**\n",
    "> El error más costoso en estrategia no es calcular mal: es **olvidar qué no está en los datos** y decidir como si el dataset fuera el mercado entero. Los precios de oferta te dicen qué *pide* la competencia, no qué *logra*. Tenlo presente en cada conclusión de hoy.\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": "da73b78d584e"
   },
   "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": "244bc688be87"
   },
   "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": "65610604ad3f"
   },
   "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": "6ea1fde99b5e"
   },
   "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": "7b0aa20316cc"
   },
   "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": "300fd96128ff"
   },
   "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": "9d00a836c9ae"
   },
   "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": "34d14ddfb95c"
   },
   "source": [
    "---\n",
    "# 🔬 BLOQUE 3 — Auditar la evidencia antes de argumentar\n",
    "\n",
    "## Tres minutos que salvan una decisión de millones\n",
    "\n",
    "Ningún estratega debería construir un argumento sobre datos que no revisó. No hace falta ser analista: basta con hacer **cuatro preguntas** a cualquier base antes de usarla.\n",
    "\n",
    "| Pregunta | Qué revela |\n",
    "|---|---|\n",
    "| **¿Faltan datos?** | Si el 30% de los avisos no tiene precio, tu \"precio de mercado\" describe solo al 70% |\n",
    "| **¿Hay repetidos?** | Un mismo inmueble publicado 3 veces infla la percepción de competencia |\n",
    "| **¿El formato es válido?** | *\"Precio a convenir\"* no es un precio |\n",
    "| **¿Se contradicen?** | Un apartamento de 30 m² con 5 habitaciones es un error, no un producto |\n",
    "\n",
    "La siguiente celda responde las cuatro automáticamente.\n",
    "\n",
    "> 🎯 **Y aquí hay un hallazgo estratégico escondido:**\n",
    "> Si una parte de la competencia **decide no publicar el precio**, eso también es un dato. Habla de la opacidad del mercado — y **la opacidad crea una oportunidad para quien decide ser transparente**. Muchos modelos de negocio disruptivos nacieron exactamente ahí.\n",
    "\n",
    "> 💰 **La regla 1-10-100:** prevenir un error de datos cuesta $1, corregirlo después cuesta $10, y las consecuencias de no corregirlo cuestan $100. En nuestro caso, ese $100 es un proyecto inmobiliario completo construido en el segmento equivocado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "226038fe9777"
   },
   "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": "b4b693653713"
   },
   "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 tuvieras que **eliminar toda fila incompleta**, ¿cuántos datos perderías? ¿Vale la pena?\n",
    "3. Un aviso sin precio, ¿es un error del portal o **información en sí misma**? (Pista: \"Precio a convenir\" dice algo sobre el vendedor.)\n",
    "\n",
    "> 🎯 **Para Estrategia:** ese último punto es clave. En análisis competitivo, **lo que el competidor decide NO publicar también es un dato**. Si el 15% de los avisos oculta el precio, eso te habla de la opacidad del mercado — y la opacidad crea oportunidades para quien sí es transparente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "24d1212aa79d"
   },
   "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": "0c8adf7969ac"
   },
   "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": "d74533f32a9a"
   },
   "source": [
    "---\n",
    "# 📐 BLOQUE 5 — La métrica que permite comparar\n",
    "\n",
    "## El salto que separa una opinión de un análisis\n",
    "\n",
    "Tenemos precio. Tenemos área. Por separado, **ninguno sirve para competir**.\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**. Ahora un penthouse de Usaquén y un apartaestudio de Bosa juegan en la misma cancha, y por primera vez podemos preguntar quién cobra más y por qué.\n",
    "\n",
    "## 🎯 Por qué esto es estrategia pura\n",
    "\n",
    "Toda estrategia competitiva descansa sobre una **base de comparación**. Sin ella no puedes afirmar que eres más barato, más premium o más eficiente que nadie: solo puedes creerlo.\n",
    "\n",
    "El valor por m² será nuestra **métrica reina** durante toda la sesión. Con ella responderemos la pregunta que vale el proyecto:\n",
    "\n",
    "> ### ¿En qué segmento del mercado bogotano se paga más por metro construido, y qué tan disputado está ese segmento?\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 empresas ignoran. Un indicador que se puede maquillar **se maquilla**, y entonces mide política interna en vez de realidad de mercado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ac4270dee22a"
   },
   "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": "f4b218cc4dde"
   },
   "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": "2cbf6342e6d2"
   },
   "source": [
    "---\n",
    "# 🎯 BLOQUE 6 — Depurar el ruido: outliers\n",
    "\n",
    "## ¿Qué es un valor atípico (*outlier*)?\n",
    "\n",
    "Es una observación tan alejada del resto que **distorsiona cualquier cálculo**. En nuestro caso: la mansión de $12.000 millones en la misma tabla que el apartaestudio de $130 millones.\n",
    "\n",
    "## La pregunta que casi nadie se hace: ¿se eliminan o no?\n",
    "\n",
    "**Depende de la pregunta que estés respondiendo.** Y esta decisión es tuya, no del algoritmo:\n",
    "\n",
    "| Si tu pregunta es... | Entonces el outlier es... |\n",
    "|---|---|\n",
    "| \"¿Cuánto vale el m² del mercado masivo?\" | **Ruido** → elimínalo |\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",
    "> 🎯 **Para Estrategia — retén esto:** en análisis competitivo, **el outlier suele ser la oportunidad**. El competidor que hace algo radicalmente distinto y le funciona es, por definición, un dato atípico. Si tu proceso analítico borra automáticamente lo raro, **borras el hallazgo antes de verlo**.\n",
    "\n",
    "## El método: rango intercuartílico (IQR)\n",
    "\n",
    "Es el criterio estadístico estándar y es simple:\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 del mercado)\n",
    "4. **Es atípico todo lo que esté fuera de** `[Q1 − 1.5·IQR , Q3 + 1.5·IQR]`\n",
    "\n",
    "Aquí **no borramos nada**: marcamos. Creamos dos vistas del mismo mercado y trabajamos con la que corresponda a cada pregunta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "97c5208615b2"
   },
   "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": "48e2ffaecd9e"
   },
   "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": "4d0062c3a866"
   },
   "source": [
    "---\n",
    "# 💾 BLOQUE 7 — Guardar la evidencia\n",
    "\n",
    "Antes de pasar al análisis, guardamos la base. No es un trámite: **un argumento estratégico que no se puede reproducir no se puede defender en un comité**.\n",
    "\n",
    "La siguiente celda genera dos archivos:\n",
    "\n",
    "- **`02_base_analitica.csv`** — la base limpia, una fila por inmueble, con el enlace de cada aviso.\n",
    "- **`03_mercado_inmobiliario_bogota.xlsx`** — el mismo dato en Excel, con hojas de resumen por segmento y por localidad, más una **ficha técnica** que deja constancia de la fuente, la fecha y la advertencia de que son precios de oferta.\n",
    "\n",
    "> 📌 Esa ficha técnica es lo que convierte un archivo en un documento defendible. Cuando alguien te pregunte dentro de seis meses de dónde salió el número, la respuesta está adentro del archivo — no en tu memoria.\n",
    "\n",
    "**Para descargarlos:** panel izquierdo → ícono de carpeta 📁 → clic derecho sobre el archivo → Descargar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "05d66aaf1562"
   },
   "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",
    "\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": "markdown",
   "metadata": {
    "id": "41ac1350df10"
   },
   "source": [
    "---\n",
    "# 📊 BLOQUE 8 — Leer el mercado: ocho mapas competitivos\n",
    "\n",
    "## Una regla antes de mirar el primer gráfico\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 presentación al comité. Por eso cada visualización viene con tres cosas:\n",
    "\n",
    "- **La pregunta** que responde\n",
    "- **Qué mirar** exactamente\n",
    "- **Qué decisión** habilita\n",
    "\n",
    "## 🎯 Lo que vamos a construir\n",
    "\n",
    "Estos ocho mapas son, en conjunto, un **análisis de la estructura competitiva** del mercado inmobiliario bogotano:\n",
    "\n",
    "| # | Mapa | Concepto de estrategia |\n",
    "|---|---|---|\n",
    "| 1 | Posicionamiento (área vs. precio) | Espacio competitivo y huecos de mercado |\n",
    "| 2 | Distribución del valor/m² | ¿Costos o diferenciación? (Porter) |\n",
    "| 3 | Portafolio por tipología | Decisión de mezcla de producto |\n",
    "| 4 | Correlación de atributos | Qué paga realmente el cliente |\n",
    "| 5 | Grupos estratégicos | Rivalidad por cuadrante |\n",
    "| 6 | Densidad de competencia | Océano rojo vs. océano azul |\n",
    "| 7 | Matriz habitaciones × baños | Diseño de producto y valor |\n",
    "| 8 | Perfil de diferenciación | Capacidad de cobrar precio premium |\n",
    "\n",
    "Al final de este bloque tendrás la materia prima para el DOFA. **No pases al bloque 9 sin haber discutido estos ocho.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "e12572a03910"
   },
   "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": "2a4e2b657272"
   },
   "source": [
    "### 📍 Gráfico 1 — Mapa de posicionamiento competitivo\n",
    "\n",
    "**La pregunta:** ¿cómo está repartida la competencia entre tamaño y precio?\n",
    "\n",
    "**Qué mirar:**\n",
    "- La **nube principal**: ahí está el mercado masivo, donde todos compiten.\n",
    "- Los **espacios vacíos**: combinaciones de área y precio que nadie está ofreciendo.\n",
    "- El **color** (habitaciones) y el **tamaño del punto** (valor del m²).\n",
    "\n",
    "**La decisión que habilita:** dónde ubicar tu primer proyecto.\n",
    "\n",
    "> 🎯 **Estrategia:** este es el mapa base de un análisis de **grupos estratégicos** (Porter). Un espacio vacío puede ser un **océano azul**… o un cementerio donde ya murieron otros. El gráfico te muestra el hueco; **descubrir por qué está vacío es tu trabajo**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "39949dd954b7"
   },
   "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": "7254e12896b9"
   },
   "source": [
    "### 🌡️ Gráfico 2 — El termómetro del mercado\n",
    "\n",
    "**La pregunta:** ¿cuánto cobra la competencia por metro cuadrado, y qué tan de acuerdo están entre sí?\n",
    "\n",
    "**Qué mirar:**\n",
    "- La **línea roja** = promedio del mercado. Tu referencia de precio.\n",
    "- El **ancho** de la campana = qué tan dispersos están los precios.\n",
    "- ¿Hay **una sola joroba o dos**? Dos jorobas significan **dos mercados distintos** conviviendo.\n",
    "\n",
    "**La decisión que habilita:** el precio de lanzamiento de tu proyecto.\n",
    "\n",
    "> 🧠 **La lectura fina que casi nadie hace:**\n",
    "> - Campana **estrecha** → el mercado es un *commodity*: todos cobran casi lo mismo, la guerra será por costo.\n",
    "> - Campana **ancha** → hay espacio real para diferenciarse y cobrar más.\n",
    ">\n",
    "> En términos de Porter: la dispersión de precios te dice si vas a competir por **liderazgo en costos** o por **diferenciación**. Esa decisión estratégica está escrita en el ancho de esta curva."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "4f5b2ae3de57"
   },
   "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(\"     → Estrategia sugerida: LIDERAZGO EN COSTOS. Diferenciarse será caro y poco rentable.\")\n",
    "    elif cv < 0.40:\n",
    "        print(\"  📊 Mercado MIXTO: hay franjas de precio diferenciadas.\")\n",
    "        print(\"     → Estrategia sugerida: ENFOQUE en un segmento específico.\")\n",
    "    else:\n",
    "        print(\"  📈 Mercado HETEROGÉNEO: enorme variación de precios por m².\")\n",
    "        print(\"     → Estrategia sugerida: DIFERENCIACIÓN. El mercado sí paga por atributos distintos.\")\n",
    "    print(\"═\" * 62)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "99eae4224263"
   },
   "source": [
    "### 🏢 Gráfico 3 — Análisis de portafolio: ¿qué producto conviene construir?\n",
    "\n",
    "**La pregunta:** con los mismos 1.000 m² de lote, ¿me conviene hacer 20 apartaestudios o 8 apartamentos familiares?\n",
    "\n",
    "**Qué mirar:** en un diagrama de cajas, la **línea del medio** es la mediana, la **caja** contiene la mitad central del mercado 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 de tu proyecto.\n",
    "\n",
    "> 🎯 **Conexión VRIO — la \"O\" de Organización:**\n",
    "> Que un segmento sea el más rentable **no significa que sea el tuyo**. Vender 20 apartaestudios exige una fuerza comercial de volumen y rotación rápida. Vender 8 unidades premium exige otra cosa completamente distinta: relaciones, showroom, tiempos largos de cierre.\n",
    ">\n",
    "> **Un recurso valioso que tu organización no está preparada para explotar, no genera ventaja: genera pérdidas.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "81dc6dd876a8"
   },
   "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": "56c0126db2cd"
   },
   "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": "73d5188b99cc"
   },
   "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": "796a31349f91"
   },
   "source": [
    "### 🗺️ Gráfico 5 — Mapa de grupos estratégicos (Porter)\n",
    "\n",
    "**La pregunta:** ¿en qué cuadrante del mercado quiero jugar, y cuántos rivales me voy a encontrar ahí?\n",
    "\n",
    "Cruzamos el mercado con dos líneas (el área promedio y el precio promedio) y obtenemos cuatro territorios competitivos:\n",
    "\n",
    "| Cuadrante | Perfil | Lógica competitiva |\n",
    "|---|---|---|\n",
    "| ↙️ **Abajo-izquierda** | Pequeño y económico | **Liderazgo en costos** — volumen y eficiencia |\n",
    "| ↖️ **Arriba-izquierda** | Pequeño pero caro | **Ubicación premium** — el m² más rentable |\n",
    "| ↘️ **Abajo-derecha** | Grande y barato | Zonas periféricas o **producto en problemas** |\n",
    "| ↗️ **Arriba-derecha** | Grande y caro | **Alta diferenciación** — lujo |\n",
    "\n",
    "**La decisión que habilita:** el posicionamiento competitivo de tu empresa.\n",
    "\n",
    "> 🎯 **Conexión DOFA — las Amenazas:**\n",
    "> Cada punto en tu cuadrante objetivo **es un competidor directo**. No es una amenaza abstracta como \"alta competencia\": es una amenaza contable. Puedes contarla. Puedes ponerle nombre. Y esa es exactamente la diferencia entre un DOFA de taller y un DOFA que sirve para invertir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "71de926f29d3"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.5 — Mapa de grupos estratégicos con cuadrantes\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 5, \"el mapa de grupos estratégicos\"):\n",
    "    prom_area   = df_real[\"Area_m2\"].mean()\n",
    "    prom_precio = df_real[\"Precio_Millones\"].mean()\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(12, 8))\n",
    "    sns.scatterplot(data=df_real, x=\"Area_m2\", y=\"Precio_Millones\",\n",
    "                    hue=\"Banos_Num\", palette=\"magma\", s=95, alpha=0.75,\n",
    "                    edgecolor=\"white\", linewidth=0.6, ax=ax)\n",
    "    ax.axvline(prom_area,   color=\"gray\", ls=\"--\", lw=1.5)\n",
    "    ax.axhline(prom_precio, color=\"gray\", ls=\"--\", lw=1.5)\n",
    "\n",
    "    xmin, xmax = ax.get_xlim(); ymin, ymax = ax.get_ylim()\n",
    "    caja = dict(boxstyle=\"round,pad=0.45\", facecolor=\"white\", edgecolor=\"lightgray\", alpha=0.92)\n",
    "\n",
    "    etiquetas = [\n",
    "        (xmin + (prom_area - xmin) * 0.05, ymin + (prom_precio - ymin) * 0.08,\n",
    "         \"Masivo / Entrada\\n(Liderazgo en costos)\"),\n",
    "        (xmin + (prom_area - xmin) * 0.05, prom_precio + (ymax - prom_precio) * 0.72,\n",
    "         \"Alta rentabilidad m²\\n(Ubicación premium)\"),\n",
    "        (prom_area + (xmax - prom_area) * 0.45, prom_precio + (ymax - prom_precio) * 0.72,\n",
    "         \"Premium / Lujo\\n(Diferenciación)\"),\n",
    "        (prom_area + (xmax - prom_area) * 0.45, ymin + (prom_precio - ymin) * 0.08,\n",
    "         \"Grande y económico\\n(Periferia)\"),\n",
    "    ]\n",
    "    for x, y, txt in etiquetas:\n",
    "        ax.text(x, y, txt, fontsize=10.5, color=\"darkred\", weight=\"bold\", bbox=caja)\n",
    "\n",
    "    ax.set_title(\"Mapa de grupos estratégicos (Porter)\")\n",
    "    ax.set_xlabel(f\"Área del inmueble (m²)  —  promedio: {prom_area:.0f} m²\")\n",
    "    ax.set_ylabel(f\"Precio total (millones COP)  —  promedio: ${prom_precio:.0f} M\")\n",
    "    ax.legend(title=\"Baños\", loc=\"upper left\", fontsize=9)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "    # ── Cuántos competidores hay en cada cuadrante ───────────────────────────\n",
    "    grande = df_real[\"Area_m2\"]   >= prom_area\n",
    "    caro   = df_real[\"Precio_Millones\"] >= prom_precio\n",
    "    cuadrantes = pd.DataFrame({\n",
    "        \"Cuadrante\": [\"Masivo / Entrada\", \"Alta rentabilidad m²\", \"Premium / Lujo\", \"Grande y económico\"],\n",
    "        \"Competidores\": [int((~grande & ~caro).sum()), int((~grande & caro).sum()),\n",
    "                         int((grande & caro).sum()),   int((grande & ~caro).sum())],\n",
    "    })\n",
    "    cuadrantes[\"% del mercado\"] = (100 * cuadrantes[\"Competidores\"] /\n",
    "                                   max(cuadrantes[\"Competidores\"].sum(), 1)).round(1)\n",
    "    cuadrantes[\"Intensidad\"] = pd.cut(cuadrantes[\"% del mercado\"], [-0.1, 15, 30, 101],\n",
    "                                      labels=[\"🟢 Baja\", \"🟡 Media\", \"🔴 Alta\"])\n",
    "    print(\"\\n  🎯 INTENSIDAD COMPETITIVA POR CUADRANTE\")\n",
    "    display(cuadrantes)\n",
    "    print(\"  Lee así: 🔴 = océano rojo (muchos rivales) · 🟢 = espacio con menos competencia directa.\")\n",
    "    print(\"  ⚠️  Poca competencia NO garantiza oportunidad. Pregúntate siempre POR QUÉ está vacío.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e75fc0568be9"
   },
   "source": [
    "### 🔥 Gráfico 6 — Radar de competencia (densidad)\n",
    "\n",
    "**La pregunta:** ¿dónde se amontona de verdad la competencia?\n",
    "\n",
    "El mapa anterior muestra puntos; este muestra **calor**. Las zonas más intensas son donde hay más oferta concentrada: el **océano rojo** literal.\n",
    "\n",
    "**La decisión que habilita:** evitar entrar donde la guerra de precios ya está declarada.\n",
    "\n",
    "> 🎯 **Estrategia de Océano Azul (Kim & Mauborgne):** el objetivo no es ganarle a la competencia en su cancha, sino **crear una cancha nueva**. Este gráfico te muestra las canchas ya llenas. Los bordes fríos de la mancha roja son las hipótesis de océano azul que vale la pena investigar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "cb06db550c95"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.6 — Mapa de densidad competitiva\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 12, \"el mapa de densidad\"):\n",
    "    fig, ax = plt.subplots(figsize=(11, 6.5))\n",
    "    try:\n",
    "        sns.kdeplot(data=df_real, x=\"Area_m2\", y=\"Precio_Millones\",\n",
    "                    cmap=\"Reds\", fill=True, bw_adjust=0.6, alpha=0.85,\n",
    "                    levels=8, thresh=0.05, ax=ax)\n",
    "    except Exception as e:\n",
    "        print(f\"ℹ️  No se pudo calcular la densidad ({type(e).__name__}). Se muestran solo los puntos.\")\n",
    "    sns.scatterplot(data=df_real, x=\"Area_m2\", y=\"Precio_Millones\",\n",
    "                    color=\"black\", alpha=0.35, s=14, ax=ax)\n",
    "    ax.set_title(\"Radar de competencia: dónde se concentra la oferta\")\n",
    "    ax.set_xlabel(\"Área (m²)\")\n",
    "    ax.set_ylabel(\"Precio (millones de COP)\")\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8c71934549a2"
   },
   "source": [
    "### 🧮 Gráfico 7 — Matriz de producto: ¿qué plano conviene?\n",
    "\n",
    "**El ejercicio:** *\"Ustedes son los gerentes de diseño. Tienen 60 m². ¿Hacen 2 habitaciones con 1 baño, o 2 habitaciones con 2 baños? ¿Cuál configuración paga mejor el mercado bogotano?\"*\n",
    "\n",
    "**Qué mirar:** cada celda es una combinación habitaciones × baños. El color indica el valor promedio del m² de esa configuración.\n",
    "\n",
    "**La decisión que habilita:** el diseño arquitectónico del producto.\n",
    "\n",
    "> 🎯 **Conexión VRIO — la \"V\" de Valioso:**\n",
    "> Un recurso es valioso si **permite aprovechar una oportunidad o neutralizar una amenaza**. Aquí lo estás midiendo con números: si la configuración 2H-2B se vende consistentemente más cara por m², entonces *\"capacidad de construir baños adicionales sin sobrecostos\"* es un recurso **valioso** — y lo puedes demostrar, no solo afirmar.\n",
    ">\n",
    "> **Ese es el salto de calidad de todo este bloque:** pasar de un VRIO de opinión a un VRIO con evidencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ec47ba37f45c"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.7 — Matriz de rentabilidad: habitaciones × baños\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 8, \"la matriz de producto\"):\n",
    "    try:\n",
    "        matriz_prod = df_real.pivot_table(values=\"Valor_m2_Millones\",\n",
    "                                          index=\"Banos_Num\", columns=\"Habitaciones_Num\",\n",
    "                                          aggfunc=\"mean\")\n",
    "        conteo_prod = df_real.pivot_table(values=\"Valor_m2_Millones\",\n",
    "                                          index=\"Banos_Num\", columns=\"Habitaciones_Num\",\n",
    "                                          aggfunc=\"count\")\n",
    "        # Blindaje: ignoramos configuraciones con menos de 2 observaciones\n",
    "        matriz_prod = matriz_prod.where(conteo_prod >= 2)\n",
    "        matriz_prod = matriz_prod.dropna(how=\"all\").dropna(axis=1, how=\"all\")\n",
    "        matriz_prod = matriz_prod.sort_index(ascending=False)\n",
    "\n",
    "        if matriz_prod.empty:\n",
    "            print(\"⚠️  No hay combinaciones con suficientes observaciones para la matriz.\")\n",
    "        else:\n",
    "            fig, ax = plt.subplots(figsize=(9, 6))\n",
    "            sns.heatmap(matriz_prod, annot=True, fmt=\".1f\", cmap=\"YlGnBu\",\n",
    "                        linewidths=0.6, cbar_kws={\"label\": \"Valor promedio m² (millones)\"}, ax=ax)\n",
    "            ax.set_title(\"Matriz de rentabilidad: habitaciones vs. baños\")\n",
    "            ax.set_xlabel(\"Número de habitaciones\")\n",
    "            ax.set_ylabel(\"Número de baños\")\n",
    "            plt.tight_layout()\n",
    "            plt.show()\n",
    "\n",
    "            print(\"  🔢 Número de observaciones por celda (confiabilidad del dato):\")\n",
    "            display(conteo_prod.fillna(0).astype(int))\n",
    "            print(\"  ⚠️  Desconfía de cualquier celda con menos de 5 observaciones:\")\n",
    "            print(\"     un promedio de 2 datos no es una conclusión, es una anécdota.\")\n",
    "    except Exception as e:\n",
    "        print(f\"⚠️  No se pudo construir la matriz: {type(e).__name__}: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ba18524115a9"
   },
   "source": [
    "### 🎻 Gráfico 8 — Perfil de diferenciación (violín)\n",
    "\n",
    "**La pregunta:** ¿en qué segmento tengo margen para cobrar un precio premium?\n",
    "\n",
    "Un gráfico de violín es un boxplot con superpoderes: además de los cuartiles muestra **la forma completa de la distribución**.\n",
    "\n",
    "**Qué mirar:**\n",
    "- Violín **largo y ancho arriba** → hay compradores dispuestos a pagar mucho más que el promedio. **Ahí cabe una estrategia premium.**\n",
    "- Violín **corto y apretado** → todos cobran casi lo mismo. **Ahí solo se compite por costo.**\n",
    "\n",
    "**La decisión que habilita:** en qué segmento tu marca puede construir margen en vez de pelear descuentos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "5c71276084e4"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 8.8 — Perfil de diferenciación por segmento\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "if hay_datos(df_real, 8, \"el gráfico de violín\"):\n",
    "    conteo = df_real[\"Habitaciones_Num\"].value_counts()\n",
    "    validas = sorted(conteo[conteo >= 5].index.tolist())[:5]\n",
    "    df_violin = df_real[df_real[\"Habitaciones_Num\"].isin(validas)].copy()\n",
    "\n",
    "    if hay_datos(df_violin, 8, \"el violín\"):\n",
    "        fig, ax = plt.subplots(figsize=(11, 6))\n",
    "        grafico_categoria(\"violin\", df_violin, \"Habitaciones_Num\", \"Valor_m2_Millones\",\n",
    "                          ax=ax, palette=\"muted\", inner=\"quartile\")\n",
    "        ax.set_title(\"¿Qué segmento permite cobrar precios premium?\")\n",
    "        ax.set_xlabel(\"Número de habitaciones\")\n",
    "        ax.set_ylabel(\"Valor del m² (millones de COP)\")\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "        potencial = (df_violin.groupby(\"Habitaciones_Num\", observed=True)[\"Valor_m2_Millones\"]\n",
    "                     .agg(Mediana=\"median\", P90=lambda s: s.quantile(0.90), Oferta=\"count\").round(2))\n",
    "        potencial[\"Techo_premium_%\"] = (100 * (potencial[\"P90\"] / potencial[\"Mediana\"] - 1)).round(0)\n",
    "        print(\"\\n  💎 POTENCIAL DE PRECIO PREMIUM POR SEGMENTO\")\n",
    "        print(\"     (cuánto más que la mediana logra cobrar el 10% superior)\")\n",
    "        display(potencial)\n",
    "        if len(potencial):\n",
    "            top = potencial[\"Techo_premium_%\"].idxmax()\n",
    "            print(f\"  🏆 Mayor margen de diferenciación: {int(top)} habitación(es) → \"\n",
    "                  f\"el decil superior cobra {potencial.loc[top, 'Techo_premium_%']:.0f}% por encima de la mediana.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1438a6c638a9"
   },
   "source": [
    "## ⏸️ Pausa: ¿qué acabamos de hacer, realmente?\n",
    "\n",
    "Ocho gráficos. Ninguno de ellos 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",
    "- Entender que un **espacio vacío** en el mapa puede ser una oportunidad o una trampa.\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 ocho 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 usar todo esto para lo que realmente importa: **decidir**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1c310dbce7d3"
   },
   "source": [
    "---\n",
    "# 🎯 BLOQUE 9 — DOFA construido con datos\n",
    "\n",
    "## Olvidemos por un momento la definición\n",
    "\n",
    "Todos sabemos que DOFA es Debilidades, Oportunidades, Fortalezas y Amenazas. **Esa parte no vale nada.**\n",
    "\n",
    "Lo que sí vale — y lo que casi ninguna empresa hace — es responder esta pregunta:\n",
    "\n",
    "> ### ¿Con qué evidencia sostienes cada casilla?\n",
    "\n",
    "Un DOFA de taller dice: *\"Oportunidad: el mercado inmobiliario está creciendo.\"*\n",
    "Un DOFA con datos dice: *\"Oportunidad: el segmento de 45-70 m² concentra el 12% de la oferta pero registra un valor por m² 18% superior al promedio del mercado; hay 9 competidores directos frente a 47 en el segmento familiar.\"*\n",
    "\n",
    "**La primera frase se puede decir sin trabajar. La segunda mueve capital.**\n",
    "\n",
    "## La regla de oro: adentro vs. afuera\n",
    "\n",
    "| | Origen | ¿Los datos del mercado te lo dicen? |\n",
    "|---|---|---|\n",
    "| **Fortalezas** | Interno (tu empresa) | ❌ No. Salen de tu operación — pero se **calibran** contra el mercado |\n",
    "| **Debilidades** | Interno (tu empresa) | ❌ No. Igual: se dimensionan comparando |\n",
    "| **Oportunidades** | Externo (el mercado) | ✅ **Sí. Es exactamente lo que acabamos de medir** |\n",
    "| **Amenazas** | Externo (el mercado) | ✅ **Sí. Cada punto del gráfico es un competidor** |\n",
    "\n",
    "> 🧠 **Sé honesto con el alcance de tus datos.** Nuestro dataset es de oferta pública: describe con precisión el mundo **externo**. Para la mitad interna hay que declarar los supuestos de tu empresa — y eso es justo lo que hace la siguiente celda: te obliga a **escribir tus números**, no a improvisarlos en la reunión.\n",
    "\n",
    "**👉 Edita el diccionario `MI_EMPRESA` con los supuestos de tu constructora y vuelve a ejecutar. Cambia los números y observa cómo cambia el diagnóstico. Ese es el ejercicio.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "2f2c5145b348"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 9.1 — 👤 SUPUESTOS DE MI EMPRESA  (¡EDITA ESTOS NÚMEROS!)\n",
    "# Aquí declaras el lado INTERNO del DOFA. Sin esto, no hay F ni D posibles.\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",
    "    \"localidades_con_tierra\":  [\"Suba\", \"Engativá\", \"Fontibón\"],   # dónde ya tengo lotes u opción\n",
    "    \"experiencia_previa\":      False,   # ¿ya construí y vendí vivienda antes?\n",
    "    \"marca_reconocida\":        False,   # ¿el comprador conoce mi nombre?\n",
    "    \"equipo_comercial_propio\": False,   # ¿vendo yo o dependo de terceros?\n",
    "    \"capacidad_diseno_flexible\": True,  # ¿puedo cambiar tipologías sin sobrecostos grandes?\n",
    "    \"acceso_credito_preferencial\": True,\n",
    "}\n",
    "\n",
    "print(\"🏢 Supuestos cargados para:\", MI_EMPRESA[\"nombre\"])\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(\"\\n💡 Cambia estos valores y vuelve a ejecutar las celdas 9.2 y 10.1 para ver otro diagnóstico.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ab24c00a498e"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 9.2 — GENERADOR DE DOFA CON EVIDENCIA\n",
    "# Cada hallazgo tiene dos partes: un TÍTULO corto y su EVIDENCIA numérica.\n",
    "# Regla de la casa: si un hallazgo no trae cifra, no entra a la matriz.\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def construir_dofa(df_mercado, empresa):\n",
    "    \"\"\"Devuelve las 4 casillas del DOFA como listas de (título, evidencia).\"\"\"\n",
    "    D, O, F, A = [], [], [], []\n",
    "\n",
    "    vm2_prom = df_mercado[\"Valor_m2_Millones\"].mean()\n",
    "    vm2_med  = df_mercado[\"Valor_m2_Millones\"].median()\n",
    "    cv       = df_mercado[\"Valor_m2_Millones\"].std() / vm2_prom if vm2_prom else 0\n",
    "    ticket   = df_mercado[\"Precio_Millones\"].median()\n",
    "    costo    = empresa[\"costo_construccion_m2\"]\n",
    "\n",
    "    # ── FORTALEZAS / DEBILIDADES: interno, calibrado contra el mercado ────────\n",
    "    margen_bruto = (vm2_med - costo) / vm2_med if vm2_med else 0\n",
    "    if margen_bruto >= 0.35:\n",
    "        F.append((\"Estructura de costos competitiva\",\n",
    "                  f\"construir a ${costo:.2f} M/m² frente a un precio mediano de mercado de \"\n",
    "                  f\"${vm2_med:.2f} M/m² deja {margen_bruto:.0%} de margen bruto.\"))\n",
    "    elif margen_bruto >= 0.15:\n",
    "        D.append((\"Margen bruto ajustado\",\n",
    "                  f\"con un costo de ${costo:.2f} M/m² frente a ${vm2_med:.2f} M/m² de mercado el margen \"\n",
    "                  f\"bruto es de solo {margen_bruto:.0%}: cualquier sobrecosto se come la utilidad.\"))\n",
    "    else:\n",
    "        D.append((\"Costo de construcción no viable\",\n",
    "                  f\"${costo:.2f} M/m² contra un precio mediano de ${vm2_med:.2f} M/m². \"\n",
    "                  f\"El margen ({margen_bruto:.0%}) no soporta el negocio.\"))\n",
    "\n",
    "    unidades_financiables = empresa[\"capital_disponible\"] / ticket if ticket else 0\n",
    "    if unidades_financiables >= 20:\n",
    "        F.append((\"Capital suficiente para absorber ciclos lentos\",\n",
    "                  f\"el capital alcanza para ~{unidades_financiables:.0f} unidades del ticket mediano \"\n",
    "                  f\"(${ticket:.0f} M) sin depender totalmente de la preventa.\"))\n",
    "    else:\n",
    "        D.append((\"Capital limitado\",\n",
    "                  f\"alcanza para ~{unidades_financiables:.0f} unidades del ticket mediano (${ticket:.0f} M): \"\n",
    "                  f\"alta dependencia de preventa o crédito.\"))\n",
    "\n",
    "    if empresa[\"capacidad_diseno_flexible\"]:\n",
    "        F.append((\"Flexibilidad de diseño\",\n",
    "                  \"se pueden ajustar tipologías al segmento más rentable sin rediseñar todo el proyecto.\"))\n",
    "    if empresa[\"acceso_credito_preferencial\"]:\n",
    "        F.append((\"Acceso a crédito preferencial\",\n",
    "                  \"menor costo financiero que un entrante sin respaldo bancario.\"))\n",
    "    if empresa[\"experiencia_previa\"]:\n",
    "        F.append((\"Trayectoria comprobable\",\n",
    "                  \"el comprador de vivienda nueva compra sobre planos: el historial es parte del producto.\"))\n",
    "    else:\n",
    "        D.append((\"Sin trayectoria previa en vivienda\",\n",
    "                  \"el comprador compra sobre planos y la confianza en el constructor es parte del producto.\"))\n",
    "    if not empresa[\"marca_reconocida\"]:\n",
    "        D.append((\"Marca desconocida\",\n",
    "                  \"obliga a competir con precio o a depender de intermediarios, lo que erosiona el margen.\"))\n",
    "    if not empresa[\"equipo_comercial_propio\"]:\n",
    "        D.append((\"Sin fuerza comercial propia\",\n",
    "                  \"la comisión de terceros (3%-5% de los ingresos) reduce el margen y aleja al cliente.\"))\n",
    "\n",
    "    # ── OPORTUNIDADES: solo si hay PRIMA de precio Y baja competencia ─────────\n",
    "    seg = (df_mercado.groupby(\"Segmento\", observed=True)\n",
    "           .agg(oferta=(\"Título\", \"count\"), vm2=(\"Valor_m2_Millones\", \"mean\"))\n",
    "           .dropna())\n",
    "    hubo_oportunidad_segmento = False\n",
    "    if len(seg):\n",
    "        seg[\"participacion\"] = seg[\"oferta\"] / seg[\"oferta\"].sum()\n",
    "        seg[\"prima\"] = seg[\"vm2\"] / vm2_prom - 1\n",
    "        # Criterio explícito: paga más que el promedio Y tiene menos competencia que el promedio\n",
    "        candidatos = seg[(seg[\"prima\"] > 0.03) &\n",
    "                         (seg[\"participacion\"] < seg[\"participacion\"].mean()) &\n",
    "                         (seg[\"oferta\"] >= 3)].copy()\n",
    "        candidatos[\"indice\"] = candidatos[\"prima\"] / candidatos[\"participacion\"].clip(lower=0.01)\n",
    "        for nombre, r in candidatos.sort_values(\"indice\", ascending=False).head(2).iterrows():\n",
    "            hubo_oportunidad_segmento = True\n",
    "            O.append((f\"Nicho rentable en «{nombre}»\",\n",
    "                      f\"concentra solo el {r['participacion']:.0%} de la oferta ({int(r['oferta'])} competidores) \"\n",
    "                      f\"y aun así se transa {r['prima']:+.0%} por encima del promedio del mercado \"\n",
    "                      f\"(${r['vm2']:.2f} M/m²).\"))\n",
    "    if not hubo_oportunidad_segmento and len(seg):\n",
    "        mejor = seg.sort_values(\"vm2\", ascending=False).index[0]\n",
    "        O.append((\"Sin nichos evidentes por tipología\",\n",
    "                  f\"ningún segmento combina prima de precio con baja competencia. El de mayor valor, \"\n",
    "                  f\"«{mejor}» (${seg.loc[mejor,'vm2']:.2f} M/m²), ya concentra el \"\n",
    "                  f\"{seg.loc[mejor,'participacion']:.0%} de la oferta. La oportunidad habrá que buscarla \"\n",
    "                  f\"en ejecución o localización, no en tipología.\"))\n",
    "\n",
    "    loc = (df_mercado.groupby(\"Localidad\", observed=True)\n",
    "           .agg(oferta=(\"Título\", \"count\"), vm2=(\"Valor_m2_Millones\", \"mean\"))\n",
    "           .query(\"oferta >= 3\").sort_values(\"vm2\", ascending=False))\n",
    "    mias = [l for l in empresa[\"localidades_con_tierra\"] if l in loc.index]\n",
    "    for l in mias[:2]:\n",
    "        pos = list(loc.index).index(l) + 1\n",
    "        prima_loc = loc.loc[l, \"vm2\"] / vm2_prom - 1\n",
    "        O.append((f\"Tierra disponible en {l}\",\n",
    "                  f\"se transa a ${loc.loc[l,'vm2']:.2f} M/m² ({prima_loc:+.0%} vs. el promedio), \"\n",
    "                  f\"puesto {pos} de {len(loc)} zonas analizadas, con {int(loc.loc[l,'oferta'])} competidores.\"))\n",
    "    if len(loc) >= 3 and loc.index[0] not in empresa[\"localidades_con_tierra\"]:\n",
    "        mejor = loc.index[0]\n",
    "        O.append((f\"Zona de mayor valor no cubierta: {mejor}\",\n",
    "                  f\"se transa a ${loc.loc[mejor,'vm2']:.2f} M/m², \"\n",
    "                  f\"{(loc.loc[mejor,'vm2']/vm2_prom-1):+.0%} sobre el promedio. Adquirir tierra allí \"\n",
    "                  f\"elevaría el techo de precio de todo el portafolio.\"))\n",
    "    if cv >= 0.35:\n",
    "        O.append((\"Mercado con espacio para diferenciarse\",\n",
    "                  f\"la dispersión del valor por m² es del {cv:.0%}: hay disposición a pagar por atributos \"\n",
    "                  f\"diferenciales, no todo se decide por precio.\"))\n",
    "\n",
    "    # ── AMENAZAS: competencia medida, no imaginada ────────────────────────────\n",
    "    if len(seg):\n",
    "        saturado = seg.sort_values(\"participacion\", ascending=False).index[0]\n",
    "        A.append((f\"Saturación en «{saturado}»\",\n",
    "                  f\"{seg.loc[saturado,'participacion']:.0%} de toda la oferta \"\n",
    "                  f\"({int(seg.loc[saturado,'oferta'])} competidores). Entrar ahí es guerra de precios directa.\"))\n",
    "    if cv < 0.25:\n",
    "        A.append((\"Mercado tipo commodity\",\n",
    "                  f\"con una dispersión de solo {cv:.0%}, el comprador percibe los productos como \"\n",
    "                  f\"intercambiables y decide por precio: margen bajo presión estructural.\"))\n",
    "    baratos = (df_mercado[\"Valor_m2_Millones\"] < costo * 1.15).mean()\n",
    "    if baratos > 0.15:\n",
    "        A.append((\"Competidores por debajo de tu costo\",\n",
    "                  f\"el {baratos:.0%} de la oferta se vende por menos de tu costo + 15%: tienen mejor \"\n",
    "                  f\"estructura de costos o inventario que necesitan liquidar.\"))\n",
    "    A.append((\"Rivalidad alta y comparación en línea\",\n",
    "              f\"{len(df_mercado)} inmuebles compiten simultáneamente solo en la muestra analizada, \"\n",
    "              f\"y el comprador los compara en un portal antes de llamar.\"))\n",
    "    if empresa[\"capacidad_anual_unidades\"] < len(df_mercado) * 0.10:\n",
    "        A.append((\"Escala limitada frente a constructoras grandes\",\n",
    "                  f\"con {empresa['capacidad_anual_unidades']} unidades/año es difícil lograr economías \"\n",
    "                  f\"de escala en compras y en pauta comercial.\"))\n",
    "\n",
    "    return {\"Fortalezas\": F, \"Debilidades\": D, \"Oportunidades\": O, \"Amenazas\": A}\n",
    "\n",
    "\n",
    "if DATOS_OK:\n",
    "    import textwrap\n",
    "    dofa = construir_dofa(df_real, MI_EMPRESA)\n",
    "\n",
    "    iconos = {\"Fortalezas\": \"💪\", \"Debilidades\": \"⚠️\", \"Oportunidades\": \"🚀\", \"Amenazas\": \"⚔️\"}\n",
    "    origen = {\"Fortalezas\": \"INTERNO — supuestos declarados\", \"Debilidades\": \"INTERNO — supuestos declarados\",\n",
    "              \"Oportunidades\": \"EXTERNO — medido en los datos\", \"Amenazas\": \"EXTERNO — medido en los datos\"}\n",
    "\n",
    "    print(\"╔\" + \"═\" * 88 + \"╗\")\n",
    "    print(\"║\" + f\"  MATRIZ DOFA CON EVIDENCIA — {MI_EMPRESA['nombre']}\".ljust(88) + \"║\")\n",
    "    print(\"║\" + f\"  Base: {len(df_real)} inmuebles · Origen de datos: {ORIGEN_DATOS}\".ljust(88) + \"║\")\n",
    "    print(\"╚\" + \"═\" * 88 + \"╝\")\n",
    "\n",
    "    for casilla in [\"Fortalezas\", \"Debilidades\", \"Oportunidades\", \"Amenazas\"]:\n",
    "        print(f\"\\n{iconos[casilla]}  {casilla.upper()}   ({origen[casilla]})\")\n",
    "        print(\"─\" * 90)\n",
    "        if not dofa[casilla]:\n",
    "            print(\"   (sin hallazgos con la evidencia disponible)\")\n",
    "        for i, (titulo, evidencia) in enumerate(dofa[casilla], 1):\n",
    "            print(f\"   {i}. {titulo}\")\n",
    "            for linea in textwrap.wrap(evidencia, 80):\n",
    "                print(f\"      {linea}\")\n",
    "    print(\"\\n\" + \"═\" * 90)\n",
    "    print(\"  📌 Cada línea de arriba se puede auditar: la cifra sale de la base que construimos.\")\n",
    "    print(\"     Un DOFA que no se puede auditar es una opinión con formato de matriz.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ec535ef8be79"
   },
   "source": [
    "### 🔀 Del DOFA al movimiento: las estrategias cruzadas\n",
    "\n",
    "Llenar la matriz **no es la estrategia**. Es el diagnóstico. La estrategia aparece cuando cruzas las casillas:\n",
    "\n",
    "| Cruce | Nombre | La pregunta |\n",
    "|---|---|---|\n",
    "| **F + O** | Ofensiva / *Maxi-Maxi* | ¿Qué fortaleza mía aprovecha directamente esta oportunidad? |\n",
    "| **D + O** | Reorientación / *Mini-Maxi* | ¿Qué debilidad me impide tomar esta oportunidad, y cómo la cierro? |\n",
    "| **F + A** | Defensiva / *Maxi-Mini* | ¿Qué fortaleza me protege de esta amenaza? |\n",
    "| **D + A** | Supervivencia / *Mini-Mini* | ¿Qué combinación me puede sacar del mercado? Aquí se decide qué NO hacer |\n",
    "\n",
    "La siguiente celda genera propuestas de cruce automáticas a partir de tu DOFA.\n",
    "\n",
    "> ⚠️ **Léelas con criterio.** El computador cruza texto; **tú decides cuál cruce tiene sentido en el negocio real**. Las mejores dos o tres son las que se llevan al comité — el resto es ruido. Volvemos al principio: la máquina genera opciones, el profesional elige."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "8c3ce4ba8721"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 9.3 — ESTRATEGIAS CRUZADAS (FO / DO / FA / DA)\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def cruzar_dofa(dofa, max_por_cruce=3):\n",
    "    \"\"\"Combina las casillas del DOFA para sugerir líneas estratégicas.\"\"\"\n",
    "    cruces = {\n",
    "        \"🚀 OFENSIVA (Fortaleza + Oportunidad)\":       (\"Fortalezas\",  \"Oportunidades\",\n",
    "            \"Usar {a} para capturar: {b}\"),\n",
    "        \"🔧 REORIENTACIÓN (Debilidad + Oportunidad)\":  (\"Debilidades\", \"Oportunidades\",\n",
    "            \"Cerrar «{a}» es condición para aprovechar: {b}\"),\n",
    "        \"🛡️ DEFENSIVA (Fortaleza + Amenaza)\":          (\"Fortalezas\",  \"Amenazas\",\n",
    "            \"Apoyarse en {a} para resistir: {b}\"),\n",
    "        \"🚨 SUPERVIVENCIA (Debilidad + Amenaza)\":       (\"Debilidades\", \"Amenazas\",\n",
    "            \"Riesgo crítico: {a} + {b}\"),\n",
    "    }\n",
    "    salida = {}\n",
    "    for titulo, (ka, kb, plantilla) in cruces.items():\n",
    "        items = []\n",
    "        for ta, _ in dofa[ka][:2]:\n",
    "            for tb, _ in dofa[kb][:2]:\n",
    "                items.append(plantilla.format(a=ta, b=tb))\n",
    "        salida[titulo] = items[:max_por_cruce]\n",
    "    return salida\n",
    "\n",
    "\n",
    "if DATOS_OK:\n",
    "    import textwrap\n",
    "    estrategias = cruzar_dofa(dofa)\n",
    "    print(\"═\" * 90)\n",
    "    print(\"  LÍNEAS ESTRATÉGICAS SUGERIDAS (para discutir, no para obedecer)\")\n",
    "    print(\"═\" * 90)\n",
    "    for titulo, items in estrategias.items():\n",
    "        print(f\"\\n{titulo}\")\n",
    "        print(\"─\" * 90)\n",
    "        if not items:\n",
    "            print(\"   (sin combinaciones disponibles)\")\n",
    "        for i, it in enumerate(items, 1):\n",
    "            envuelto = textwrap.wrap(it, 84)\n",
    "            print(f\"   {i}. {envuelto[0]}\")\n",
    "            for linea in envuelto[1:]:\n",
    "                print(f\"      {linea}\")\n",
    "    print(\"\\n\" + \"═\" * 90)\n",
    "    print(\"  🗣️  ACTIVIDAD (10 min): en grupos, escojan UNA línea ofensiva y UNA de supervivencia.\")\n",
    "    print(\"     Defiéndanlas citando la cifra exacta del DOFA que las sustenta.\")\n",
    "    print(\"     Si no pueden citar un número, la línea se descarta.\")\n",
    "    print(\"\\n  ⚠️  El computador combinó texto. Cuál de estas líneas tiene sentido en el negocio real\")\n",
    "    print(\"     lo decide el equipo directivo. Esa selección es la estrategia; la lista es insumo.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0c232ee17f1a"
   },
   "source": [
    "---\n",
    "# 🏛️ BLOQUE 10 — VRIO con evidencia\n",
    "\n",
    "## Qué es VRIO, en una frase\n",
    "\n",
    "Es un **filtro para saber si un recurso tuyo genera ventaja competitiva de verdad**, o solo te permite seguir jugando.\n",
    "\n",
    "Un recurso pasa por cuatro preguntas, **en orden**, y basta que falle una para saber en qué liga estás:\n",
    "\n",
    "| Pregunta | Qué evalúa | ¿Se puede medir con datos de mercado? |\n",
    "|---|---|---|\n",
    "| **V — ¿Valioso?** | ¿Permite aprovechar una oportunidad o neutralizar una amenaza? | ✅ **Sí**: ¿el mercado paga más por ese atributo? |\n",
    "| **R — ¿Raro?** | ¿Pocos competidores lo tienen? | ✅ **Sí**: ¿qué porcentaje de la oferta lo ofrece? |\n",
    "| **I — ¿Inimitable?** | ¿Es costoso o difícil de copiar? | 🟡 **Parcial**: la dispersión da pistas, el juicio decide |\n",
    "| **O — ¿Organización?** | ¿Mi empresa está preparada para explotarlo? | ❌ **No**: esto es 100% interno |\n",
    "\n",
    "## El resultado del filtro\n",
    "\n",
    "| V | R | I | O | Implicación competitiva | Desempeño esperado |\n",
    "|:--:|:--:|:--:|:--:|---|---|\n",
    "| ❌ | — | — | — | **Desventaja competitiva** | Por debajo del promedio |\n",
    "| ✅ | ❌ | — | — | **Paridad competitiva** | Promedio del sector |\n",
    "| ✅ | ✅ | ❌ | — | **Ventaja temporal** | Por encima, hasta que te copien |\n",
    "| ✅ | ✅ | ✅ | ❌ | **Ventaja no explotada** | Dejas plata sobre la mesa |\n",
    "| ✅ | ✅ | ✅ | ✅ | **Ventaja competitiva sostenida** | Superior y duradero |\n",
    "\n",
    "---\n",
    "\n",
    "### 🧠 Por qué hacerlo con datos cambia la conversación\n",
    "\n",
    "En la mayoría de talleres de estrategia, el VRIO se llena con opiniones del equipo directivo. Todos creen que su recurso es valioso y raro — **por eso casi ningún VRIO de taller sirve**.\n",
    "\n",
    "Aquí vamos a hacer algo distinto: **la V y la R las va a responder el mercado**, no nosotros.\n",
    "\n",
    "- **V (Valioso)** → medimos la **prima de precio**: ¿cuánto más paga el mercado por m² cuando el atributo está presente?\n",
    "- **R (Raro)** → medimos la **escasez en la oferta**: ¿qué porcentaje de los competidores ya lo ofrece?\n",
    "- **I** e **O** siguen siendo juicio informado, y así hay que declararlo. **Ser explícito sobre qué parte es dato y qué parte es criterio es lo que hace defendible un análisis.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "08dd0c6de9dd"
   },
   "source": [
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "# CELDA 10.1 — VRIO ALIMENTADO CON DATOS DEL MERCADO\n",
    "# ══════════════════════════════════════════════════════════════════════════════\n",
    "\n",
    "def prima_de_precio(df_mercado, condicion):\n",
    "    \"\"\"\n",
    "    Mide cuánto más (o menos) vale el m² cuando se cumple una condición.\n",
    "    Devuelve (prima %, presencia en la oferta %, n con atributo) o None si no hay muestra.\n",
    "    \"\"\"\n",
    "    con = df_mercado[condicion][\"Valor_m2_Millones\"]\n",
    "    sin = df_mercado[~condicion][\"Valor_m2_Millones\"]\n",
    "    if len(con) < 5 or len(sin) < 5 or not sin.median():\n",
    "        return None\n",
    "    return (con.median() / sin.median() - 1), len(con) / len(df_mercado), len(con)\n",
    "\n",
    "\n",
    "def evaluar_vrio(nombre, valioso, raro, inimitable, organizado, evidencia=\"\"):\n",
    "    \"\"\"Aplica el filtro VRIO en orden. Basta que falle una pregunta para saber en qué liga estás.\"\"\"\n",
    "    if not valioso:\n",
    "        impl, desemp, icono = \"Desventaja competitiva\", \"Por debajo del promedio\", \"🔴\"\n",
    "    elif not raro:\n",
    "        impl, desemp, icono = \"Paridad competitiva\", \"Promedio del sector\", \"🟡\"\n",
    "    elif not inimitable:\n",
    "        impl, desemp, icono = \"Ventaja competitiva temporal\", \"Superior, hasta que lo copien\", \"🟠\"\n",
    "    elif not organizado:\n",
    "        impl, desemp, icono = \"Ventaja no explotada\", \"Potencial desperdiciado\", \"🔵\"\n",
    "    else:\n",
    "        impl, desemp, icono = \"VENTAJA COMPETITIVA SOSTENIDA\", \"Superior y duradero\", \"🟢\"\n",
    "    return {\"Recurso\": nombre, \"V\": \"✅\" if valioso else \"❌\", \"R\": \"✅\" if raro else \"❌\",\n",
    "            \"I\": \"✅\" if inimitable else \"❌\", \"O\": \"✅\" if organizado else \"❌\",\n",
    "            \"Implicación\": f\"{icono} {impl}\", \"Desempeño esperado\": desemp, \"Evidencia\": evidencia}\n",
    "\n",
    "\n",
    "if DATOS_OK:\n",
    "    UMBRAL_PRIMA  = 0.05    # el mercado paga al menos 5% más → el atributo es VALIOSO\n",
    "    UMBRAL_RAREZA = 0.30    # lo ofrece menos del 30% de la competencia → es RARO\n",
    "\n",
    "    # ── Juicio interno: EDITA estos valores según tu empresa ─────────────────\n",
    "    # (¿es difícil de imitar?  ,  ¿mi organización está lista para explotarlo?)\n",
    "    JUICIO_INTERNO = {\n",
    "        \"banos_extra\":   (False, MI_EMPRESA[\"capacidad_diseno_flexible\"]),\n",
    "        \"compactos\":     (False, MI_EMPRESA[\"capacidad_diseno_flexible\"]),\n",
    "        \"tierra_premium\": (True, MI_EMPRESA[\"capital_disponible\"] > 10000),\n",
    "        \"familiar\":      (False, MI_EMPRESA[\"experiencia_previa\"]),\n",
    "    }\n",
    "\n",
    "    # ── Recursos candidatos y la condición de mercado que los evidencia ──────\n",
    "    definiciones = [\n",
    "        (\"banos_extra\",    \"Capacidad de construir 2+ baños sin sobrecosto\",\n",
    "         df_real[\"Banos_Num\"] >= 2),\n",
    "        (\"compactos\",      \"Especialización en unidades compactas (≤55 m²)\",\n",
    "         df_real[\"Area_m2\"] <= 55),\n",
    "        (\"familiar\",       \"Producto familiar de 3+ habitaciones\",\n",
    "         df_real[\"Habitaciones_Num\"] >= 3),\n",
    "    ]\n",
    "\n",
    "    top_loc = (df_real.groupby(\"Localidad\", observed=True)[\"Valor_m2_Millones\"]\n",
    "               .agg([\"mean\", \"count\"]).query(\"count >= 5\").sort_values(\"mean\", ascending=False))\n",
    "    if len(top_loc):\n",
    "        zona = top_loc.index[0]\n",
    "        definiciones.append((\"tierra_premium\", f\"Banco de tierras en {zona}\",\n",
    "                             df_real[\"Localidad\"] == zona))\n",
    "\n",
    "    filas_vrio = []\n",
    "    print(\"═\" * 92)\n",
    "    print(\"  SEÑALES DEL MERCADO PARA CADA RECURSO\")\n",
    "    print(\"═\" * 92)\n",
    "    for clave, nombre, condicion in definiciones:\n",
    "        medida = prima_de_precio(df_real, condicion)\n",
    "        if medida is None:\n",
    "            print(f\"  • {nombre}\\n      ⚠️  Muestra insuficiente para medirlo. Se omite del análisis.\")\n",
    "            continue\n",
    "        prima, presencia, n = medida\n",
    "        valioso = prima >= UMBRAL_PRIMA\n",
    "        raro    = presencia <= UMBRAL_RAREZA\n",
    "        inimit, organiz = JUICIO_INTERNO.get(clave, (False, False))\n",
    "        print(f\"  • {nombre}\")\n",
    "        print(f\"      Prima de precio ..... {prima:+7.1%}  → {'VALIOSO ✅' if valioso else 'no valioso ❌'}\")\n",
    "        print(f\"      Presencia en oferta . {presencia:7.1%}  → {'RARO ✅' if raro else 'común ❌'}\")\n",
    "        filas_vrio.append(evaluar_vrio(\n",
    "            nombre, valioso, raro, inimit, organiz,\n",
    "            f\"Prima {prima:+.0%} · presente en {presencia:.0%} de la oferta (n={n})\"))\n",
    "\n",
    "    if filas_vrio:\n",
    "        print(\"\\n\" + \"═\" * 92)\n",
    "        print(\"  MATRIZ VRIO\")\n",
    "        print(\"═\" * 92)\n",
    "        tabla_vrio = pd.DataFrame(filas_vrio)\n",
    "        display(tabla_vrio[[\"Recurso\", \"V\", \"R\", \"I\", \"O\", \"Implicación\", \"Desempeño esperado\"]])\n",
    "        print(\"\\n  📎 Evidencia de cada fila:\")\n",
    "        for f in filas_vrio:\n",
    "            print(f\"     • {f['Recurso']}: {f['Evidencia']}\")\n",
    "        sostenidas = [f[\"Recurso\"] for f in filas_vrio if \"SOSTENIDA\" in f[\"Implicación\"]]\n",
    "        print(\"\\n  🏆 Recursos con ventaja SOSTENIDA:\",\n",
    "              \", \".join(sostenidas) if sostenidas else \"ninguno con los supuestos actuales.\")\n",
    "    print(\"\\n  ⚙️  V y R salen de los DATOS. I y O son JUICIO declarado en `JUICIO_INTERNO`.\")\n",
    "    print(\"     Cambiar un supuesto y ver cómo se mueve la conclusión es el ejercicio:\")\n",
    "    print(\"     eso es análisis de sensibilidad aplicado a la estrategia.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5f40a6d53d00"
   },
   "source": [
    "### 🗣️ Actividad de cierre para Estrategia (15 minutos, en grupos)\n",
    "\n",
    "1. **Cambien un supuesto** en `MI_EMPRESA` (por ejemplo, bajen el costo de construcción a 2.6 o pongan `experiencia_previa = True`) y vuelvan a ejecutar las celdas 9.2 y 10.1.\n",
    "2. **Observen qué se movió** en el DOFA y en el VRIO. ¿Qué recurso pasó de paridad a ventaja?\n",
    "3. **Defiendan en 2 minutos** una recomendación de entrada al mercado:\n",
    "   - ¿En qué **segmento** entran y con qué **tipología**?\n",
    "   - ¿Con qué **cifra exacta** sustentan la oportunidad?\n",
    "   - ¿Cuál es la **amenaza principal** y cómo la neutralizan?\n",
    "   - ¿Qué recurso les da ventaja **sostenida** y no solo temporal?\n",
    "\n",
    "> 🏁 **Criterio de evaluación:** una afirmación sin número no cuenta. *\"Vemos una oportunidad en el segmento compacto\"* no vale. *\"Vemos una oportunidad en el segmento compacto porque concentra el 12% de la oferta con un valor por m² 18% superior al promedio\"* sí vale.\n",
    ">\n",
    "> Esa diferencia —la misma frase, con y sin evidencia— es literalmente la diferencia entre un analista junior y un director de estrategia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "d6efd3be5092"
   },
   "source": [
    "---\n",
    "# 🎓 BLOQUE 11 — 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 un **diagnóstico estratégico defendible**: DOFA con cifras auditables, VRIO con señales de mercado, y una recomendación de entrada que se puede sustentar frente a una junta.\n",
    "\n",
    "---\n",
    "\n",
    "## 🔨 Volvamos al principio: Python es el martillo, no la casa\n",
    "\n",
    "Repasa lo que hiciste hoy y separa las dos columnas:\n",
    "\n",
    "| El computador hizo | **Tú hiciste** |\n",
    "|---|---|\n",
    "| Leer 400 avisos de la competencia | Decidir qué mercado observar |\n",
    "| Calcular promedios por segmento | **Notar que el promedio mentía** |\n",
    "| Dibujar la nube de puntos | **Ver el hueco y preguntar por qué está vacío** |\n",
    "| Contar competidores por cuadrante | Entender qué significa esa rivalidad para tu margen |\n",
    "| Llenar las casillas del DOFA | **Decidir cuál hallazgo merece capital** |\n",
    "| Aplicar el filtro VRIO | Declarar honestamente qué era dato y qué era juicio |\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 mucho dominar la izquierda**. No para competir con la máquina, sino porque **quien no entiende la herramienta no puede auditarla**, y en una sala de junta la persona que puede verificar el número tiene una autoridad que no se delega.\n",
    "\n",
    "---\n",
    "\n",
    "## 🗺️ Si quieres ir más lejos: ruta de 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 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 | 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 importa:** no aprendas Python \"en general\". Escoge **un problema tuyo, real y molesto** y resuélvelo. Aprender sin un problema propio se abandona en la semana tres.\n",
    "\n",
    "---\n",
    "\n",
    "## ✅ Checklist: lo que deberías poder hacer al salir de aquí\n",
    "\n",
    "- [ ] Explicar por qué un precio de **oferta** no es un precio de **transacción**, y qué decisiones cambia esa diferencia\n",
    "- [ ] Verificar la trazabilidad de un dato hasta su fuente original\n",
    "- [ ] Construir un indicador comparable a partir de variables crudas\n",
    "- [ ] Decidir con criterio si un **atípico** es ruido o es la oportunidad\n",
    "- [ ] Leer un **mapa de grupos estratégicos** y contar competidores por cuadrante\n",
    "- [ ] Distinguir **correlación** de **causalidad** y decir por qué importa en plata\n",
    "- [ ] Sustentar **cada casilla de un DOFA** con una cifra verificable\n",
    "- [ ] Derivar **estrategias cruzadas** (FO, DO, FA, DA) y elegir cuáles merecen recursos\n",
    "- [ ] Aplicar **VRIO** separando lo que dicen los datos de lo que es juicio propio\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 inteligencia competitiva real.**\n",
    "\n",
    "Usa la celda de abajo. Está en blanco a propósito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "metadata": {
    "id": "ccdff05e2cbb"
   },
   "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",
    "# ══════════════════════════════════════════════════════════════════════════════"
   ]
  }
 ]
}