Extendiendo la API de Pandas

Yo lo estoy trabajando en VS y me daba problema correr el %run.

Esto sucedio ya que no habia instalado en mi ambiente la libreria de jupyter

Les dejo el codigo para que lo puedan solucionar

conda activate your_env
pip install jupyter

Crear una nueva clase para extender Pandas

Creamos una clase y dentro de ella todos lo metodos que necesitemos. Para poder hacer accesible los metodos, utilizamos un decorador de pandas para acceder a la clase mediante una palabra clave

@pd.api.extensions.register_dataframe_accessor("missing")  #Decorador
class MissingMethods:                                      #clase
    def __init__(self, pandas_obj):
        self._df = pandas_obj

    def number_missing(self):                        #metodo para contar datos faltantes
        return self._df.isna().sum().sum()

    def number_complet(self):                        #metodo para contar datos completos
        return self._df.size - self._df.missing.number_missing()

Para acceder a los metodos se procede como sigue:

# actualizamos el dataframe para que se guarden los cambios
df = pd.DataFrame(df)

# accediendo al metodo number_missing
df.missing.number_missing()

#accediendo al metodo number_complet
df.missing.number_complet()

Hola. Nuevamente paso por aquí para los que no leyeron mi aporte en la primera clase del curso. Para los que estén experimentando problemas con el uso de la librería, hice un repositorio para poder clonarlo y tomar el curso usando VSCode. Todo ya fue probado durante todo el curso para asegurarme que funcione. Espero les evite días de frustración y directamente puedan tomar el curso sin ningún problema: <https://github.com/onnymm/missing_data_exploration>

A opinión personal creo que es mejor usarlo sin la clase, uso los métodos de manera manual cuando los necesito (de paso practico el código, y si eres principiante es aun mejor, ya que repetir código y saber para que se usa cada cosa te ayudará a futuro), me ahorro código y tiempo, no sé. No le veo mucha utilidad, a menos de que lleves ya tiempo en esto, y estés cansado de repetir código y te lo sepas de memoria

5. Extendiendo la API de Pandas

• Es muy buena práctica modularizar el código para mejorar el flujo de trabajo, así si quiero modificar el código de una función solo tengo que acceder al notebook de las funciones y no buscar en todo el notebook principal.
• Me gusta mucho de Jesus que nos comparte las herramientas de su workflow que tiene como data scientist para facilitar el nuestro.

En resumen, para extender el funcionamiento de la API de Pandas:

1. Crear un decorador con el accesorio para el acceso a los métodos
2. Crear una clase
3. Crear los métodos que se requieran en la clase

Hola! Encontré un error en el método missing_case_summary(). Este método en esencia calcula el valor absoluto y relativo de nulos en cada fila:

def missing_case_summary(self) -> pd.DataFrame:
        return self._obj.assign(
            case=lambda df: df.index,
            n_missing=lambda df: df.apply(
                axis="columns", func=lambda row: row.isna().sum()
            ),
            pct_missing=lambda df: df["n_missing"] / df.shape[1] * 100,
        )[["case", "n_missing", "pct_missing"]]

El problema sucede cuando calculamos el porcentaje de missings

pct_missing=lambda df: df["n_missing"] / df.shape[1] * 100

Hemos creado 2 columnas de más!!! Las cuales son casey n_missing por lo que este porcentaje está subestimado. Por ejemplo. Si la fila fuese [None, 1, None, 0] El porcentaje de nulos es 50% pero este error de código arrojaría un porcentaje de 2 / 6 ≈ 33%

La solución a este bug es restar 2 al denominador:

pct_missing=lambda df: df["n_missing"] / (df.shape[1]-2) * 100,

```python #python _3_11 _para Vcode SOLUCIONA EL %RUN asttokens==2.4.1 attrs==23.2.0 colorama==0.4.6 comm==0.2.2 contourpy==1.2.0 cycler==0.12.1 debugpy==1.8.1 decorator==5.1.1 executing==2.0.1 fastjsonschema==2.19.1 fonttools==4.50.0 ipykernel==6.29.3 ipython==8.22.2 jedi==0.19.1 jsonschema==4.21.1 jsonschema-specifications==2023.12.1 jupyter_client==8.6.1 jupyter_core==5.7.2 kiwisolver==1.4.5 matplotlib==3.8.3 matplotlib-inline==0.1.6 missingno==0.5.2 multipledispatch==1.0.0 natsort==8.4.0 nbformat==5.10.3 nest-asyncio==1.6.0 numpy==1.26.4 packaging==24.0 pandas==2.2.1 pandas-flavor==0.6.0 parso==0.8.3 pillow==10.2.0 platformdirs==4.2.0 prompt-toolkit==3.0.43 psutil==5.9.8 pure-eval==0.2.2 Pygments==2.17.2 pyjanitor==0.26.0 pyparsing==3.1.2 pyreadr==0.5.0 python-dateutil==2.9.0.post0 pytz==2024.1 pywin32==306 pyzmq==25.1.2 referencing==0.34.0 rpds-py==0.18.0 scipy==1.12.0 seaborn==0.13.2 session_info==1.0.0 six==1.16.0 stack-data==0.6.3 stdlib-list==0.10.0 tornado==6.4 traitlets==5.14.2 tzdata==2024.1 UpSetPlot==0.9.0 wcwidth==0.2.13 wget==3.2 xarray==2024.2.0 ```

Pandas es una biblioteca poderosa para el análisis y manipulación de datos en Python, y ofrece muchas funcionalidades para trabajar con conjuntos de datos,

• Extender la API de Pandas significa utilizar las funcionalidades avanzadas y personalizadas de Pandas para realizar operaciones más específicas y complejas en tus conjuntos de datos.

la API de Pandas para realizar tareas más avanzadas y personalizadas en tus conjuntos de datos. La versatilidad de Pandas te permite adaptar tus análisis de datos de acuerdo con tus necesidades específicas. Puedes explorar aún más las funciones y métodos avanzados de Pandas en la documentación oficial y a medida que adquieras experiencia en su uso.

Ojo:

Para quienes están trabajando en Jupyter Notebook en VS Code y les marca error la última funcion de la clase MissingMethods:

def missing_upsetplot(self, variables: list[str] = None, **kwargs):
	...

se trata de la version de Python, con 3.9 o mayor anda normal.

Extender la API de \*\*Pandas\*\* es útil cuando deseas agregar funcionalidades personalizadas o simplificar tareas recurrentes que no están directamente soportadas por la biblioteca. A continuación, se presentan diversas formas de extender la API de Pandas. \### 1. \*\*Métodos personalizados con `@pd.api.extensions.register\_dataframe\_accessor`\*\* Puedes crear \*\*accesores\*\* personalizados que te permiten extender la funcionalidad de un DataFrame o Series. Esto se hace decorando clases con `@pd.api.extensions.register\_dataframe\_accessor`. \#### Ejemplo: ```python import pandas as pd \# Crear un accesor personalizado @pd.api.extensions.register\_dataframe\_accessor("analytics") class AnalyticsAccessor: def \_\_init\_\_(self, pandas\_obj): self.\_obj = pandas\_obj \# Método personalizado para obtener estadísticas resumidas def summary(self): return { "mean": self.\_obj.mean(), "median": self.\_obj.median(), "max": self.\_obj.max(), "min": self.\_obj.min(), } \# Uso del accesor df = pd.DataFrame({ 'A': \[10, 20, 30], 'B': \[1, 2, 3], 'C': \[4, 5, 6] }) print(df.analytics.summary()) ``` \#### Explicación: \- Se crea un accesor llamado `analytics` que puedes utilizar directamente sobre el DataFrame. \- El método `summary()` devuelve estadísticas clave como media, mediana, máximo y mínimo. \### 2. \*\*Agregando métodos a objetos existentes (monkey patching)\*\* Puedes agregar métodos directamente al DataFrame o Series utilizando \*\*monkey patching\*\*, aunque no es recomendable para proyectos a gran escala debido a posibles problemas de compatibilidad y mantenibilidad. \#### Ejemplo: ```python import pandas as pd def highlight\_max(df): return df.style.apply(lambda x: \['background: yellow' if v == x.max() else '' for v in x], axis=1) \# Agregar método personalizado pd.DataFrame.highlight\_max = highlight\_max \# Crear un DataFrame df = pd.DataFrame({ 'A': \[10, 20, 30], 'B': \[1, 50, 3], 'C': \[4, 5, 6] }) \# Usar el nuevo método df.highlight\_max() ``` \#### Explicación: \- Se añade el método `highlight\_max()` al objeto DataFrame. \- Este método resalta en amarillo los valores máximos en cada fila del DataFrame. \### 3. \*\*Crear una clase heredada de DataFrame\*\* Una forma más estructurada de extender Pandas es creando clases que hereden de `pd.DataFrame` para agregar funcionalidad adicional. \#### Ejemplo: ```python import pandas as pd class MyDataFrame(pd.DataFrame): @property def \_constructor(self): return MyDataFrame \# Método personalizado para normalizar los datos def normalize(self): return (self - self.mean()) / self.std() \# Crear un DataFrame personalizado df = MyDataFrame({ 'A': \[10, 20, 30], 'B': \[1, 50, 3], 'C': \[4, 5, 6] }) \# Usar el nuevo método print(df.normalize()) ``` \#### Explicación: \- Se hereda de `pd.DataFrame` para crear una nueva clase `MyDataFrame`. \- Se añade un método `normalize()` para normalizar los valores de las columnas. \- Al sobrescribir `\_constructor`, se asegura que los métodos devuelvan objetos de la misma clase. \### 4. \*\*Funciones UDF para operaciones en DataFrame\*\* Las \*\*funciones definidas por el usuario (UDF)\*\* te permiten aplicar operaciones personalizadas sobre filas o columnas de un DataFrame. \#### Ejemplo: ```python import pandas as pd df = pd.DataFrame({ 'A': \[10, 20, 30], 'B': \[1, 50, 3], 'C': \[4, 5, 6] }) \# Función personalizada def custom\_function(row): return row\['A'] + row\['B'] + row\['C'] \# Aplicar la función personalizada a cada fila df\['Sum'] = df.apply(custom\_function, axis=1) print(df) ``` \#### Explicación: \- Se define una función personalizada `custom\_function()` que suma los valores de las columnas `A`, `B` y `C`. \- Se aplica la función a cada fila usando `apply()`. \### 5. \*\*Métodos personalizados con `pipe()`\*\* El método `pipe()` permite aplicar funciones personalizadas a DataFrames, lo que puede ser útil cuando se encadenan múltiples operaciones. \#### Ejemplo: ```python import pandas as pd \# Crear un DataFrame df = pd.DataFrame({ 'A': \[10, 20, 30], 'B': \[1, 50, 3], 'C': \[4, 5, 6] }) \# Función personalizada def add\_columns(df, col1, col2): df\['Sum'] = df\[col1] + df\[col2] return df \# Aplicar la función usando pipe df = df.pipe(add\_columns, 'A', 'B') print(df) ``` \#### Explicación: \- `pipe()` permite encadenar la función `add\_columns()` al DataFrame, lo que facilita la legibilidad del código. \### 6. \*\*Extender el comportamiento de las Series\*\* Similar a los DataFrames, también puedes extender las Series usando `@pd.api.extensions.register\_series\_accessor`. \#### Ejemplo: ```python @pd.api.extensions.register\_series\_accessor("stats") class StatsAccessor: def \_\_init\_\_(self, pandas\_obj): self.\_obj = pandas\_obj def range(self): return self.\_obj.max() - self.\_obj.min() \# Crear una Serie s = pd.Series(\[1, 2, 3, 4, 5]) \# Usar el accesor personalizado print(s.stats.range()) # Salida: 4 ``` \### Resumen 1\. \*\*Accesores personalizados\*\* (`@pd.api.extensions.register\_dataframe\_accessor`): Añadir métodos especializados a DataFrames y Series. 2\. \*\*Monkey patching\*\*: Modificar objetos de Pandas directamente (aunque no siempre recomendado). 3\. \*\*Herencia de clases\*\*: Crear clases personalizadas a partir de DataFrames o Series. 4\. \*\*Funciones UDF\*\*: Aplicar funciones definidas por el usuario. 5\. \*\*Encadenamiento con `pipe()`\*\*: Facilita la lectura y escritura de código con operaciones encadenadas. Estas técnicas te permiten hacer que Pandas sea aún más flexible y personalizado según las necesidades de tus proyectos.

He encapsulado las funciones definidas directamente en un script: ```js #!../../env/bin/python import pandas as pd # Para borrar en caso de su existencia a .missing try: del pd.DataFrame.missing except: pass # Extension para manejar numeros no disponibles @pd.api.extensions.register_dataframe_accessor("missing") # Acceso para los dataframes de pandas class MissingMethods: def __init__(self, pandas_obj): self._df = pandas_obj def na_full_count(self): return self._df.isna().sum().sum() def not_na_full_count(self): return self._df.size - self._df.missing.na_full_count() def na_proportion(self): return (self.na_full_count() / self._df.size) # Para crear un Data Frame que pueda rescatarse DF_TEST_MISSIGN = pd.DataFrame.from_dict( data = { "a": list("asdafsdafa"), "b": range(0, 10) } ) DF_TEST_MISSIGN.iloc[2:5, 0] = None DF_TEST_MISSIGN.iloc[6:7, 1] = None ```Además les dejo los test unitarios: ```js #!../../env/bin/python import unittest import pandas_missing_extension from pandas_missing_extension import DF_TEST_MISSIGN class TestMissingMethods(unittest.TestCase): def test_na_full_count(self): self.assertEqual(DF_TEST_MISSIGN.missing.na_full_count(), 4) def test_na_full_count(self): self.assertEqual(DF_TEST_MISSIGN.missing.not_na_full_count(), 16) def test_na_proportion(self): self.assertEqual(DF_TEST_MISSIGN.missing.na_proportion(), 0.2) if __name__ == "__main__": unittest.main() ```

El curso lo estoy haciendo con Google Colab y con la ayuda de ChatGPT. La verdad es que estoy aprendiendo MUCHO del curso en sí y de cómo tengo problemas y los soluciono. La verdad es que se aprende siempre que se tenga voluntad. Es un curso BRILLANTE.

Para visual code les recomiendo : Data Wrangler (Preview) es excelente funciona con pandas dándole la visual del deepnote y se puede visualizar los csv mejor.

A opinión personal creo que es mejor usarlo sin la clase, uso los métodos de manera manual cuando los necesito (de paso practico el código), me ahorro código y tiempo, no sé. No le veo mucha utilidad