No tienes acceso a esta clase

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

Transformación de datos con Python y Pandas

9/25
Recursos

¿Cómo limpiar códigos de productos usando Pandas en Python?

Explorar el uso de Pandas junto con Python es fundamental para todos los interesados en ingeniería y limpieza de datos. En esta lección aprenderemos a manejar el dataset de códigos de productos, empezando por limpiar los datos nulos y creando códigos aptos para nuestros análisis. Aprovecharemos los seis primeros dígitos de los códigos para cruzar la información con datos en Postgres. Las habilidades que hoy practicaremos, como la creación de funciones customizadas y la manipulación de dataframes, son esenciales para entender el potencial de Pandas y Python.

¿Cómo identificar y eliminar nulos?

Uno de los primeros pasos en la limpieza de datos es manejar los valores nulos. En nuestro caso, trabajamos con la columna CODCOM y nos interesa solo los valores que no son nulos. El proceso es el siguiente:

dfcons = df[df['CODCOM'].notnull()]

Esta línea de código devuelve un dataframe (dfcons) que contiene únicamente los códigos que no son nulos. Es crucial para garantizar que el análisis posterior sea efectivo y que los valores con los que trabajamos sean válidos y consistentes.

¿Cómo construir una función de limpieza de código?

Queremos crear una función que extraiga los seis primeros dígitos del código y la descripción del producto, más la descripción de su categoría de nivel superior. Lo logramos creando una función personalizada en Python:

def cleanCode(texto):
    texto = str(texto)
    parentCode = ''
    if len(texto) == 11:
        codigo = texto[:6]
        parentCode = texto[0]
    else:
        codigo = texto[:6]
        parentCode = texto[:2]
    try:
        parent = df[df['CODECOM'] == parentCode]['DESCRIPCION'].values[0]
    except:
        parent = None
    return (codigo, parent)

Esta función convierte el código en un string, verifica su longitud y extrae el código y la categoría de nivel superior basándose en esas características. La utilidad de esta función se aprovecha al aplicarse a cada fila del dataframe.

¿Cómo aplicar la función personalizada al dataframe?

Aplicamos la función cleanCode para obtener un dataframe enriquecido con nuevas columnas. Aquí te mostramos cómo hacerlo:

df[['cleanCode', 'parentDescription']] = df.apply(
    lambda x: cleanCode(x['CODCOM']), axis=1, result_type='expand'
)

Se usa la función apply junto con lambda para aplicar cleanCode a cada fila (axis=1), expandiendo el resultado en dos nuevas columnas: cleanCode y parentDescription.

¿Cómo seleccionar columnas útiles?

Después de calcular el código limpio y las descripciones, se procede a seleccionar solo las columnas necesarias para el análisis final:

df_final = df[['cleanCode', 'DESCRIPCION', 'parentDescription']]

Este paso simplifica el dataframe, dejándonos con las columnas más valiosas: el código limpio para búsquedas y las descripciones del producto y su categoría madre.

Con esta técnica, podemos enriquecer nuestros análisis al tener descriptores claros de los productos y su categorización de nivel superior, dando pie a mejores decisiones basadas en datos sólidos y bien estructurados. ¡Sigue adelante y explora cómo Pandas puede transformar tu trabajo con datos!

Aportes 11

Preguntas 0

Ordenar por:

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

Código

def clean_code(text):
    text = str(text)
    parent_code = None

    if len(text) == 12:
        code = text[:5]
        parent_code = text[:1]
    else:
        code = text[:6]
        parent_code = text[:2]

    try:
        parent = df_parents[df_parents['Code_comm'] == parent_code]['Description'].values[0]
    except:
        parent = None


    return (code, parent)
df_codes[['clean_code', 'parent_description']] = 
	df_codes.apply(
				  lambda x:  clean_code( x['Code'] ), 
				   axis=1, 
				   result_type='expand' 
)

Refresca tu memoria con Apply 😉

Sugerencia para Platzi, sería bueno que creen un curso “Como comunicar efectivamente sin leer”, y manden a sus profesores a este curso, lo digo muy en serio, dan pena y hasta me molesta pagar por escuchar como leen sin explicar con claridad, por lo menos si van a leer expliquen bien.

Para tener una idea más clara del código de la clase, le pedí a chatGPT que lo explicara de manera sencilla: ¡Claro! Esta función llamada `clean\_code` toma dos argumentos: `text` y `df\_parents`. Veamos cómo funciona paso a paso: 1\. `text` es el código que se va a limpiar. 2\. `df\_parents` es un DataFrame que contiene información sobre los códigos principales y sus descripciones. Ahora, echemos un vistazo a la función en sí: * `text = str(text)`: Esto asegura que el argumento `text` sea convertido a una cadena (string), en caso de que no lo sea ya. Esto evita errores si el valor de `text` no es una cadena. * `parent\_code = None`: Se inicializa la variable `parent\_code` como `None`, que se utilizará más adelante. * `if len(text) == 11:`: Esta línea verifica si la longitud de `text` es igual a 11. Si es así, significa que `text` contiene un código con una longitud de 11 caracteres. * `code = text\[:5]`: Si `text` tiene 11 caracteres, se toman los primeros 5 caracteres como el código. * `parent\_code = text\[:1]`: Aquí se toma solo el primer carácter de `text` como el `parent\_code`. * `else:`: Si la longitud de `text` no es 11 (es decir, si es mayor o menor), se ejecuta este bloque. * `code = text\[:6]`: En este caso, se toman los primeros 6 caracteres de `text` como el código. * `parent\_code = text\[:2]`: Aquí se toman los primeros dos caracteres de `text` como el `parent\_code`. * `try:`: Aquí comienza un bloque de código que se intentará ejecutar. Este bloque manejará cualquier posible error que pueda ocurrir durante la ejecución del código dentro de él. * `parent = df\_parents.loc\[df\_parents\['Code\_comm'] == parent\_code]\['Description'].values\[0]`: Esta línea busca en el DataFrame `df\_parents` la fila donde el valor en la columna 'Code\_comm' coincida con el valor de `parent\_code`. Luego, toma la descripción correspondiente de esa fila. Si no encuentra una fila que coincida con el `parent\_code`, generará una excepción que será manejada por el bloque `except`. * except:`: Este bloque maneja cualquier excepción que ocurra dentro del bloque `try`. En este caso, si no se encuentra ninguna fila que coincida con `parent\_code`, se asigna `None` a la variable `parent`. Finalmente, la función devuelve una tupla que contiene el código limpio (`code`) y la descripción del código principal (`parent`).
El warning en el código se puede resolver con el siguiente código: ```js def clean_code(text, df_parents): text = str(text) parent_code = None if len(text) == 1: code = text[:5] parent_code = text[:1] else: code = text[:6] parent_code = text[:2] try: parent = df_parents.loc[df_parents['Code_comm'] == parent_code,'Description'].values[0] except: parent = None return (code, parent) df_codes[['clean_code', 'parent_description']] = df_codes.apply(lambda x : clean_code(x['Code'], df_parents), axis=1, result_type='expand') ```Tiene dos cambio: 1.- Utilizar **loc** al momento de definir las filas (df\_parents\['Code\_comm´] ==parent\_code) y las columnas ('Description'). Así pandas se asegura que sea la información que queremos la que se modifica. 2.- Mandar df\_parents como argumento a la función (def clean\_code(text, **df\_parents**):) para que la función no dependa de variables externas.
No sé si le sirva a alguien pero me faltaban los parentesis en el .copy() y con eso se resolvieron todos los problemas y pude replicar el código tal cual
Como al momento de crear mi base de datos le cambié el puerto , me tocó cambiarlo para crear el engine también. 'postgresql+psycopg2://postgres:mysecretpass@localhost:5433/postgres'
Tengo la conexión y ambiente correcto pero mi pc se muere con esta linea, df\_trades = pd.read\_sql('select \* from trades limit 10', engine) y eso que le puse limit
¿Por qué si el código lo definen los 6 primeros dígitos la función toma 5 cuando el parent code es de un sólo dígito?, además, en los resultados, clean\_code muestra 5 dígitos en la gran mayoría de los casos.

Más información acerca de la advertencia en la línea 15 al 8:50: Link