Introducción

A continuación, encontrarás una guía de estudio que abarca tanto conceptos fundamentales de calidad y confiabilidad de datos, como prácticas de limpieza, imputación y manipulación de información en entornos de Python. Estos temas son clave en la ciencia de datos y en cualquier proyecto de análisis, pues garantizan que los datos con los que se trabaja sean consistentes, completos y confiables.

En la guía se profundiza en la terminología básica (confiabilidad, durabilidad, seguridad y disponibilidad de los datos), así como en procesos y herramientas necesarios para preparar la información antes de su análisis, como la detección de inconsistencias, la imputación estadística y la limpieza de valores nulos.

También se detalla el uso de estructuras de datos (listas, tuplas, diccionarios y DataFrames) y librerías en Python (Pandas, NumPy, Matplotlib, os, scikit-learn), imprescindibles para la manipulación, exploración y visualización de la información. Finalmente, se incluyen ejemplos de funciones y métodos (dropna, fillna, read_excel, describe, info, etc.) para ilustrar de manera práctica los conceptos abordados.

Esta guía te servirá como referencia y apoyo para tu estudio, asegurando que no solo conozcas los fundamentos teóricos, sino también cómo aplicarlos de forma directa en Python. Con ello, podrás enfrentar con solvencia tareas de limpieza y tratamiento de datos para obtener resultados precisos y confiables en tus proyectos o exámenes.

1. Conceptos de Confiabilidad, Durabilidad, Seguridad y Disponibilidad de los datos

1. Confiabilidad
   1. Se refiere a la exactitud y consistencia de la información.
   2. Un sistema confiable produce resultados correctos o sin errores de manera constante.
   3. A nivel de datos, implica que los registros estén completos y correctos.
2. Durabilidad
   1. Asegura que los datos persistan o permanezcan a lo largo del tiempo.
   2. Si los datos han sido guardados, estos no deben perderse por fallas, errores o apagones.
   3. Frecuentemente asociado a copias de seguridad (backups) o mecanismos de replicación.
3. Seguridad
   1. Garantiza que los datos estén protegidos frente a accesos no autorizados o modificaciones indebidas.
   2. Incluye aspectos como cifrado, autenticación, autorización de usuarios, firewalls, entre otros.
4. Disponibilidad
   1. Significa que el acceso a los datos (o el servicio que los gestiona) está garantizado cuando se necesita.
   2. Un sistema con alta disponibilidad casi siempre estará “activo” o accesible para su consulta o actualización.

2. Definición de calidad de los datos

La calidad de los datos se refiere al grado en que los datos son aptos para su uso. Normalmente se evalúan ciertos criterios:

• Exactitud: qué tan correctos o cercanos a la verdad son los datos o representan fielmente la realidad.
• Consistencia: que no haya conflictos o duplicados en la información. Por ejemplo: no debe haber contradicciones (un registro no dice “Edad=30” y “Fecha de nacimiento=2023”).
• Completitud: que no haya valores faltantes o nulos.
• Valor agregado o Relevancia: que los datos realmente sirvan para el análisis requerido.
• Actualidad o “timeless”: que estén al día o actualizados.
• Credibilidad: que provengan de fuentes confiables.
• Interpretabilidad: Trata sobre lo fácil que resulta comprenderlos datos y su significado.
• Accesibilidad: que se tengan los permisos para utilizarlos
• Intrínsecos: Se refiere a las propiedades internas de los datos, independientemente de su uso o contexto. Incluye aspectos como: exactitud, validez, consistencia interna (que no haya contradicciones), completitud (que no falten registros indispensables) y confiabilidad (que los datos reflejen fielmente la realidad o la fuente).
• Contextuales: Evalúa si los datos son “adecuados” o “aptos” para el uso específico que se les quiere dar.
• Representacionales: Se relaciona con la forma en que están estructurados o presentados los datos. Incluye la consistencia en el formato, claridad en la codificación, estandarización (p. ej. usar el mismo formato de fecha, separador decimal, nombre de columnas).

Mientras más alta la calidad, más confiables serán los resultados de los análisis y modelos que usemos.

3. Definición de limpieza de datos

La limpieza de datos (data cleaning) es el proceso mediante el cual se identifican y corrigen errores, inconsistencias, valores faltantes (nulos) o valores atípicos en un conjunto de datos. Su objetivo es mejorar la calidad de la información para que sea útil en análisis, modelos estadísticos o de aprendizaje automático.

Dentro de la limpieza de datos se incluyen actividades como:

• Eliminar valores duplicados.
• Corregir valores inconsistentes (ej., “México” vs. “mexico”).
• Imputar o eliminar datos faltantes.
• Ajustar tipos de datos (por ejemplo, convertir strings a fechas).

• Encontrar y corregir errores en campos numéricos,
• Manejar valores ausentes (NaN o None).

El propósito es mejorar la calidad de la información para que los análisis o modelos estadísticos/ML que se basen en estos datos sean más confiables.

4. Reglas para la identificación de inconsistencias

Para identificar inconsistencias, se pueden establecer reglas de negocio o revisiones lógicas. Ejemplos:

• Campos que deben tener un valor dentro de un rango (ej., edad > 0 y < 120).
• Verificar la coherencia entre dos columnas (ej., si el país es “México”, el código de estado debe ser uno válido para México).
• Fechas que no estén en un rango de tiempo imposible (ej., nacimiento en el año 1800 de un estudiante actual).

En Python/Pandas, a menudo se usan filtros booleanos para detectar estas inconsistencias. Por ejemplo:

# En el siguiente código se obtiene un dataframe con los registros que tiene un campo o columna

# llamado edad, y que sus valores son menores a 0 y mayores a 120.

df_inconsistente = df[(df[‘edad’] < 0) | (df[‘edad’] > 120)]

Proceso para identificación de inconsistencias.

Para identificar inconsistencias en un conjunto de datos, es útil seguir un proceso sistemático que combine la definición de reglas (de negocio o de validación) con un análisis exploratorio y diversas técnicas de detección de anomalías. A continuación, se describe un proceso sugerido, paso a paso:

1. Definir las reglas o criterios de calidad

1. Especificar reglas de negocio
   • Ejemplo: la columna “edad” no puede ser negativa ni mayor a 120.
   • Ejemplo: si “país” = “México”, entonces el “estado” debe ser uno válido en México.
   • Estas reglas te orientan sobre qué condiciones deben cumplir (o no) los datos.
2. Conocer los tipos de datos y rangos esperados
   • Saber si un campo debe ser numérico, texto, fecha, etc.
   • Definir rangos o categorías válidas (por ejemplo, columnas con un listado finito de valores).
3. Establecer relaciones entre columnas
   • Dependencias (por ejemplo, si fecha de egreso < fecha de ingreso = inconsistencia).
   • Coordenadas (latitud y longitud) que deben seguir un rango geográfico válido.

2. Cargar y revisar los datos (exploración inicial)

1. Lectura de datos
   • Usar, por ejemplo, pd.read_csv() o pd.read_excel() para cargar la información a un DataFrame de Pandas.
2. Vista general
   • df.head() y df.tail() para observar las primeras y últimas filas.
   • df.shape para saber cuántas filas y columnas hay.
3. Información básica
   • df.info() para ver tipos de datos y cuántos valores no nulos hay.
   • df.describe() para obtener estadísticas descriptivas (mínimo, máximo, media, percentiles, etc.).

3. Detección de valores atípicos (outliers) o inválidos

1. Valores fuera de rango
   • Aplicar filtros lógicos para encontrar valores que no cumplan el criterio:

df_inconsistentes = df[(df[‘edad’] < 0) | (df[‘edad’] > 120)]

1. Revisar si en columnas con fechas hay algún valor fuera de un rango posible.
2. Verificación de tipos
   • Asegurarse de que columnas que deben ser numéricas no contengan valores de texto.
   • Intentar convertir tipos (por ejemplo, a datetime):

df[‘fecha’] = pd.to_datetime(df[‘fecha’], errors=’coerce’)

Si aparecen muchos NaT (not a time), significa que hay inconsistencias de formato.

3. Análisis estadístico de outliers
   • Usar estadísticas como la desviación estándar (std), el rango intercuartil (IQR) o métodos de detección automatizados (p.ej., z-score).
   • df[‘col’].describe() y graficar histogramas o boxplots para visualizar valores atípicos.

4. Revisión de consistencia entre columnas

1. Reglas de correspondencia
   • Ejemplo: si df[‘estado’] = ‘Nuevo León’, entonces df[‘país’] debería ser “México”. Filtrar filas que no cumplan esto.
   • Ejemplo: “fecha de inicio” debe ser anterior a “fecha de fin”.
2. Verificación cruzada
   • Hacer conteos de valores combinados (por ejemplo, df.groupby([‘colA’, ‘colB’]).size()) para detectar registros que no tengan sentido juntos.
3. Búsqueda de duplicados
   • df.duplicated() y df[df.duplicated()] muestran registros que aparecen más de una vez.
   • Decidir si es inconsistencia (datos repetidos) o si puede haber registros legítimamente iguales.

5. Detección de faltantes e inconsistencias en formatos

1. Valores nulos
   • Revisar cuántos nulos hay por columna: df.isnull().sum().
   • Evaluar si esto es esperado o no (por ejemplo, si la columna es obligatoria pero está vacía en muchos registros).
2. Formatos no estándar
   • Revisar si, por ejemplo, en una columna de texto esperas solo letras pero aparecen números o caracteres extraños.
   • Normalizar texto (ejemplo: “México” vs. “mexico” vs. “MEXICO”).
3. Códigos o categorías incorrectas
   • Si esperas categorías como “Hombre”/“Mujer”, verificar que no aparezca “hmbre”, “F”, etc.
   • Corregir o etiquetar como inconsistente.

6. Consolidar y documentar las inconsistencias

1. Crear un DataFrame o reporte de inconsistencias
   • Por cada regla fallida (ej. edad fuera de rango, país-estado no coincidentes, duplicados, etc.), generar un dataframe filtrado con esos casos.
   • Etiquetar el tipo de inconsistencia y la cantidad de registros afectados.
2. Análisis de impacto
   • Cuántos y cuáles registros se ven afectados por cada inconsistencia.
   • Priorizar la corrección según la relevancia de la columna o la proporción de datos afectados.

7. Acciones de limpieza o corrección

Una vez identificadas las inconsistencias:

1. Corrección manual o automática
   • Depende de los recursos y del volumen de datos.
   • A veces se corrige manualmente un valor atípico si es un error evidente; en otros casos, se definen reglas automatizadas.
2. Eliminación de registros
   • Solo si la inconsistencia es grave y no hay forma de corregirla.
   • Por ejemplo, si un registro tiene casi todas las columnas nulas.
3. Imputación de valores
   • En caso de faltantes, usar métodos estadísticos (media, mediana, etc.) o modelos (regresiones, KNN) para estimar valores.
4. Normalización/Transformación
   • Ajustar formatos (fechas, texto, mayúsculas/minúsculas) y convertir tipos de datos.

8. Validación final y documentación

1. Revisar nuevamente
   • Una vez corregidas o marcadas las inconsistencias, ejecutar de nuevo los filtros o métodos de detección para asegurar que no queden errores.
2. Documentar
   • Anotar las reglas utilizadas, los procedimientos de limpieza y cualquier supuesto que se haya aplicado.
   • Importante para la trazabilidad y reproducibilidad del proceso.

Ejemplo sencillo en Python/Pandas

import pandas as pd

import numpy as np

# 1. Creación o lectura del DataFrame

df = pd.DataFrame({

    ‘id’: [1, 2, 3, 4],

    ‘edad’: [25, -5, 130, 40],     # Inconsistencias (-5, 130)

    ‘pais’: [‘Mexico’, ‘mexico’, ‘MX’, ‘Alemania’],  # Diferentes formatos de México

    ‘estado’: [‘Nuevo Leon’, ‘Guerrero’, ‘Baviera’, ‘NRW’]

})

# 2. Definir reglas (ejemplo: edad debe estar entre 0 y 120)

df_edad_invalida = df[(df[‘edad’] < 0) | (df[‘edad’] > 120)]

# -> Filas con id 2 y 3 son inconsistentes en la columna edad

# 3. Verificar correspondencia ‘pais’-‘estado’

#   Suponiendo que ‘pais’ debe ser “Mexico” para que ‘estado’ sea un estado de México

mexican_states = [‘Nuevo Leon’, ‘Guerrero’, ‘Jalisco’, ‘Chihuahua’]  # etc.

df_estado_invalido = df[ (df[‘pais’].str.lower() == ‘mexico’) &

                         (~df[‘estado’].isin(mexican_states)) ]

# 4. Normalizar/Corregir

df.loc[df[‘pais’].str.lower() == ‘mexico’, ‘pais’] = ‘Mexico’

El ejemplo anterior ilustra una manera sencilla de filtrar y detectar algunos casos de inconsistencia.

5. Reglas de imputación

Las reglas de imputación describen el método específico que usaremos para rellenar valores faltantes. Algunas opciones comunes:

• Reemplazar valores nulos con un valor fijo (cero o texto “Desconocido”).
• Usar la media de la columna (si es variable numérica).
• Usar la moda (si es categórica).
• Usar interpolación (en datos de series temporales o secuencias).
• Aplicar un modelo predictivo (regresión, KNN, árboles de decisión, etc.).

La elección dependerá de la naturaleza de los datos y la justificación estadística.

6. Definición de imputación estadística

La imputación estadística es el proceso de reemplazar valores faltantes (o nulos) en un conjunto de datos con valores estimados (ej., la media, la mediana, la moda u otros métodos más avanzados). El objetivo es mantener la mayor cantidad de datos posible y evitar sesgos que pueden originarse si simplemente se eliminan las filas o columnas con datos faltantes.

Ejemplo básico en Python/Pandas:

import pandas as pd

import numpy as np

df = pd.DataFrame({

    ‘col1’: [10, np.nan, 30, 40],

    ‘col2’: [5, 2, np.nan, 8]

})

# Imputar con la media de col1

df[‘col1’].fillna(df[‘col1’].mean(), inplace=True)

# Filtrar filas con edad fuera del rango 0 a 120

7. Reglas de imputación estadística

Se refieren específicamente a métodos basados en métricas o modelos estadísticos. Entre los más comunes:

• Imputar con media (para datos numéricos).
• Imputar con mediana (menos sensible a valores atípicos).
• Imputar con moda (para datos categóricos).
• Interpolate (cuando los datos tienen un orden secuencial o temporal, se interpola basándose en valores adyacentes).
• Modelos estadísticos/ML (imputar usando un regresor o clasificador entrenado con las demás variables).

8. ¿Qué son los valores nulos? y ¿Qué valor tienen los valores nulos?

• Valores nulos: Son celdas o posiciones que no tienen un dato asignado. En Python/Pandas generalmente se representan como NaN (Not a Number) en datos numéricos, o None si es un objeto/estructura de Python.
• ¿Qué valor tienen?: Formalmente, el valor nulo es la ausencia de valor. No significa cero ni significa cadena vacía, sino “desconocido”.
• No deben confundirse con cero ni con cadena vacía; un valor nulo es la “ausencia” de un dato, algo desconocido.
• Un 0 en un campo tipo numérico no significa valor nulo.
• Estos valores no se pueden usar directamente en operaciones matemáticas sin antes tratarlos o imputarlos.

9. Borrado de registros con dropna(), dropna(subset=[‘valor’]) y en qué estructura se utiliza

• dropna() es una función de Pandas (DataFrame o Series).
• Cuando se llama sobre un DataFrame, elimina todas las filas o columnas que contengan valores nulos, dependiendo de los parámetros (axis=0 para filas, axis=1 para columnas, etc.).
• dropna(subset=[‘columna’]) elimina únicamente las filas donde la columna indicada sea nula.

Ejemplo:

import pandas as pd

df = pd.DataFrame({

    ‘A’: [1, None, 3],

    ‘B’: [4, 5, None]

})

# Eliminar filas con NAs en ‘B’

df.dropna(subset=[‘B’], inplace=True)

10. Uso de las diferentes estructuras: Listas, Tuplas, Diccionarios y DataFrames

Listas (list)

• Ordenadas, mutables, permiten elementos duplicados.
• [1, 2, 3, “texto”]

Tuplas (tuple)

• Ordenadas, inmutables, permiten duplicados.
• (1, 2, 3, “texto”)

Diccionarios (dict)

• Estructura de pares clave-valor.
• {“clave1”: valor1, “clave2”: valor2}
• Las claves son únicas y no mantienen necesariamente orden (en Python 3.7+ se respeta el orden de inserción, pero conceptualmente se manejan como desordenados).

DataFrames

• Estructura tabular de Pandas, muy usada en ciencia de datos.
• Organiza la información en filas y columnas, permitiendo etiquetas (nombres de columnas y de índice).
• Se puede convertir de listas, tuplas, y diccionarios a DataFrame y viceversa.

Ejemplos de conversión:

import pandas as pd

lista = [1, 2, 3]

df = pd.DataFrame(lista, columns=[‘numeros’])

# De un diccionario a DataFrame

dicc = {“nombre”: [“Ana”, “Juan”], “edad”: [23, 30]}

df = pd.DataFrame(dicc)

11. Uso de funciones de estadística básica (sum, mean, median, mode) y en qué estructuras se utilizan

• En listas y tuplas, muchas veces usamos las funciones de Python en conjunto con la librería statistics o convertimos primero a un numpy.array.

import statistics

lista = [1, 2, 3, 4, 5]

print(statistics.mean(lista))    # 3

print(statistics.median(lista))  # 3

print(statistics.mode(lista))    # si hay una moda clara

• En NumPy (numpy.array), existen métodos como np.sum(), np.mean(), np.median(), etc.
• En Pandas (DataFrame o Series), podemos usar:

df[‘col1’].sum()

df[‘col1’].mean()

df[‘col1’].median()

df[‘col1’].mode()

También df.describe() muestra estadísticos básicos.

12. Uso del remplazo de nombres en columnas con rename() y en qué estructura se utiliza

• El método rename() se utiliza en Pandas (DataFrame) para cambiar el nombre de columnas y/o índices.
• Ejemplo:

df.rename(columns={‘col1’: ‘nueva_col1’, ‘col2’: ‘nueva_col2’}, inplace=True)

• También se puede usar para renombrar índices con el argumento index={}.

13. Uso del remplazo de valores en filas con replace() y en qué estructura se utiliza

• El método replace() también se utiliza en Pandas (DataFrame o Series).
• Permite reemplazar uno o varios valores específicos por otros.
• Ejemplo:

df[‘columna’].replace(to_replace=’No definido’, value=’Desconocido’, inplace=True)

• También se puede usar para reemplazos masivos (dict de mapeos) o expresiones regulares.

14. Uso de .describe(), .info(), .shape, .dtypes y qué se muestra en cada uno

• df.describe(): Muestra estadísticos básicos de las columnas numéricas (count, mean, std, min, 25%, 50%, 75%, max). Si se añade include=’all’, muestra también estadísticos de columnas no numéricas.
• df.info(): Muestra información del DataFrame: número de filas, número de columnas, nombres de columnas, tipo de datos de cada columna, memoria usada.
• df.shape: Retorna una tupla con la forma del DataFrame (número de filas, número de columnas).
• df.dtypes (o df.types si se refiere a la propiedad, aunque el habitual es df.dtypes): Muestra el tipo de datos de cada columna.

15. ¿Qué es lo que muestra un print(df) y en qué se diferencia de las funciones de pandas del punto anterior?

• print(df) simplemente imprime una vista tabular del DataFrame, normalmente un subconjunto de filas (si es muy largo) y todas las columnas (si caben) o parte de ellas.
• No muestra estadísticas específicas (como df.describe()), ni la información de tipos (como df.info()), ni la forma (df.shape).
• Es una vista rápida para inspeccionar datos de forma textual.

16. Uso de la función .fillna() y en qué estructura se utiliza

• .fillna() es otra función de Pandas (DataFrame/Series) para reemplazar valores nulos con un valor específico o con alguna estrategia (media, mediana, forward fill, etc.).
• Ejemplo:

df[‘col1’].fillna(0, inplace=True)  # Reemplaza todos los NaN con 0

• También se puede usar con argumentos como method=’ffill’ para rellenar hacia adelante o method=’bfill’ hacia atrás.

17. Uso de la función .drop() y en qué estructuras se utiliza

• .drop() se utiliza en Pandas (DataFrame o Series) para eliminar filas o columnas según etiquetas (nombres).
  • df.drop(‘col1’, axis=1, inplace=True) → elimina la columna col1.
  • df.drop([0, 1], axis=0, inplace=True) → elimina las filas con índice 0 y 1.

18. Uso de las funciones de lectura de archivos pd.read_excel, pd.read_csv. ¿Cuándo se utilizan y cómo se ocupan?

• pd.read_excel(ruta_archivo, sheet_name=’Hoja1′,header=1): Se usa para leer archivos de Excel (.xlsx, .xls). Sheet_name es el nombre de la hoja en el archivo y header es la fila donde empieza a leer los datos.
• pd.read_csv(ruta_archivo, sep=’,’): Se usa para leer archivos de texto con separadores (generalmente , para CSV).

Ejemplos:

df_excel = pd.read_excel(‘datos.xlsx’, sheet_name=’Hoja1′, header=0)

df_csv = pd.read_csv(‘datos.csv’, delimiter=’,’)

NOTA: Se utilizan para importar datos tabulares a un DataFrame de Pandas.

19. Uso de las librerías Numpy, Pandas, Matplotlib, Os. ¿Cuándo se utilizan? ¿Qué tipo de funciones tienen?

1. NumPy:
   • Trabaja con arrays multidimensionales y funciones matemáticas optimizadas.
   • Útil para cálculo numérico, transformaciones de datos y como base para otras librerías (como Pandas).
2. Pandas:
   • Manejo de estructuras de datos como Series (1D) y DataFrame (2D).
   • Ideal para análisis de datos, limpieza, manipulación, etc.
3. Matplotlib:
   • Librería de visualización más antigua y estable de Python.
   • Se utiliza para crear gráficos de todo tipo (barras, líneas, dispersión, histogramas, etc.).
4. os:
   • Librería para interactuar con el sistema operativo (rutas de archivos, crear/carpetas, etc.).
   • Permite, por ejemplo, verificar si un archivo existe, cambiar de directorio, listar archivos, etc.

20. Funciones de la librería scikit-learn para la imputación estadística, su uso y cuándo aplican

En scikit-learn hay varias clases y funciones para imputación, pero la más utilizada es la del módulo sklearn.impute:

• SimpleImputer: Rellena valores faltantes con una estadística simple (mean, median, most_frequent o constant).

from sklearn.impute import SimpleImputer

import numpy as np

imputer = SimpleImputer(strategy=’mean’)  # ‘median’, ‘most_frequent’, ‘constant’

data = np.array([[1, 2], [np.nan, 3], [7, np.nan]])

imputed_data = imputer.fit_transform(data)

• KNNImputer: Imputa valores basándose en la media de los vecinos más cercanos.

from sklearn.impute import KNNImputer

imputer_knn = KNNImputer(n_neighbors=2)

data_knn = imputer_knn.fit_transform(data)

• IterativeImputer (experimental): Usa un modelo predictivo iterativo para imputar valores.

Estas técnicas se aplican cuando necesitamos imputar valores en un contexto de machine learning y se quieren conservar características estadísticas del conjunto de datos o utilizar la relación entre múltiples variables para estimar los valores faltantes.

Asegúrate de:

1. Comprender cada concepto teórico.
2. Practicar con ejemplos de código en Python, especialmente con DataFrames de Pandas.
3. Saber aplicar los métodos de limpieza (dropna, fillna, replace, drop, etc.) y de imputación (estadística y con scikit-learn).
4. Dominar las estructuras de datos básicas (listas, tuplas, diccionarios) y cómo convertirlas a DataFrames, ya que suelen ser preguntas frecuentes en exámenes de fundamentos de Python y manipulación de datos.