Asignatura: Estadística Aplicada con Python y R
Programa: Ingeniería Agrícola — Universidad de Sucre
Grupos: 1 y 2
Tema: Análisis Exploratorio de Datos (EDA) + control de versiones con Git/GitHub + desarrollo asistido por IA
Modalidad: Individual. Repositorio en GitHub + hoja manuscrita escaneada dentro del repositorio (Lápiz y Algoritmo)
Duración: 2 sesiones de 2 horas + trabajo autónomo
Entregable único: la URL de tu
repositorio en GitHub
(https://github.com/TU_USUARIO/app-estadistica-agricola)
Importante: este repositorio te acompañará el resto del semestre. En las próximas actividades le agregarás las páginas de Regresión y Series de tiempo. Lo que construyas hoy es la base de tu proyecto final.
Una cooperativa de productores de Sucre quiere una aplicación web sencilla para explorar los datos de sus parcelas: cuánto rinden, qué tan variables son, si hay parcelas con comportamiento extraño y si el riego o el tipo de suelo parecen marcar diferencias. Tú serás el ingeniero que construye esa app.
Para hacerlo usarás tres herramientas profesionales:
Analogía agrícola:
Metodología del Lápiz y el Algoritmo: antes de que la app te muestre los resultados, calcularás a mano las medidas descriptivas de 10 parcelas que te asigna tu código estudiantil (Fase 1). Después las verificarás con Python y R (Fase 2).
| Mecanismo | Qué lo hace personal |
|---|---|
| Semilla = código estudiantil | El script generar_datos.py usa tu código para asignarte
cultivo, municipio, número de parcelas, datos, atípicos y
faltantes. |
| Huella digital | Un código de 8 caracteres (p. ej. 83C6B069) que aparece
en tu app y en tu README. El docente la regenera con tu código. |
| Muestra de 10 parcelas | Cada estudiante calcula a mano con números distintos; la hoja debe tener tu letra, nombre y código. |
| Historial de commits | GitHub registra fecha, hora y autor de cada commit. Se revisa que el trabajo se haya hecho en las dos sesiones y con tu correo institucional. |
| Bitácora de IA | Tus prompts, lo que aceptaste, lo que rechazaste y los errores que corregiste. |
Si dos repositorios tienen textos de hallazgos o bitácoras idénticas, ambos estudiantes presentan una sustentación oral corta antes de asignar la nota.
Objetivo general
Construir, en un GitHub Codespace y con apoyo supervisado de GitHub Copilot en modo Agente, la primera versión de una aplicación en Python y Streamlit que realice el Análisis Exploratorio de Datos de un conjunto de parcelas agrícolas personalizado, gestionando su desarrollo con Git y GitHub.
Objetivos específicos
.gitignore y
requirements.txt, e instalar las dependencias.| Competencia | Resultado de aprendizaje | Estrategia pedagógica |
|---|---|---|
| Pensamiento computacional y reproducibilidad | Organiza un proyecto de Python con entorno virtual, dependencias declaradas y archivos excluidos del control de versiones | Prompt 1 al agente + revisión de cada comando antes de aprobarlo |
| Gestión de versiones (Git/GitHub) | Registra su trabajo en commits con mensajes claros y sincroniza su repositorio local con el remoto, de forma manual y mediante el agente | Panel Control de código fuente, edición web + pull,
Prompt 3 |
| Análisis exploratorio de datos | Describe una variable agrícola con medidas de tendencia central, dispersión y posición; detecta atípicos y datos faltantes; compara grupos y explora correlaciones | Página EDA de la app con datos personalizados |
| Razonamiento cuantitativo manual (Lápiz y Algoritmo) | Calcula a mano las medidas descriptivas de 10 observaciones y las contrasta con Python y R | Hoja manuscrita + verificar_muestra.py y
verificar_muestra.R |
| Uso ético y crítico de la IA | Dirige, supervisa y corrige a un agente de IA, y documenta su uso | Bitácora de IA (Hoja de Ruta para la Adopción Ética y Sostenible de la IA en Colombia, 2024) |
| Comunicación técnica | Redacta hallazgos agronómicos con unidades, a partir de la evidencia estadística | Sección “Hallazgos del EDA” del README |
No necesitas tener aprobado GitHub Education: la cuenta gratuita incluye Codespaces y Copilot Free con modo Agente. La cuota del agente es limitada: usa cada prompt una sola vez, completo, y no lo repitas sin necesidad.
app-estadistica-agricolaApp de Streamlit para análisis estadístico agrícola — Estadística Aplicada con Python y R, Unisucre.gitignore).15 minutos (se
apaga solo si lo dejas sin uso).30
días.README.md y una terminal abajo.git config --global user.name "Nombre Apellido" # tu nombre real
git config --global user.email "usuario@unisucrevirtual.edu.co" # tu correo institucional
git config --global --list # verifica que quedaron guardados¿Cuánto se consume? Un Codespace de 2 núcleos gasta 2 horas-núcleo por cada hora encendido. La cuenta gratuita trae 120 horas-núcleo al mes (unas 60 horas reales). Un Codespace olvidado encendido toda la noche gasta la quinta parte de tu cuota. Detenido no gasta horas.
.gitignore
y requirements.txt (25 min)Cómo trabajar con el agente:
Ctrl+Alt+I) y en el selector de modo elige
Agent.BITACORA_IA.md (Paso
11).Actúa como tutor de Python y Streamlit para estudiantes de Ingeniería Agrícola.
Responde en español y explica en una o dos líneas cada paso antes de ejecutarlo.
Estamos en un GitHub Codespace (Linux) dentro de mi repositorio app-estadistica-agricola,
que por ahora solo tiene README.md. Prepara el proyecto así:
1. Crea un entorno virtual llamado .venv con: python -m venv .venv
2. Actívalo con: source .venv/bin/activate y verifica con: which python
3. Configura VS Code para usar .venv/bin/python como intérprete (archivo .vscode/settings.json).
4. Crea un .gitignore para Python que excluya: .venv/, __pycache__/, *.pyc,
.ipynb_checkpoints/, .streamlit/secrets.toml y .DS_Store
5. Crea requirements.txt con: streamlit, pandas, numpy, scipy, matplotlib, seaborn, statsmodels
6. Instala las dependencias con: .venv/bin/pip install -r requirements.txt
7. Verifica la instalación imprimiendo la versión de cada librería.
No crees ningún otro archivo y no hagas commits. Al final muéstrame el árbol de archivos
(sin .venv) y explícame en 5 líneas para qué sirven el entorno virtual, .gitignore y requirements.txt.Verifica tú mismo: en el explorador de la izquierda
aparecen .gitignore, requirements.txt y
.vscode/. La carpeta .venv existe, pero
no debe aparecer en el panel Control de código
fuente.
Ctrl+Shift+G)..venv.[manual] Configura entorno: .gitignore, requirements.txt y VS Codepull + push.Regla de los mensajes: los commits que hagas tú desde el panel empiezan por
[manual]; los que hagas en la web, por[web]; los que haga el agente, por[agente]. Así el docente puede evaluar cada forma de trabajo.
generar_datos.py en
la raíz del proyecto.codigo y
nombre..venv/bin/python generar_datos.py # ejecuta el script con el Python del entorno virtualdatos/ con
parcelas.csv, clima_mensual.csv,
muestra10.csv y metadatos.json. En la terminal
verás tu huella, tu cultivo, tu
municipio y tus 10 parcelas para el cálculo a
mano.[manual] Agrega generador y datos personalizados →
Commit → Sync Changes.No vuelvas a ejecutar el script con otro código. Si lo vuelves a ejecutar con el mismo código, los datos salen idénticos.
git status # debe decir: nothing to commit, working tree clean| Opción | Cuándo usarla |
|---|---|
| Stop codespace | Siempre, al terminar cada sesión |
| Delete | Solo al final del semestre y después de verificar que todo está en GitHub |
Push y apagar, siempre en ese orden. Nunca borres un Codespace sin haber sincronizado.
Con las 10 parcelas de muestra10 que copiaste en tu hoja
(nombre, código y huella en el encabezado):
Analogía: el atípico es como esa parcela del lote que se ve “distinta” desde la carretera. El EDA no la borra de inmediato: primero pregunta por qué es distinta.
Escanea la hoja en PDF con el nombre
hoja_manuscrita.pdf.
README.md → icono del
lápiz → reemplaza su contenido por la plantilla del
Anexo C y completa tus datos y tu huella. Mensaje del
commit: [web] Actualiza README con datos del estudiante →
Commit changes.evidencias/LEEME.md (al escribir la / se crea
la carpeta) → contenido: Evidencias de la actividad →
mensaje [web] Crea carpeta de evidencias → Commit
changes.evidencias/ → Add file →
Upload files → arrastra hoja_manuscrita.pdf →
mensaje [web] Agrega hoja manuscrita → Commit
changes.git pull). Verás
aparecer el README actualizado y la carpeta
evidencias/.git log --oneline # deben aparecer tus commits [manual] y [web]Ahora crea una app de Streamlit multipágina. El proyecto ya tiene la carpeta datos/ con:
- parcelas.csv: parcela, suelo, riego, dosis_N [kg/ha], lamina_riego [mm],
materia_organica [%], ph, rendimiento [t/ha]. Tiene valores faltantes en
materia_organica y posibles atípicos en rendimiento.
- clima_mensual.csv: fecha, precipitacion_mm, temperatura_c (mensual, 2015-2025).
- muestra10.csv: parcela, suelo, riego, rendimiento.
- metadatos.json: codigo, nombre, cultivo, municipio, n_parcelas, huella.
NO modifiques la carpeta datos/ ni generar_datos.py.
Crea esta estructura, usando .venv/bin/python y .venv/bin/pip en todos los comandos:
1. src/__init__.py y src/eda.py con funciones con docstrings: cargar_datos(nombre_csv)
con @st.cache_data, cargar_metadatos(), resumen_numerico(serie) [n, media, mediana,
desviación estándar muestral, CV %, mínimo, Q1, Q3, máximo, RIC, asimetría],
valores_faltantes(df) y atipicos_iqr(serie) [vallas de Tukey con 1.5·RIC].
2. app.py (Inicio): título "Estadística Aplicada con Python y R — Ingeniería Agrícola,
Unisucre"; tarjeta con nombre, código, cultivo, municipio y huella leídos de
metadatos.json; descripción breve de la app y de cada página.
3. pages/1_Datos.py: tabla de parcelas, número de filas y columnas, tipo de cada variable
(cualitativa o cuantitativa), tabla de valores faltantes y botón para descargar el CSV.
4. pages/2_EDA.py: filtros en la barra lateral por suelo y riego, y cuatro secciones:
a) Univariado: selector de variable numérica, tabla resumen_numerico, histograma con
curva de densidad y diagrama de caja con seaborn, y lista de parcelas atípicas.
b) Cualitativo: tabla de frecuencias absolutas y relativas, y gráfico de barras de
suelo y de riego.
c) Bivariado: diagramas de caja de rendimiento por suelo y por riego; dispersión de una
variable X elegida contra rendimiento, coloreada por riego; mapa de calor de la
matriz de correlación de Pearson de las variables numéricas.
d) "Muestra de 10 parcelas (verificación del cálculo a mano)": tabla de muestra10,
su resumen_numerico, sus vallas de Tukey, sus atípicos y la media por riego.
5. pages/3_Regresion.py: página "en construcción" con st.info y la lista de temas que
vendrán: correlación, regresión lineal simple, regresión múltiple y diagnóstico de residuos.
6. pages/4_Series_de_tiempo.py: página "en construcción" con st.info, la lista de temas
(componentes, descomposición, promedios móviles, pronóstico) y, como vista previa,
un gráfico de línea de precipitacion_mm de clima_mensual.csv.
Requisitos: solo librerías de requirements.txt; textos de la interfaz en español; ejes
con unidades; código comentado paso a paso para estudiantes de Ingeniería Agrícola.
No hagas commits. Al final ejecuta:
.venv/bin/streamlit run app.py --server.headless true
y dime cómo abrir la app desde la pestaña Puertos (puerto 8501). Si hay errores, corrígelos.Supervisa al agente:
requirements.txt, rechaza
y pídele que use solo las de la lista.evidencias/ arrastrándolas al explorador del Codespace:
captura_inicio.png y captura_eda.png.Ctrl+C en la terminal donde
corre.verificacion/ con los dos scripts del
Anexo B..venv/bin/python verificacion/verificar_muestra.py # verifica tu cálculo a manodatos/muestra10.csv y verificar_muestra.R a un
proyecto, y ejecuta el script.verificacion/RESULTADOS.md con la tabla del
Anexo B (manual vs Python vs R). Si algún valor no
coincide (más allá del redondeo), busca el error en tu hoja; no
cambies la hoja para que coincida: anótalo y explica qué
pasó.README.md, completa la sección “Hallazgos
del EDA” (6–10 líneas, escritas por ti, no por
la IA), con base en tu app:
BITACORA_IA.md con la plantilla del Anexo
D.[manual] Agrega verificación, hallazgos del EDA y bitácora de IA
→ Commit → Sync Changes.Actúa como mi asistente de control de versiones con Git. Explica cada comando antes de
ejecutarlo y espera mi aprobación.
1. Ejecuta git status y confirma que .venv/ NO aparece; si aparece, corrige .gitignore
antes de continuar.
2. Ejecuta git pull para traer los cambios que haya en GitHub.
3. Agrupa los archivos pendientes en commits separados y lógicos (por ejemplo: src/ y
app.py; pages/; evidencias/; otros). Cada mensaje en español debe empezar por "[agente]"
y describir el cambio.
4. Ejecuta git push y muéstrame git log --oneline -20.
5. Explícame en 3 líneas la diferencia entre hacer commit y hacer push, y dame la URL de mi
repositorio en GitHub.Si al llegar aquí ya no tienes archivos pendientes, primero pídele al agente un cambio pequeño (por ejemplo, agregar en
app.pyun pie de página con la fecha de la última actualización) y después usa el Prompt 3.
.venv.app-estadistica-agricola/
├── README.md ← datos del estudiante, huella, hallazgos del EDA
├── .gitignore ← creado por el agente (excluye .venv/)
├── requirements.txt ← creado por el agente
├── .vscode/settings.json ← intérprete .venv/bin/python
├── generar_datos.py ← Anexo A (con tu código)
├── app.py ← página de Inicio
├── src/
│ ├── __init__.py
│ └── eda.py ← funciones reutilizables
├── pages/
│ ├── 1_Datos.py
│ ├── 2_EDA.py
│ ├── 3_Regresion.py ← en construcción (próxima actividad)
│ └── 4_Series_de_tiempo.py ← en construcción (final del semestre)
├── datos/
│ ├── parcelas.csv clima_mensual.csv muestra10.csv metadatos.json
├── verificacion/
│ ├── verificar_muestra.py verificar_muestra.R RESULTADOS.md
├── evidencias/
│ ├── hoja_manuscrita.pdf captura_inicio.png captura_eda.png
└── BITACORA_IA.mdHistorial mínimo de commits: 3 [manual]
+ 2 [web] + 2 [agente], distribuidos en las
dos sesiones.
Escala de 0,0 a 5,0. Nota de la actividad = Σ (nota del criterio × peso), redondeada a un decimal.
| # | Criterio | Peso | Excelente (4,6–5,0) | Bueno (3,6–4,5) | Aceptable (3,0–3,5) | Insuficiente (0,0–2,9) |
|---|---|---|---|---|---|---|
| 1 | Repositorio e identificación | 10 % | Repositorio público app-estadistica-agricola; commits
firmados con el correo institucional; README con nombre, código, grupo,
cultivo, municipio y huella coincidente con el código |
Completo con un detalle menor (descripción o grupo faltante) | Falta un dato clave del README o el nombre del repositorio es distinto | Repositorio privado o inaccesible, sin datos del estudiante, o huella que no corresponde al código |
| 2 | Entorno de trabajo en el Codespace | 15 % | .gitignore correcto y .venv
no subido; requirements.txt con las 7
librerías; .vscode/settings.json con el intérprete; Prompt
1 registrado en la bitácora |
Un archivo con detalle menor (p. ej. falta una exclusión) | Falta uno de los archivos o .venv aparece subido |
Sin entorno virtual, sin .gitignore ni
requirements.txt |
| 3 | App de Streamlit (estructura y funcionamiento) | 20 % | Inicio, Datos y EDA completos con las 4 secciones; páginas de
Regresión y Series de tiempo preparadas; src/eda.py con
funciones documentadas; capturas que muestran la app funcionando con
sus datos |
Falta una sección del EDA o una página preparada | Varias secciones ausentes o la app solo funciona parcialmente | Sin app, app que no corresponde a sus datos o sin evidencia de funcionamiento |
| 4 | Análisis exploratorio e interpretación agronómica | 20 % | Hallazgos propios (6–10 líneas) con cifras y unidades: CV, atípicos, faltantes, efecto de riego y suelo, correlación más fuerte, y advertencia de que correlación ≠ causalidad | Hallazgos correctos pero incompletos (faltan 1–2 aspectos) | Hallazgos superficiales, sin cifras o genéricos | Sin hallazgos, o texto generado por IA sin relación con sus datos |
| 5 | Lápiz y Algoritmo (manuscrito + verificación Python y R) | 15 % | Predicción previa; tabla de desviaciones; media, mediana, \(s^2\), \(s\), CV, \(Q_1\), \(Q_3\), RIC, vallas, atípicos y medias por
riego correctos a mano; diagrama de caja dibujado;
RESULTADOS.md comparando manual, Python y R |
Cálculos correctos con un error menor de redondeo o sin predicción previa | Cálculo incompleto o con errores de procedimiento; verificación solo en un lenguaje | Ausente, no manuscrito o con una muestra distinta a la asignada |
| 6 | Control de versiones: panel y agente | 10 % | ≥ 3 commits [manual], ≥ 2 [web]
sincronizados con pull, ≥ 2 [agente]; mensajes
claros; trabajo distribuido en las dos sesiones |
Cumple el mínimo con algún mensaje poco descriptivo | Falta un tipo de commit (manual, web o agente) | Uno o dos commits con todo el trabajo, o subido con Upload files sin usar Git |
| 7 | Bitácora de IA y uso responsable de recursos | 10 % | Los 3 prompts exactos; qué aprobó, rechazó o corrigió y por qué; al menos un error detectado; reflexión honesta; declara que detuvo el Codespace | Bitácora completa pero con poco detalle en las correcciones | Bitácora genérica o incompleta | Sin bitácora |
| Lo que ves | Solución |
|---|---|
| No aparece el modo Agent | Recarga la página del Codespace y verifica que iniciaste sesión en Copilot con tu cuenta de GitHub |
| “You’ve reached your monthly chat/agent limit” | Se agotó la cuota gratuita: pega el prompt en otro asistente, crea los archivos a mano y anótalo en la bitácora |
.venv aparece en Control de código fuente |
Falta .venv/ en .gitignore: agrégalo
antes del commit |
| Push rechazado por “private email” | En Settings → Emails, desmarca Block command line pushes that expose my email |
| Push rechazado porque hay cambios en GitHub | Sync Changes (o git pull y luego
git push) |
ModuleNotFoundError al correr la app |
Usa .venv/bin/streamlit run app.py o activa el entorno
con source .venv/bin/activate |
| La app no abre | Pestaña Puertos → globo del puerto 8501 |
| El Codespace se detuvo solo | Es el idle timeout: vuelve a abrirlo, no se pierde nada |
generar_datos.py da error con mi código |
El código debe contener solo números y estar entre comillas:
"1102345678" |
generar_datos.pyModifica solo las líneas de codigo y
nombre.
"""
generar_datos.py
Genera los datos PERSONALIZADOS de tu app a partir de tu código estudiantil.
Asignatura: Estadística Aplicada con Python y R · Ingeniería Agrícola · Unisucre
NO modifiques nada, excepto las dos líneas marcadas con <--
"""
import hashlib # para calcular la "huella" única de tus datos
import json # para guardar los metadatos
from pathlib import Path
import numpy as np
import pandas as pd
# ------------------------------------------------------------------
# 0. Tus datos de identificación (ÚNICAS líneas que modificas)
# ------------------------------------------------------------------
codigo = "XXXXXXXXXX" # <-- tu código estudiantil completo, entre comillas
nombre = "Nombre Apellido" # <-- tus nombres y apellidos
semilla = int(codigo) % 2**32 # la semilla depende de tu código
rng = np.random.default_rng(semilla) # generador de números aleatorios
Path("datos").mkdir(exist_ok=True) # carpeta donde se guardan los CSV
# ------------------------------------------------------------------
# 1. Escenario asignado: cultivo y municipio
# ------------------------------------------------------------------
cultivos = { # cultivo: (rendimiento base en t/ha, escala de variación)
"Maíz": (4.5, 1.0), "Arroz": (5.5, 0.9), "Yuca": (18.0, 3.5),
"Ñame": (14.0, 3.0), "Ajonjolí": (0.9, 0.2), "Plátano": (12.0, 2.5),
"Frijol": (1.4, 0.3), "Sorgo": (3.8, 0.8)}
cultivo = list(cultivos)[semilla % len(cultivos)]
base, esc = cultivos[cultivo]
municipio = ["Sincelejo", "Corozal", "Sampués", "Los Palmitos",
"San Marcos", "Majagual", "Tolú", "Ovejas"][(semilla // 8) % 8]
# ------------------------------------------------------------------
# 2. parcelas.csv: una fila por parcela (para EDA y, luego, regresión)
# ------------------------------------------------------------------
n = 80 + semilla % 41 # entre 80 y 120 parcelas
suelo = rng.choice(["Franco", "Arcilloso", "Arenoso"], n, p=[0.45, 0.35, 0.20])
riego = rng.choice(["Sí", "No"], n, p=[0.4, 0.6])
dosis_N = rng.uniform(0, 180, n).round(0) # kg/ha de nitrógeno
lamina = np.where(riego == "Sí", rng.uniform(250, 600, n),
rng.uniform(100, 350, n)).round(0) # mm de agua recibida
mo = rng.normal(2.5, 0.8, n).clip(0.5, 5.0).round(2) # materia orgánica (%)
ph = rng.normal(6.2, 0.5, n).clip(4.8, 7.8).round(2) # pH del suelo
efecto_suelo = {"Franco": 0.25, "Arcilloso": 0.0, "Arenoso": -0.30}
rend = (base
+ esc * (0.9 * dosis_N / 180 + 0.8 * (lamina - 100) / 500 + 0.20 * (mo - 2.5))
- esc * 0.6 * (ph - 6.3) ** 2
+ esc * np.vectorize(efecto_suelo.get)(suelo)
+ rng.normal(0, 0.45 * esc, n))
rend = np.clip(rend, 0.2 * base, None)
atipicos = rng.choice(n, 2, replace=False) # 2 parcelas atípicas
rend[atipicos[0]] *= 1.9 # una muy alta
rend[atipicos[1]] *= 0.35 # una muy baja (plaga)
mo_con_faltantes = mo.astype(float)
mo_con_faltantes[rng.choice(n, 3 + semilla % 4, replace=False)] = np.nan # datos faltantes
parcelas = pd.DataFrame({
"parcela": [f"P{i:03d}" for i in range(1, n + 1)],
"suelo": suelo, "riego": riego,
"dosis_N": dosis_N, "lamina_riego": lamina,
"materia_organica": mo_con_faltantes, "ph": ph,
"rendimiento": rend.round(2)})
parcelas.to_csv("datos/parcelas.csv", index=False)
# ------------------------------------------------------------------
# 3. clima_mensual.csv: serie mensual 2015-2025 (para series de tiempo al final)
# ------------------------------------------------------------------
fechas = pd.date_range("2015-01-01", "2025-12-01", freq="MS")
mes = fechas.month.values
t = np.arange(len(fechas))
# régimen bimodal del Caribe: lluvias en abril-mayo y septiembre-noviembre
patron = np.array([15, 20, 45, 110, 160, 110, 90, 120, 160, 190, 130, 45])
precip = (patron[mes - 1] * rng.uniform(0.85, 1.15)
* rng.lognormal(0, 0.30, len(t))).round(1)
temp = (27.5 + 0.012 * t + 0.9 * np.cos(2 * np.pi * (mes - 3) / 12)
+ rng.normal(0, 0.35, len(t))).round(2)
pd.DataFrame({"fecha": fechas.strftime("%Y-%m-%d"),
"precipitacion_mm": precip,
"temperatura_c": temp}).to_csv("datos/clima_mensual.csv", index=False)
# ------------------------------------------------------------------
# 4. muestra10.csv: 10 parcelas para el cálculo A MANO (Lápiz y Algoritmo)
# ------------------------------------------------------------------
sin_atipicos = parcelas.drop(index=atipicos)
muestra10 = sin_atipicos.sample(9, random_state=semilla % 10_000)
muestra10 = pd.concat([muestra10, parcelas.loc[[atipicos[0]]]]) # incluye 1 atípico
muestra10 = muestra10[["parcela", "suelo", "riego", "rendimiento"]].sort_values("parcela")
muestra10.to_csv("datos/muestra10.csv", index=False)
# ------------------------------------------------------------------
# 5. Huella y metadatos
# ------------------------------------------------------------------
huella = hashlib.md5(f"{codigo}|{n}|{parcelas['rendimiento'].sum():.2f}".encode()
).hexdigest()[:8].upper()
meta = {"codigo": codigo, "nombre": nombre, "cultivo": cultivo,
"municipio": municipio, "n_parcelas": int(n), "huella": huella}
Path("datos/metadatos.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2),
encoding="utf-8")
print(f"Estudiante: {nombre} | Código: {codigo} | Huella: {huella}")
print(f"Cultivo: {cultivo} | Municipio: {municipio} | Parcelas: {n}")
print("\nMuestra de 10 parcelas para tu cálculo a mano:")
print(muestra10.to_string(index=False))Qué contiene cada archivo y para qué se usará en el semestre:
| Archivo | Contenido | Se usa en |
|---|---|---|
parcelas.csv |
80–120 parcelas con suelo, riego, dosis de N, lámina de riego, materia orgánica, pH y rendimiento | EDA (hoy) y regresión simple y múltiple (próximas actividades) |
clima_mensual.csv |
Precipitación y temperatura mensual 2015–2025 | Series de tiempo (final del semestre) |
muestra10.csv |
10 parcelas (incluye un atípico) | Lápiz y Algoritmo de hoy |
metadatos.json |
Nombre, código, cultivo, municipio, huella | Página de Inicio de la app |
verificacion/verificar_muestra.py
# verificar_muestra.py — Fase 2 del Lápiz y Algoritmo (verificación con Python)
# Ejecuta desde la raíz del repositorio: .venv/bin/python verificacion/verificar_muestra.py
import pandas as pd
m = pd.read_csv("datos/muestra10.csv") # 1. Leer las 10 parcelas asignadas
y = m["rendimiento"] # 2. Variable de interés (t/ha)
media = y.mean() # 3. Media aritmética
mediana = y.median() # 4. Mediana
var = y.var(ddof=1) # 5. Varianza muestral (divide entre n-1)
de = y.std(ddof=1) # 6. Desviación estándar muestral
cv = 100 * de / media # 7. Coeficiente de variación (%)
q1, q3 = y.quantile([0.25, 0.75]) # 8. Cuartiles (método tipo 7, igual que R)
ric = q3 - q1 # 9. Rango intercuartílico
li, ls = q1 - 1.5 * ric, q3 + 1.5 * ric # 10. Límites (vallas) de Tukey
atipicos = m.loc[(y < li) | (y > ls), "parcela"].tolist()
print(f"n = {len(y)} media = {media:.3f} mediana = {mediana:.3f}")
print(f"varianza = {var:.4f} desv. est. = {de:.4f} CV = {cv:.2f} %")
print(f"Q1 = {q1:.4f} Q3 = {q3:.4f} RIC = {ric:.4f}")
print(f"Límite inferior = {li:.4f} Límite superior = {ls:.4f} Atípicos: {atipicos}")
print("\nMedia por riego:")
print(m.groupby("riego")["rendimiento"].mean().round(3)) # 11. Media por grupoverificacion/verificar_muestra.R
(ejecutar en Posit Cloud)
# verificar_muestra.R — Fase 2 del Lápiz y Algoritmo (verificación con R)
# En Posit Cloud: sube datos/muestra10.csv al proyecto y ejecuta este script.
m <- read.csv("muestra10.csv") # 1. Leer las 10 parcelas asignadas
y <- m$rendimiento # 2. Variable de interés (t/ha)
media <- mean(y) # 3. Media
mediana <- median(y) # 4. Mediana
varianza <- var(y) # 5. Varianza muestral (n-1)
de <- sd(y) # 6. Desviación estándar
cv <- 100 * de / media # 7. CV (%)
q <- quantile(y, c(0.25, 0.75), type = 7) # 8. Cuartiles tipo 7
ric <- q[2] - q[1] # 9. Rango intercuartílico
li <- q[1] - 1.5 * ric; ls <- q[2] + 1.5 * ric # 10. Vallas de Tukey
cat("n =", length(y), " media =", round(media, 3), " mediana =", round(mediana, 3), "\n")
cat("varianza =", round(varianza, 4), " desv. est. =", round(de, 4), " CV =", round(cv, 2), "%\n")
cat("Q1 =", round(q[1], 4), " Q3 =", round(q[2], 4), " RIC =", round(ric, 4), "\n")
cat("Lím. inf. =", round(li, 4), " Lím. sup. =", round(ls, 4), "\n")
cat("Atípicos:", m$parcela[y < li | y > ls], "\n")
print(tapply(y, m$riego, mean)) # 11. Media por riego
boxplot(y, horizontal = TRUE, main = "Rendimiento (t/ha) - muestra de 10 parcelas")verificacion/RESULTADOS.md
(plantilla)
# Verificación del Lápiz y Algoritmo — Muestra de 10 parcelas
| Medida | A mano | Python | R | ¿Coincide? |
|---------------------|--------|--------|------|------------|
| Media (t/ha) | | | | |
| Mediana (t/ha) | | | | |
| Varianza | | | | |
| Desv. estándar | | | | |
| CV (%) | | | | |
| Q1 | | | | |
| Q3 | | | | |
| RIC | | | | |
| Límite inferior | | | | |
| Límite superior | | | | |
| Parcela(s) atípica(s)| | | | |
| Media riego "Sí" | | | | |
| Media riego "No" | | | | |
## ¿Se cumplió mi predicción previa?
(2–3 líneas)
## Diferencias encontradas y su causa
(si no hubo, escribe "Ninguna, solo redondeo")README.md# App de Estadística Aplicada con Python y R — Ingeniería Agrícola (Unisucre)
**Estudiante:** Nombres y apellidos
**Código:** XXXXXXXXXX · **Grupo:** 1 / 2
**Cultivo asignado:** ______ · **Municipio:** ______ · **Huella:** ________
**Docente:** Justo Fuentes · **Semestre:** 2026-2
## Descripción
App de Streamlit para el análisis estadístico de parcelas agrícolas.
Páginas: Inicio · Datos · EDA · Regresión (próximamente) · Series de tiempo (próximamente).
## Cómo ejecutarla
1. Abrir el repositorio en un Codespace.
2. `python -m venv .venv && .venv/bin/pip install -r requirements.txt`
3. `.venv/bin/streamlit run app.py`
## Hallazgos del EDA
(6–10 líneas escritas por ti, con cifras y unidades)BITACORA_IA.md# Bitácora de uso de IA
**Herramienta:** GitHub Copilot (modo Agent) · **Modelo mostrado en el chat:** ______
## Prompt 1 — Entorno virtual, .gitignore y requirements.txt
- Prompt usado (texto exacto):
- Comandos que aprobé:
- Comandos o cambios que rechacé o corregí, y por qué:
## Prompt 2 — App de Streamlit
- Prompt usado (texto exacto):
- ¿Funcionó al primer intento? ¿Qué errores aparecieron y cómo se corrigieron?
- ¿Coincidió la sección "Muestra de 10 parcelas" con mi cálculo a mano?
## Prompt 3 — Actualización del repositorio
- Prompt usado (texto exacto):
- Commits que creó el agente:
## Reflexión (5–6 líneas)
- ¿Qué aprendí haciéndolo yo mismo que no habría aprendido si el agente lo hacía todo?
- ¿En qué se equivocó o podría equivocarse la IA?
- ¿Detuve el Codespace al terminar cada sesión? (Sí / No)