Datos reales de Colombia con Python

datos.gov.co es el portal oficial de datos abiertos del Estado colombiano. Ministerios, alcaldías, gobernaciones y entidades públicas publican allí tablas que cualquier persona puede descargar y usar sin pedir permiso y sin pagar. Eso es lo que significa datos abiertos: información pública, en formato que un computador puede procesar, con licencia libre de uso.

No todos los conjuntos sirven igual para empezar. Busca uno que cumpla tres condiciones:

• Tamaño manejable. Unas pocas decenas de miles de filas está bien; si el portal te avisa que son millones de registros, déjalo para después.
• Al menos una columna de texto para agrupar: municipio, departamento, entidad, categoría, año. Es la que va a formar las barras de tu gráfica.
• Al menos una columna numérica: cantidad, monto, número de personas, número de casos. Es lo que vas a sumar o promediar.

En el buscador del portal escribe un tema que de verdad te interese: matrícula, bicicletas, turismo, presupuesto, animales, accidentes. Abre el conjunto, mira la vista previa y revisa la fecha de actualización. Cuando te decidas, busca la opción de exportar o descargar y escoge CSV.

Un CSV (comma-separated values, valores separados por comas) es un archivo de texto plano donde cada línea es una fila y las columnas van separadas por comas o por punto y coma. Es feo de mirar pero es el formato más universal que existe: lo lee Excel, lo lee Python, lo lee cualquier cosa.

Sé honesto contigo desde ya: los datos abiertos no son datos limpios. Es normalísimo que en una misma columna aparezcan "BOGOTÁ D.C.", "Bogota" y "BOGOTA DC" como si fueran tres ciudades distintas, que haya celdas vacías, o que la columna de pesos venga con signo de peso y puntos de miles. Limpiar eso no es un castigo: es el 70% del trabajo real de cualquier analista de datos.

Google Colab (colab.research.google.com) es un cuaderno de Python que corre en el navegador, gratis, con tu cuenta de Google. Sirve desde un computador y también desde el celular, aunque escribir código en pantalla pequeña es incómodo. No instalas nada: el computador que ejecuta el código es de Google.

Crea un cuaderno nuevo. En el panel izquierdo hay un ícono de carpeta: ahí subes tu CSV arrastrándolo. Queda guardado en la ruta /content/tu_archivo.csv.

Ahora entra pandas, la librería de Python para trabajar con tablas. Una librería es código que otras personas ya escribieron y tú reutilizas. Pandas ya viene instalada en Colab.

import pandas as pd

df = pd.read_csv("/content/tu_archivo.csv")
print(df.shape)
df.head()

import pandas as pd carga la librería y le pone el apodo pd (es la convención mundial, no la cambies). read_csv lee el archivo y devuelve un DataFrame: una tabla en memoria, con filas y columnas, que guardamos en la variable df. df.shape te dice cuántas filas y columnas tiene, y df.head() muestra las primeras cinco filas.

Dos cosas fallan casi siempre la primera vez:

• Sale todo en una sola columna. El archivo usa punto y coma como separador. Solución: pd.read_csv(ruta, sep=";").
• Las tildes salen como é o Bogotá. El archivo no está guardado en UTF-8. Solución: pd.read_csv(ruta, encoding="latin-1"). La codificación es la tabla que traduce bytes a letras; si Python usa la equivocada, las tildes se rompen.

Después corre df.info(). Te muestra cada columna, cuántos valores no nulos tiene (un valor nulo, NaN, es una celda vacía) y su tipo: object es texto, int64 y float64 son números. Esta línea vale oro: aquí descubres que tu columna de plata es texto y no número.

Limpiar no es hacer todo perfecto: es dejar utilizables las dos o tres columnas que vas a usar. Estos cuatro pasos resuelven la mayoría de casos.

a) Nombres de columna decentes. Vienen con mayúsculas, espacios y tildes, y eso te obliga a escribir df["Nombre del Municipio "]. Normalízalos:

df.columns = (df.columns.str.strip()
                        .str.lower()
                        .str.replace(" ", "_", regex=False))
print(list(df.columns))

.str.strip() quita espacios de sobra a los lados, .str.lower() pasa a minúsculas y .str.replace cambia espacios por guiones bajos.

b) Filas repetidas. df = df.drop_duplicates(). Compara df.shape antes y después: si bajó mucho, investiga, porque a veces los duplicados son legítimos.

c) Texto inconsistente. Esta es la trampa grande. Si la misma ciudad aparece escrita de tres formas, tu conteo queda partido en tres. Empieza por unificar espacios y mayúsculas y mira qué queda:

df["municipio"] = df["municipio"].str.strip().str.upper()
print(df["municipio"].value_counts().head(15))

value_counts() cuenta cuántas veces aparece cada valor. Si ves "BOGOTA" y "BOGOTA D.C." como entradas separadas, únelas con df["municipio"] = df["municipio"].replace({"BOGOTA D.C.": "BOGOTA"}).

d) Números que son texto. Si df.info() dice que tu columna numérica es object, conviértela:

df["valor"] = pd.to_numeric(df["valor"], errors="coerce")
print(df["valor"].isna().sum())

errors="coerce" convierte a NaN lo que no logre volver número, en vez de reventar. Por eso la segunda línea es obligatoria: te dice cuántos datos perdiste. Si perdiste 12 de 40.000, sigue tranquilo; si perdiste 15.000, algo está mal (quizás la columna trae $ y puntos de miles y toca quitarlos primero). Al final, df = df.dropna(subset=["valor"]) elimina las filas sin valor numérico.

Regla de oro: cada vez que botes datos, cuenta cuántos botaste y anótalo. Un análisis honesto dice qué dejó por fuera.

Una tabla de 40.000 filas no le dice nada a nadie. Lo que comunica es un resumen. La operación clave se llama agrupar: juntar todas las filas que comparten un valor (por ejemplo, el mismo departamento) y calcular algo con ellas.

resumen = (df.groupby("departamento")["valor"]
             .sum()
             .sort_values(ascending=False)
             .head(10))
print(resumen)

Léelo en español: agrupa por departamento, toma la columna valor, súmala, ordena de mayor a menor y quédate con los 10 primeros. Cambia .sum() por .mean() si el promedio tiene más sentido (montos por persona, notas, edades), o por .count() si lo que te interesa es cuántos registros hay.

Cuidado con una decisión que mucha gente ignora: sumar y promediar responden preguntas distintas. Antioquia puede liderar en total simplemente porque tiene más habitantes; eso no significa que le vaya mejor por persona.

Ahora la gráfica, con matplotlib, la librería estándar de Python para dibujar:

import matplotlib.pyplot as plt

resumen.sort_values().plot(kind="barh", figsize=(8, 5))
plt.title("Top 10 departamentos por valor total")
plt.xlabel("Valor total")
plt.ylabel("")
plt.tight_layout()
plt.show()

kind="barh" hace barras horizontales, ideales cuando las etiquetas son nombres largos como "NORTE DE SANTANDER". El .sort_values() extra antes de graficar es un truco: en barras horizontales matplotlib dibuja el primer elemento abajo, así que reordenando ascendente la barra más grande queda arriba. figsize es el tamaño en pulgadas y tight_layout() evita que los nombres queden cortados.

Tres reglas para que tu gráfica no engañe: siempre título, siempre nombre en el eje numérico con la unidad (pesos, personas, casos) y nunca más de 10 o 12 barras, porque después nadie las lee. Si quieres guardar la imagen para tu trabajo, agrega plt.savefig("grafica.png", dpi=150) antes de plt.show() y descárgala del panel de archivos de Colab.

Aquí es donde la IA ayuda de verdad y donde también es más peligrosa. Un modelo de lenguaje puede alucinar: afirmar con toda seguridad cifras, causas o normas que no existen. Si le pides "analiza mis datos" sin más, es muy probable que te entregue párrafos bonitos con datos falsos.

La técnica es simple: dale tú los números, no se los pidas a él. Copia la salida de resumen (son 10 líneas de texto) y pégala en el chat. Ahora el modelo no tiene que adivinar nada, solo redactar sobre lo que le diste.

Un buen prompt tiene cuatro partes: qué datos son, de dónde salieron, qué limpiaste, y qué quieres que haga con límites explícitos:

> "Estos son los resultados de agrupar un conjunto de datos abiertos de datos.gov.co sobre [tema], publicado por [entidad], con datos de [años]. Agrupé por departamento y sumé la columna [valor]. Eliminé 320 filas de 40.000 que no tenían valor numérico. Resultados: [pega las 10 líneas]. Escríbeme 3 conclusiones que se puedan sostener SOLO con estos números. No inventes causas ni cifras que no estén aquí. Para cada conclusión, dime qué otro dato necesitaría para confirmarla."

Esa última frase es la más valiosa: te obliga a distinguir entre lo que muestran los datos y lo que tú supones.

Después viene tu trabajo, que no es delegable: verificar. Si la IA dice "Antioquia lidera con 3,2 millones", vuelve a tu tabla y confírmalo. Si dice "esto se debe a la inversión en infraestructura", bórralo: esa causa no está en tus datos. Correlación no es causalidad; que dos cosas suban juntas no prueba que una cause la otra.

Y recuerda dos límites más: los datos abiertos reflejan lo que la entidad decidió registrar, así que un departamento con pocos registros puede tener poca ocurrencia o poca capacidad de reporte (eso es sesgo); y aunque sean públicos, si un archivo trae nombres o cédulas de personas, no lo pegues en un chat de IA.