La ciencia de datos usa funciones para convertir datos crudos en información útil. Una función puede limpiar valores, calcular métricas, transformar escalas, detectar anomalías o preparar datos para un modelo.
En programación, trabajar con datos significa aplicar muchas transformaciones pequeñas y controladas. Por eso las funciones son una herramienta central: permiten repetir procesos, probarlos y combinarlos.
Muchos análisis comienzan con una lista de valores. Una función puede recorrer esa lista y producir un resumen.
function contarDatos(datos) {
return datos.length;
}
const edades = [18, 22, 25, 31, 40];
console.log("Cantidad de datos:", contarDatos(edades));Antes de calcular métricas conviene conocer cuántos datos tenemos y si la lista está vacía.
El promedio es una medida básica de tendencia central. Se calcula sumando los valores y dividiendo por la cantidad de datos.
function suma(datos) {
return datos.reduce((total, valor) => total + valor, 0);
}
function promedio(datos) {
if (datos.length === 0) {
return 0;
}
return suma(datos) / datos.length;
}
const ventas = [120, 180, 90, 210, 160];
console.log("Promedio:", promedio(ventas));El mínimo y el máximo permiten conocer el rango de los datos. Son útiles para validar valores y preparar escalas gráficas.
function minimo(datos) {
return Math.min(...datos);
}
function maximo(datos) {
return Math.max(...datos);
}
const temperaturas = [21.5, 19.2, 24.8, 18.9, 23.1];
console.log("Mínimo:", minimo(temperaturas));
console.log("Máximo:", maximo(temperaturas));El rango mide la diferencia entre el valor máximo y el mínimo. Es una forma simple de observar dispersión.
function rango(datos) {
return Math.max(...datos) - Math.min(...datos);
}
const mediciones = [12, 18, 15, 30, 21];
console.log("Rango:", rango(mediciones));Filtrar significa conservar solamente los datos que cumplen una condición. En ciencia de datos se usa para quitar registros inválidos o seleccionar subconjuntos.
function filtrarMayoresOIguales(datos, limite) {
return datos.filter(valor => valor >= limite);
}
const puntajes = [45, 82, 77, 30, 91, 65];
const aprobados = filtrarMayoresOIguales(puntajes, 60);
console.log(aprobados);Los datos reales pueden tener valores faltantes. Una función de limpieza puede quitarlos antes de calcular estadísticas.
function quitarNulos(datos) {
return datos.filter(valor => valor !== null && valor !== undefined);
}
const datos = [10, null, 15, undefined, 20, 0];
console.log(quitarNulos(datos));El valor 0 no debe eliminarse si representa una medición válida.
Otra estrategia es reemplazar valores faltantes por un valor calculado, como el promedio.
function promedio(datos) {
const validos = datos.filter(valor => valor !== null && valor !== undefined);
return validos.reduce((total, valor) => total + valor, 0) / validos.length;
}
function completarFaltantes(datos) {
const valorPromedio = promedio(datos);
return datos.map(valor => valor === null || valor === undefined ? valorPromedio : valor);
}
const datos = [8, null, 10, 12, undefined];
console.log(completarFaltantes(datos));Un conjunto de registros suele representarse como una lista de objetos. Las funciones pueden crear nuevas columnas a partir de las existentes.
function agregarTotal(registros) {
return registros.map(registro => ({
...registro,
total: registro.precio * registro.cantidad
}));
}
const ventas = [
{ producto: "A", precio: 100, cantidad: 3 },
{ producto: "B", precio: 80, cantidad: 5 }
];
console.log(agregarTotal(ventas));Normalizar valores permite llevarlos a una escala común. La normalización min-max convierte valores al intervalo de 0 a 1.
function normalizarMinMax(datos) {
const min = Math.min(...datos);
const max = Math.max(...datos);
return datos.map(valor => (valor - min) / (max - min));
}
const alturas = [150, 165, 180, 190];
console.log(normalizarMinMax(alturas));La estandarización convierte valores en cuántas desviaciones estándar se alejan del promedio. Es común en modelos estadísticos y aprendizaje automático.
function promedio(datos) {
return datos.reduce((total, valor) => total + valor, 0) / datos.length;
}
function desviacionEstandar(datos) {
const media = promedio(datos);
const varianza = promedio(datos.map(valor => (valor - media) ** 2));
return Math.sqrt(varianza);
}
function estandarizar(datos) {
const media = promedio(datos);
const desviacion = desviacionEstandar(datos);
return datos.map(valor => (valor - media) / desviacion);
}
console.log(estandarizar([10, 12, 14, 16]));La mediana es el valor central cuando los datos están ordenados. Es más resistente a valores extremos que el promedio.
function mediana(datos) {
const ordenados = [...datos].sort((a, b) => a - b);
const mitad = Math.floor(ordenados.length / 2);
if (ordenados.length % 2 === 0) {
return (ordenados[mitad - 1] + ordenados[mitad]) / 2;
}
return ordenados[mitad];
}
console.log(mediana([9, 2, 15, 4, 7]));
console.log(mediana([9, 2, 15, 4]));Contar frecuencias permite saber cuántas veces aparece cada categoría o valor.
function contarFrecuencias(datos) {
const frecuencias = {};
for (const valor of datos) {
frecuencias[valor] = (frecuencias[valor] || 0) + 1;
}
return frecuencias;
}
const categorias = ["A", "B", "A", "C", "B", "A"];
console.log(contarFrecuencias(categorias));Agrupar registros por una propiedad permite calcular resúmenes por categoría, ciudad, producto, usuario o período.
function agruparPor(registros, campo) {
return registros.reduce((grupos, registro) => {
const clave = registro[campo];
grupos[clave] = grupos[clave] || [];
grupos[clave].push(registro);
return grupos;
}, {});
}
const ventas = [
{ ciudad: "Córdoba", monto: 120 },
{ ciudad: "Rosario", monto: 90 },
{ ciudad: "Córdoba", monto: 150 }
];
console.log(agruparPor(ventas, "ciudad"));Después de agrupar, es común calcular totales por categoría. Esta operación resume muchos registros en pocos resultados.
function sumarPorGrupo(registros, campoGrupo, campoValor) {
return registros.reduce((totales, registro) => {
const grupo = registro[campoGrupo];
totales[grupo] = (totales[grupo] || 0) + registro[campoValor];
return totales;
}, {});
}
const ventas = [
{ producto: "A", monto: 100 },
{ producto: "B", monto: 80 },
{ producto: "A", monto: 40 }
];
console.log(sumarPorGrupo(ventas, "producto", "monto"));Un valor atípico se aleja demasiado del comportamiento general. Una regla simple es comparar cada dato con el promedio y la desviación estándar.
function promedio(datos) {
return datos.reduce((total, valor) => total + valor, 0) / datos.length;
}
function desviacionEstandar(datos) {
const media = promedio(datos);
const varianza = promedio(datos.map(valor => (valor - media) ** 2));
return Math.sqrt(varianza);
}
function detectarAtipicos(datos, limite) {
const media = promedio(datos);
const desviacion = desviacionEstandar(datos);
return datos.filter(valor => Math.abs(valor - media) > limite * desviacion);
}
console.log(detectarAtipicos([10, 11, 9, 12, 100], 2));La correlación mide si dos variables tienden a variar juntas. Un cálculo simplificado puede ayudar a entender la relación entre dos listas de datos.
function promedio(datos) {
return datos.reduce((total, valor) => total + valor, 0) / datos.length;
}
function correlacion(x, y) {
const mediaX = promedio(x);
const mediaY = promedio(y);
let numerador = 0;
let sumaX = 0;
let sumaY = 0;
for (let i = 0; i < x.length; i++) {
const dx = x[i] - mediaX;
const dy = y[i] - mediaY;
numerador += dx * dy;
sumaX += dx * dx;
sumaY += dy * dy;
}
return numerador / Math.sqrt(sumaX * sumaY);
}
console.log(correlacion([1, 2, 3, 4], [2, 4, 6, 8]));Una función lineal puede usarse como modelo muy simple de predicción. La forma general es y = m · x + b.
function predecirLineal(x, pendiente, intercepto) {
return pendiente * x + intercepto;
}
const horasEstudio = 6;
const notaEstimada = predecirLineal(horasEstudio, 8, 35);
console.log("Nota estimada:", notaEstimada);Para evaluar un modelo se compara lo predicho con lo real. El error absoluto medio resume esa diferencia.
function errorAbsolutoMedio(reales, predichos) {
let total = 0;
for (let i = 0; i < reales.length; i++) {
total += Math.abs(reales[i] - predichos[i]);
}
return total / reales.length;
}
const reales = [100, 120, 90, 150];
const predichos = [95, 130, 85, 140];
console.log("Error medio:", errorAbsolutoMedio(reales, predichos));Antes de dibujar una visualización, los datos suelen transformarse a coordenadas, porcentajes o tamaños.
function mapear(valor, minOrigen, maxOrigen, minDestino, maxDestino) {
const proporcion = (valor - minOrigen) / (maxOrigen - minOrigen);
return minDestino + proporcion * (maxDestino - minDestino);
}
function prepararBarras(datos, altoMaximo) {
const max = Math.max(...datos);
return datos.map(valor => ({
valor,
alto: mapear(valor, 0, max, 0, altoMaximo)
}));
}
console.log(prepararBarras([10, 25, 40], 200));Un flujo de ciencia de datos suele aplicar varias funciones en secuencia: limpiar, filtrar, transformar y resumir.
function quitarNulos(datos) {
return datos.filter(valor => valor !== null && valor !== undefined);
}
function soloPositivos(datos) {
return datos.filter(valor => valor > 0);
}
function promedio(datos) {
return datos.reduce((total, valor) => total + valor, 0) / datos.length;
}
const datos = [10, null, -5, 20, undefined, 30];
const resultado = promedio(soloPositivos(quitarNulos(datos)));
console.log(resultado);Las funciones en ciencia de datos se usan para:
Al analizar datos conviene evitar estos problemas:
Las funciones permiten convertir datos en conocimiento paso a paso. Cada operación clara y pequeña hace que el análisis sea más confiable, fácil de revisar y reutilizable.
En ciencia de datos, programar bien no consiste solo en obtener un resultado, sino en construir un proceso comprensible: limpiar, transformar, resumir, comparar y validar.