Transformación de datos con Python y Pandas

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' 
)

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.

try and except en python:
https://www.youtube.com/watch?v=IFfdRY609Fg

axis (en inglés):
https://www.youtube.com/watch?v=PtO3t6ynH-8

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.