Fundamentos de ETL con Python

1

Procesos ETL: Extracción, Transformación y Carga de Datos

2

Manipulación de Datos con Python: De CSV a ETL Completo

3

Fuentes de Datos: Archivos, Bases de Datos y APIs en Análisis de Ventas

4

Instalación de Anaconda y Jupyter para Procesamiento de Datos

Quiz: Fundamentos de ETL con Python

Técnicas Efectivas de Transformación de Datos

5

Lectura y Exploración de Archivos CSV con Pandas en Python

6

Manejo de Archivos Excel con Pandas para Procesos ETL

7

Ingesta de Datos desde APIs con Python

8

Conexión y consulta de bases de datos en Python con SQLite3 y SQLAlchemy

9

Series y DataFrames en Pandas: Diferencias y Usos Prácticos

10

Métricas Clave en el Perfilado de Datos para Análisis de Calidad

11

Limpieza de Datos en Python con Pandas

12

Filtrado, Selección y Transformación de Datos con Pandas

13

Agrupación y Resumen de Datos con Pandas

14

Manipulación Avanzada de Datos con Python y Pandas

Quiz: Técnicas Efectivas de Transformación de Datos

Carga de Datos y Proyecto Final

15

Exportación de DataFrames a CSV con Pandas paso a paso

16

Gestión de Datos: Carga Completa vs. Carga Incremental en Python

17

Partición de Datos en Archivos CSV con Pandas

18

Carga Incremental de Datos en Archivos Excel con Python

19

Importación de la Base de Datos Sakila en MySQL Workbench

20

Transformaciones de Datos ETL con Python y MySQL

21

Transformaciones de Datos con Python y SQL

22

Buenas prácticas y errores comunes en procesos ETL

23

Carga y Validación de Datos en Sakila ETL con Python y SQL

24

Fundamentos de ETL con Python: Extracción, Transformación y Carga de Datos

Quiz: Carga de Datos y Proyecto Final

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Limpieza de Datos en Python con Pandas

11/24
Recursos

¿Cómo limpiar datos en Python de manera efectiva?

La limpieza de datos es un paso crucial en el análisis de datos. Permite no solo garantizar la calidad y precisión de los análisis subsecuentes, sino que también puede prevenir errores en algoritmos y modelos predictivos. Usar Python y la librería Pandas ofrece herramientas poderosas que facilitan este proceso. A continuación, exploraremos diversas técnicas y métodos para llevar a cabo una limpieza eficiente de datos.

¿Cómo manejar valores nulos en un DataFrame?

Al analizar datos, es común encontrarse con valores nulos o "mising". Estos pueden tratarse de distintas maneras:

  • Detección: Utiliza isnull() para identificar valores nulos en cada columna. Posteriormente, con .sum(), se puede contar cuántos valores nulos existen por columna.
  valores_nulos = df.isnull().sum()
  • Eliminación: Con dropna(), eliminamos filas que contengan valores nulos. Aunque eficaz, puede no siempre ser lo ideal si se pierden datos valiosos.
  df_limpio = df.dropna()
  • Imputación: Se refiere a llenar valores nulos con un dato específico. Por ejemplo, podríamos usar fillna() para imputar ceros en variables numéricas o colocar "desconocido" en una columna de texto.
  df_rellenado = df.fillna({'salario': 0, 'nombre': 'desconocido'})

¿Cómo corregir errores en los tipos de datos?

Una tarea habitual en la limpieza de datos es asegurar que cada columna tenga el tipo de dato correcto. Esto se puede lograr fácilmente con Pandas:

  • Convertir a numérico: to_numeric() transforma columnas en números, útil cuando datos se almacenan como texto.
  df['edad'] = pd.to_numeric(df['edad'], errors='coerce')
  • Transformaciones estadísticas para imputación: Más allá de simples constantes, podemos usar métodos estadísticos como la media para la imputación.
  df['salario'].fillna(df['salario'].mean(), inplace=True)

¿Cómo transformar variables categóricas?

Frecuentemente es necesario convertir variables categóricas a numéricas, especialmente al prepararlas para modelos de aprendizaje automático:

  • Mapeo binario: Con map() es posible transformar variables binarias, como género, a 0 y 1, facilitando su uso en modelos.
  df['género'] = df['género'].map({'femenino': 0, 'masculino': 1})
  • Variables ficticias: get_dummies() genera columnas binarias para cada categoría de una variable. Al usarlo, el parámetro drop_first=True ayuda a evitar redundancias.
  df_dummies = pd.get_dummies(df['departamento'], drop_first=True)

¿Cómo manejar variables categóricas no binarias?

Manejar categorías no binarias introduce complejidad, pero también brinda más información. Por ejemplo, al tratar con géneros no binarios podríamos:

  • Ampliar categorías en mapeo: Ajustar map() para incluir más categorías.

  • Uso de variables ficticias: get_dummies() permite incluir múltiples categorías sin perder información.

Recomendaciones para mejoras prácticas

  • Antes de eliminar datos, considera el impacto en los análisis.
  • Imputa con métodos estadísticos cuando sea posible para mantener integridad en datos.
  • Revisa valores tipo datos después de conversiones usando .info().

En definitiva, estos métodos proveen las bases necesarias para una limpieza de datos efectiva. Viajar por el mundo de los datos bien preparados no solo incrementará la eficiencia de tus análisis, sino que también te permitirá sacar conclusiones más precisas y significativas. Este es solo el comienzo, sigue explorando y perfeccionando tus habilidades con prácticas y nuevos desafíos.

Aportes 8

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

La limpieza de datos es esencial para garantizar que los datos sean precisos, consistentes y adecuados para el análisis. Aquí te explico algunas de las técnicas más comunes para limpiar datos con **Pandas** en Python. ## **1. Identificar y Manejar Valores Nulos** Los valores nulos son comunes en los datos y pueden manejarse de diferentes maneras. ### a) Identificar valores nulos \# Contar valores nulos por columna print(df.isnull().sum()) \# Visualizar valores nulos import seaborn as sns import matplotlib.pyplot as plt sns.heatmap(df.isnull(), cbar=False, cmap='viridis') plt.title("Mapa de Valores Nulos") plt.show() ### b) Eliminar valores nulos \# Eliminar filas con valores nulos df = df.dropna() \# Eliminar columnas con muchos valores nulos df = df.dropna(axis=1) ### c) Rellenar valores nulos \# Rellenar con un valor fijo df\['columna'] = df\['columna'].fillna(0) \# Rellenar con la media, mediana o moda df\['columna'] = df\['columna'].fillna(df\['columna'].mean()) df\['columna'] = df\['columna'].fillna(df\['columna'].median()) df\['columna'] = df\['columna'].fillna(df\['columna'].mode()\[0]) ## **2. Manejar Duplicados** ### a) Identificar duplicados \# Identificar filas duplicadas print(df.duplicated().sum()) \# Ver duplicados específicos print(df\[df.duplicated()]) ### b) Eliminar duplicados df = df.drop\_duplicates() ## **3. Corregir Tipos de Datos** Los datos pueden estar mal clasificados y necesitan conversión. ### a) Cambiar el tipo de una columna df\['columna'] = df\['columna'].astype(float) # Convertir a flotante df\['fecha'] = pd.to\_datetime(df\['fecha']) # Convertir a fecha ### b) Detectar errores en los tipos \# Encontrar filas no convertibles errores = df\[~df\['columna'].str.isnumeric()] print(errores) ## **4. Corregir Valores Atípicos (Outliers)** ### a) Detectar valores atípicos \# Usar el rango intercuartílico (IQR) Q1 = df\['columna'].quantile(0.25) Q3 = df\['columna'].quantile(0.75) IQR = Q3 - Q1 \# Filtrar outliers outliers = df\[(df\['columna'] < Q1 - 1.5 \* IQR) | (df\['columna'] > Q3 + 1.5 \* IQR)] print(outliers) ### b) Manejar valores atípicos \# Reemplazar outliers con la mediana mediana = df\['columna'].median() df.loc\[(df\['columna'] < Q1 - 1.5 \* IQR) | (df\['columna'] > Q3 + 1.5 \* IQR), 'columna'] = mediana ## **5. Normalizar y Estandarizar Datos** ### a) Normalización (escala de 0 a 1) df\['columna\_normalizada'] = (df\['columna'] - df\['columna'].min()) / (df\['columna'].max() - df\['columna'].min()) ### b) Estandarización (media 0, desviación estándar 1) df\['columna\_estandarizada'] = (df\['columna'] - df\['columna'].mean()) / df\['columna'].std() ## **6. Corregir Datos Categóricos** ### a) Normalizar texto \# Convertir a minúsculas df\['columna'] = df\['columna'].str.lower() \# Eliminar espacios extra df\['columna'] = df\['columna'].str.strip() ### b) Reemplazar valores incorrectos df\['columna'] = df\['columna'].replace({'valor\_incorrecto': 'valor\_correcto'}) ## **7. Manejar Rangos y Valores Inválidos** ### a) Filtrar valores fuera de rango df = df\[(df\['columna'] >= 0) & (df\['columna'] <= 100)] ### b) Corregir valores inválidos \# Reemplazar valores negativos con NaN df\['columna'] = df\['columna'].apply(lambda x: x if x >= 0 else None) ## **8. Ejemplo Completo** import pandas as pd \# Cargar datos df = pd.read\_csv("archivo.csv") \# Identificar y manejar valores nulos df\['columna'] = df\['columna'].fillna(df\['columna'].mean()) \# Eliminar duplicados df = df.drop\_duplicates() \# Corregir tipos de datos df\['fecha'] = pd.to\_datetime(df\['fecha']) \# Manejar valores atípicos Q1 = df\['columna'].quantile(0.25) Q3 = df\['columna'].quantile(0.75) IQR = Q3 - Q1 df.loc\[(df\['columna'] < Q1 - 1.5 \* IQR) | (df\['columna'] > Q3 + 1.5 \* IQR), 'columna'] = df\['columna'].median() \# Guardar datos limpios df.to\_csv("archivo\_limpio.csv", index=False)
**1er. Reto.** Género No Binario: Se podría agregar NB (No binario) de manera ordinal como: M=0, F=1, NB=2 ```js df["Genero"] = df["Genero"].map({"M": 0, "F": 1, "NB": 2}) ``` **2do Reto.** \- Qué harías con la fila que tiene el valor de Cantidad = 0 ? Cuando la cantidad es **0**, significa que la venta no se concretó o que hubo un error en el registro. Existen dos opciones: \# **1: Eliminar la fila** (si los datos no son útiles para el análisis): ```js df = df[df["cantidad"] > 0] ``` Esto elimina cualquier fila donde la cantidad sea **0**. \#**2: Mantener la fila, pero marcarla como cancelada o revisar** Si se necesita un historial de intentos de venta, se puede agregar una columna: ```js df["estado"] = df["cantidad"].apply(lambda x: "Cancelada" if x == 0 else "Completada") ``` Esto ayuda a analizar intentos de venta fallidos. \- Cómo manejarias el caso de productos repetidos con diferentes fechas ? Para productos repetidos, se pueden **agrupar** o **ordenar**, dependiendo del análisis que se necesite. ```js df_grouped = df.groupby("producto").agg({"cantidad": "sum", "precio_unitario": "first"}).reset_index() ```
Respondiendo a las preguntas: 1\. Para manejar los datos que contienen un cero como registro. usaria el valor promedio o mediana como valor a remplazar por el cero. ```js ventas['cantidad'] = ventas['cantidad'].replace(0, ventas['cantidad'].mean()) ```Ahora, con los productos duplicados con fechas distintas los dejaria tal cual. porque al ser una tabla de ventas los registros de la columna producto se vuelven unicos porque se vendieron en fechas distintas. Si quieres saber solo los valores unicos de la columna tocaria utilizar la siguiente linea ```js ventas['producto'].unique() ```
La limpieza de datos implica varias técnicas esenciales para asegurar que los conjuntos de datos sean útiles y precisos. Algunas de las técnicas más comunes incluyen: 1. **Manejo de valores nulos**: Puedes usar `dropna()` para eliminar filas con valores faltantes o `fillna()` para imputar estos valores con un dato relevante (como la media o un valor específico). 2. **Conversión de tipos de datos**: Asegúrate de que cada columna tenga el tipo de dato adecuado usando `pd.to_numeric()` para convertir cadenas a números, por ejemplo. 3. **Corrección de errores**: Esto incluye la normalización de valores, como convertir categorías en números (e.g., género) usando `map()` o `get_dummies()` para variables categóricas. Estas técnicas son fundamentales para preparar tus datos antes de realizar análisis más profundos o entrenamiento de modelos.
Una variable dummy es una variable categórica que ha sido convertida en una variable numérica para facilitar su uso en análisis estadísticos o modelos de machine learning. Se utiliza principalmente para representar categorías de datos, como género o departamento, asignando valores binarios (0 y 1). Por ejemplo, si tienes una variable "género" con valores "masculino" y "femenino", podrías crear una variable dummy donde "masculino" sea 1 y "femenino" sea 0. Esto permite realizar análisis más efectivos en software de estadísticas y modelado.
La función `pandas.get_dummies()` se utiliza para convertir variables categóricas en variables dummy (o indicator variables) en un DataFrame de Pandas. Esto es particularmente útil en el contexto de la limpieza de datos, como se mencionó en la clase sobre técnicas de transformación de datos. Por ejemplo, si tienes una columna "género" con valores "F" y "M", `get_dummies()` crearía dos nuevas columnas: "género_F" y "género_M", donde cada fila tendría un 1 en la columna correspondiente al género y 0 en la otra. Esto permite que los algoritmos de machine learning procesen mejor la información categórica, facilitando su uso en modelos predictivos.
No sé en cuanto a género, pero por ejemplo en modelos de machine learning yo creo que este feature podría generar sesgos y mejor ni lo pondría.
1. Para la columna "Cantidad" que tiene el valor de 0, revisaría si realmente se vendió o no y por qué quedó en cero Lo anterior con el fin de validar si es necesario corregir dicho valor, o si se elimina ese registro de la data o se excluye. 2. Para productos repetidos, dependerá del análisis que se requiere. Si es saber cuánto se ha vendido por producto en el mes, entonces sumaría todas las cantidades vendidas durante el mes sin importar que se repita la fecha. Ahora si es para un mismo día y todos los productos se repiten, hay que revisar en el sistema si es necesario mantener esos valores repetidos o solo se debe actualizar la cantidad cada vez que se venda un mismo producto en el día.