No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

15 Días
2 Hrs
17 Min
48 Seg

Operaciones con valores faltantes

2/21
Recursos

Aportes 34

Preguntas 2

Ordenar por:

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

Operaciones con valores faltantes

Aprender otro idioma no es solo aprender diferentes palabras para las mismas cosas, sino aprender otra forma de pensar sobre las cosas

  • En Python, None no tiene definido operaciones con valores numericos, booleanos… Ademas al comparar los None (==) ó utilizar la funcion is, arroja True
  • En Numpy, los valores faltantes se representan con nan y tienen definido operaciones con valores numericos ya que es de tipo float. Por otro lado, al comparar los None arroja False es decir, que no son el mismo objeto y al compararlos mediante la funcion is arroja True es decir que un nan esta contenido en otro nana. Tener cuidado
  • En Pandas, existen varias maneras de representar los valores faltantes (nan, <NA>, None)

Funciones para buscar valores nulos en Pandas

nombre_df.isna()
nombre_df.isnull()

Buscar valores faltantes en una columna del DataFrame

nombre_df.nombre_columna.isnull()

si al importar janitor les devuelve un error ‘type’

!pip uninstall pyjanitor --yes

y vuelvan a instalarlo pero agreguenle la versión

!pip install pyjanitor==0.23.1

ahi vulven a importar y ya en teoría les tendría que funcionar ❤️

== >>True cuando son iguales.
IS >>True cuando ambos apuntan al mismo objeto.

np.nan == np.nan # is always False! Use special numpy functions instead.

Aproveche para poner en practica lo aprendido en el curso de entornos de trabajos (cookiecutter) para crear la estructura de carpetas y trabajar mis notebooks desde VSC, no tuve problemas como en deepnote

Las operaciones con valores faltantes se refieren a las que debes tomar al trabajar con datos que contienen valores ausentes o datos acciones faltantes. Es fundamental abordar estos valores de manera adecuada para garantizar la precisión y la integridad de tus análisis y modelos estadísticos. Aquí, explicaré en detalle algunos conceptos claves relacionados con las operaciones de datos faltantes:

1. Valores faltantes (Missing Values):

  • Son valores que faltan o no están disponibles en un conjunto de datos en una o más ubicaciones. Pueden ser denotados por diferentes convenciones, como “NaN” (Not a Number) en Python o “NULL” en SQL.

2. Tipos de valores faltantes:

Valores faltantes completamente al azar (MCAR):

  • Ocurren de manera completamente aleatoria y no hay relación entre la falta de datos y ninguna otra variable o razón.

Valores faltantes aleatorios (MAR):

  • La falta de datos está relacionada con otras variables observadas en el conjunto de datos, pero no con los valores faltantes en sí.

Valores faltantes no aleatorios (MNAR):

  • La falta de datos está relacionada con los valores faltantes en sí. Esto puede deberse a factores que no están registrados en el conjunto de datos.

3. Exploración de datos faltantes:

  • Antes de abordar los valores faltantes, es importante realizar un análisis exploratorio para identificar la cantidad y la ubicación de los datos faltantes en tus datos.

4. Tratamiento de valores faltantes:

  • Hay varias estrategias para tratar los valores faltantes:

Eliminación de filas o columnas:

  • Puedes eliminar filas o columnas que contengan valores faltantes si la cantidad de datos faltantes es pequeña o si no son críticos para tu análisis.

Imputación:

  • Implica reemplazar los valores faltantes por estimaciones basadas en otros datos. Puedes utilizar estadísticas como la media, la mediana o la moda para imputar valores faltantes, o incluso modelos de regresión para predecir valores faltantes a partir de datos existentes.

Técnicas avanzadas:

  • También puedes utilizar técnicas más avanzadas, como la imputación múltiple, para manejar datos faltantes de manera más sofisticada.

5. Impacto en análisis y modelos:

  • Es importante comprender cómo los valores faltantes pueden afectar tus análisis y modelos. Pueden introducir segundos, disminuir la precisión y afectar la interpretación de los resultados.

6. Imputación de valores faltante

La imputación es el proceso de estimar o reemplazar los valores faltantes con valores calculados.

7. Evaluación del tratamiento de datos faltantes:

  • Después de tratar los datos faltantes, debes evaluar cómo afecta esto a tu análisis. Esto puede incluir la comparación de resultados antes y después del tratamiento y la consideración de la solidez de tus conclusiones.

8. Documentación y transparencia:

  • Es fundamental documentar y comunicar claramente cómo has manejado los valores faltantes en tus análisis. Esto asegura la reproducibilidad y la comprensión de tu trabajo por parte de otros.

operaciones con valores faltantes son esenciales en el análisis de datos. Debes identificar, comprender y tratar adecuadamente los valores faltantes para garantizar la calidad y la precisión de tus análisis y modelos. La elección de la estrategia de manejo de datos faltantes dependerá del contexto específico de tus datos y del objetivo de tu análisis.

CODIGO DE PANDAS

test_missing_df = pd.DataFrame.from_dict(
    data=dict(
        x=[0, 1, np.nan, np.nan, None],
        y=[0, 1, pd.NA, np.nan, None]
    )
)

El curso que faltaba

Por si alguien no entiende mucho de los presets que coloca para los gráficos:

%matplotlib inline

No es necesario colocarlo ni en Google Colab, ni en Deepnote, ni incluso Visual Studio Code, ya que estos entornos lo tienen por defecto incluido, incluso así es una buena práctica colocarlo. En Jupyter Notebooks los gráficos salen como una ventana emergente, cuando colocas este código aparecen debajo de la celda que lo ejecuta (es decir como siempre lo vemos en Colab o Deepnote)

sns.set(rc = {"figure.figsize": (10, 10)})
sns.set_style("whitegrid")

La documentación de Seaborn indica que seaborn.set podría desaparecer en el futuro y que es un alias para seaborn.set_theme. Por lo que sería más conveniente usar set_theme. Además set_theme es un método general que acepta todo (style, font, context, etc). Dicho esto, las 2 líneas de código se pueden resumir a:

sns.set_theme(style="whitegrid", rc = {"figure.figsize": (10, 10)})
Estoy usando Python 3.10.6 y usando este requirements.txt al menos me deja iniciarpyjanitor==0.26.0missingno==0.5.2numpy==1.26.4matplotlib==3.8.3pandas==2.2.1pyreadr==0.5.0seaborn==0.13.2session-info==1.0.0upsetplot==0.9.0 Estoy apenas empezando, pero debi cambiar las versiones para poder hacerlo. quizas a alguien mas le sirva ```js pyjanitor==0.26.0 missingno==0.5.2 numpy==1.26.4 matplotlib==3.8.3 pandas==2.2.1 pyreadr==0.5.0 seaborn==0.13.2 session-info==1.0.0 upsetplot==0.9.0 ```
Les dejo el código del archivo pandas-missing-extension corregido para que no anden batallando, porque vengo del futuro y da error en algunas partes Simplemente vayan al archivo pandas-missing-extension.ipynb y cambien el código que hay allí por esto ```js import itertools import pandas as pd import upsetplot ``` ```js try: del pd.DataFrame.missing except AttributeError: pass ``` ```js @pd.api.extensions.register_dataframe_accessor("missing") class MissingMethods: def __init__(self, pandas_obj): self._obj = pandas_obj def number_missing(self) -> int: return self._obj.isna().sum().sum() def number_complete(self) -> int: return self._obj.size - self._obj.missing.number_missing() def missing_variable_summary(self) -> pd.DataFrame: return self._obj.isnull().pipe( lambda df_1: ( df_1.sum() .reset_index(name="n_missing") .rename(columns={"index": "variable"}) .assign( n_cases=len(df_1), pct_missing=lambda df_2: df_2.n_missing / df_2.n_cases * 100, ) ) ) 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"]] def missing_variable_table(self) -> pd.DataFrame: return ( self._obj.missing.missing_variable_summary() .value_counts("n_missing") .reset_index(name="n_variables") .rename(columns={"n_missing": "n_missing_in_variable"}) .assign( pct_variables=lambda df: df.n_variables / df.n_variables.sum() * 100 ) .sort_values("pct_variables", ascending=False) ) def missing_case_table(self) -> pd.DataFrame(): return ( self._obj.missing.missing_case_summary() .value_counts("n_missing") .reset_index(name="n_cases") .rename(columns={"n_missing": "n_missing_in_case"}) .assign(pct_case=lambda df: df.n_cases / df.n_cases.sum() * 100) .sort_values("pct_case", ascending=False) ) def missing_variable_span(self, variable: str, span_every: int) -> pd.DataFrame: return ( self._obj.assign( span_counter=lambda df: ( np.repeat(a=range(df.shape[0]), repeats=span_every)[: df.shape[0]] ) ) .groupby("span_counter") .aggregate( n_in_span=(variable, "size"), n_missing=(variable, lambda s: s.isnull().sum()), ) .assign( n_complete=lambda df: df.n_in_span - df.n_missing, pct_missing=lambda df: df.n_missing / df.n_in_span * 100, pct_complete=lambda df: 100 - df.pct_missing, ) .drop(columns=["n_in_span"]) .reset_index() ) def missing_variable_run(self, variable) -> pd.DataFrame: rle_list = self._obj[variable].pipe( lambda s: [[len(list(g)), k] for k, g in itertools.groupby(s.isnull())] ) return pd.DataFrame(data=rle_list, columns=["run_length", "is_na"]).replace( {False: "complete", True: "missing"} ) def sort_variables_by_missingness(self, ascending = False): return ( self._obj .pipe( lambda df: ( df[df.isna().sum().sort_values(ascending = ascending).index] ) ) ) def create_shadow_matrix( self, true_string: str = "Missing", false_string: str = "Not Missing", only_missing: bool = False, ) -> pd.DataFrame: return ( self._obj .isna() .pipe(lambda df: df[df.columns[df.any()]] if only_missing else df) .replace({False: false_string, True: true_string}) .add_suffix("_NA") ) def bind_shadow_matrix( self, true_string: str = "Missing", false_string: str = "Not Missing", only_missing: bool = False, ) -> pd.DataFrame: return pd.concat( objs=[ self._obj, self._obj.missing.create_shadow_matrix( true_string=true_string, false_string=false_string, only_missing=only_missing ) ], axis="columns" ) def missing_scan_count(self, search) -> pd.DataFrame: return ( self._obj.apply(axis="rows", func=lambda column: column.isin(search)) .sum() .reset_index() .rename(columns={"index": "variable", 0: "n"}) .assign(original_type=self._obj.dtypes.reset_index()[0]) ) # Plotting functions --- def missing_variable_plot(self): df = self._obj.missing.missing_variable_summary().sort_values("n_missing") plot_range = range(1, len(df.index) + 1) plt.hlines(y=plot_range, xmin=0, xmax=df.n_missing, color="black") plt.plot(np.array(df.n_missing), plot_range, 'o', color="black") plt.yticks(plot_range, df.variable) plt.grid(axis="y") plt.xlabel("Number missing") plt.ylabel("Variable") def missing_case_plot(self): df = self._obj.missing.missing_case_summary() sns.displot(data=df, x="n_missing", binwidth=1, color="black") plt.grid(axis="x") plt.xlabel("Number of missings in case") plt.ylabel("Number of cases") def missing_variable_span_plot( self, variable: str, span_every: int, rot: int = 0, figsize=None ): ( self._obj.missing.missing_variable_span( variable=variable, span_every=span_every ).plot.bar( x="span_counter", y=["pct_missing", "pct_complete"], stacked=True, width=1, color=["black", "lightgray"], rot=rot, figsize=figsize, ) ) plt.xlabel("Span number") plt.ylabel("Percentage missing") plt.legend(["Missing", "Present"]) plt.title( f"Percentage of missing values\nOver a repeating span of { span_every } ", loc="left", ) plt.grid(False) plt.margins(0) plt.tight_layout(pad=0) def missing_upsetplot(self, variables: list[str] = None, **kwargs): if variables is None: variables = self._obj.columns.tolist() return ( self._obj.isna() .value_counts(variables) .pipe(lambda df: upsetplot.plot(df, **kwargs)) ) ```

Estas son las librerías que se utilizan en el curso.

Janitor. Lo utilizamos para limpieza de datos.
Matplotlib. Para la visualización.
Missingno. Para visualizar valores faltantes.
Numpy y pandas. Para realizar computo científico en Python.
Pyreadr. Para leer archivos.
Seaborn. Para visualización estadística.
Session_info. Para tener un registro de las librerías usadas.
Upsetplot. Para realizar gráfico.

En resumen, las operaciones con valores faltantes son esenciales en el análisis de datos. Debes identificar, comprender y tratar adecuadamente los valores faltantes para garantizar la calidad y la precisión de tus análisis y modelos. La elección de la estrategia de manejo de datos faltantes dependerá del contexto específico de tus datos y del objetivo de tu análisis.

detesto deepnote, me quedo mil veces con jupyter.

Es curso mas nuevo en mis dos años en platzi

Mi momento favorito de la clase 10:15
Al inicio me aparecía un error al importar `janitor`, pero utilizar la siguiente versión resolvió el problema :D ```js pyjanitor==0.26.0 ```pyjanitor==0.26.0
Con esto cree mi entorno virtual ```sh \#Crear un entorno llamado detección con python 3.9 conda create --name deteccion python=3.9 \#Para que sea más rápido lo haré con mamba mamba create --name deteccion python=3.9 \#activar el entorno conda activate deteccion \#instalar las dependencias desde requirements.txt mamba install --file requirements.txt \#crear archivo requirements.txt si no lo tengo mamba env export > requirements.txt ``` Abre un bloc de notas y guarda el siguiente contenido como "requirements.txt" pyjanitor missingno numpy matplotlib==3.5.1 pandas pyreadr seaborn session-info upsetplot==0.6.1 jupyter jupyterlab PS: Espero funcione bien jajaa saludos!
En el manejo de datos, es común encontrarse con valores faltantes (o `NaN` en Pandas y NumPy). Estos valores pueden causar problemas en los análisis si no se manejan adecuadamente. A continuación, te muestro algunas operaciones comunes para trabajar con valores faltantes utilizando \*\*Pandas\*\*. \### 1. \*\*Detectar valores faltantes\*\* Para identificar los valores faltantes en un `DataFrame` o `Series`, se pueden usar los métodos `isnull()` o `isna()`, que devuelven un DataFrame de booleanos. ```python import pandas as pd df = pd.DataFrame({ 'A': \[1, 2, None, 4], 'B': \[None, 2, 3, 4], 'C': \[1, None, None, 4] }) \# Detectar valores faltantes df.isnull() ``` Salida: ```plaintext A B C 0 False True False 1 False False True 2 True False True 3 False False False ``` \### 2. \*\*Contar valores faltantes\*\* Puedes contar cuántos valores faltantes hay en cada columna utilizando `isnull().sum()`. ```python \# Contar valores faltantes por columna df.isnull().sum() ``` Salida: ```plaintext A 1 B 1 C 2 dtype: int64 ``` \### 3. \*\*Eliminar valores faltantes\*\* Para eliminar filas o columnas con valores faltantes, se utiliza `dropna()`. \- \*\*Eliminar filas con valores faltantes\*\*: ```python df\_sin\_nan = df.dropna() ``` Esto eliminará cualquier fila que contenga al menos un valor faltante. \- \*\*Eliminar columnas con valores faltantes\*\*: ```python df\_sin\_nan\_columnas = df.dropna(axis=1) ``` Esto eliminará cualquier columna que tenga al menos un valor faltante. \### 4. \*\*Rellenar valores faltantes\*\* En lugar de eliminar los valores faltantes, puedes optar por rellenarlos con algún valor. Esto se puede hacer con el método `fillna()`. \- \*\*Rellenar con un valor constante\*\*: ```python df\_relleno = df.fillna(0) ``` Aquí, todos los valores `NaN` se reemplazan por `0`. \- \*\*Rellenar con la media, mediana o moda\*\*: \- Media: ```python df\['A'] = df\['A'].fillna(df\['A'].mean()) ``` \- Mediana: ```python df\['B'] = df\['B'].fillna(df\['B'].median()) ``` \- Moda: ```python df\['C'] = df\['C'].fillna(df\['C'].mode()\[0]) ``` \- \*\*Rellenar con el valor anterior o siguiente (forward fill / backward fill)\*\*: \- Rellenar con el valor anterior: ```python df\_forward\_fill = df.fillna(method='ffill') ``` \- Rellenar con el valor siguiente: ```python df\_backward\_fill = df.fillna(method='bfill') ``` \### 5. \*\*Interpolar valores faltantes\*\* Para valores numéricos, puedes usar la interpolación para estimar los valores faltantes basándote en los valores vecinos. ```python \# Interpolación lineal df\_interpolado = df.interpolate() ``` \### 6. \*\*Reemplazar valores específicos\*\* Si deseas reemplazar un valor específico (como `None`, `NaN`, o un número), puedes usar el método `replace()`. ```python df\_reemplazo = df.replace({None: 0}) ``` \### 7. \*\*Verificar si hay valores faltantes\*\* Para saber si hay algún valor faltante en el `DataFrame`, puedes usar `isnull().values.any()`. ```python \# Verificar si hay valores faltantes df.isnull().values.any() ``` \### Ejemplo completo: ```python import pandas as pd \# Crear un DataFrame con valores faltantes df = pd.DataFrame({ 'A': \[1, 2, None, 4], 'B': \[None, 2, 3, 4], 'C': \[1, None, None, 4] }) \# Detectar valores faltantes print("Valores faltantes:") print(df.isnull()) \# Contar valores faltantes por columna print("\nConteo de valores faltantes:") print(df.isnull().sum()) \# Eliminar filas con valores faltantes print("\nDataFrame sin filas con valores faltantes:") print(df.dropna()) \# Rellenar valores faltantes con un valor constante print("\nRellenar valores faltantes con 0:") print(df.fillna(0)) \# Rellenar con la media de la columna print("\nRellenar la columna 'A' con la media:") df\['A'] = df\['A'].fillna(df\['A'].mean()) print(df) \# Interpolación para rellenar valores faltantes print("\nInterpolación de valores faltantes:") print(df.interpolate()) ``` \### Conclusión Pandas ofrece herramientas muy flexibles para detectar, eliminar, rellenar, y reemplazar valores faltantes en tus datos. Dependiendo del análisis que quieras realizar, podrás elegir la mejor técnica para manejar estos valores.
Alguien sabe las versiones correctas para que corra perfectamente? llevo todo el dia intentando encontrar las versinoes, en mi caso uso vsc
Hola 👋 A continuación les dejo un link con la documentación oficial de pandas sobre el manejo de datos faltantes. <https://pandas.pydata.org/docs/user_guide/missing_data.html> Espero les sea de utilidad :)
```txt #REQUIREMENT Python 3.11 asttokens==2.4.1 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 fonttools==4.50.0 ipykernel==6.29.3 ipython==8.22.2 jedi==0.19.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 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 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 xarray==2024.2.0 ```
```js backcall==0.2.0 colorama==0.4.6 cycler==0.11.0 debugpy==1.7.0 decorator==5.1.1 entrypoints==0.4 fonttools==4.38.0 importlib-metadata==6.7.0 ipykernel==6.16.2 ipython==7.34.0 jedi==0.19.1 jupyter-client==7.4.9 jupyter-core==4.12.0 kiwisolver==1.4.5 matplotlib==3.5.3 matplotlib-inline==0.1.6 missingno==0.5.2 multipledispatch==1.0.0 natsort==8.4.0 nest-asyncio==1.6.0 numpy==1.21.6 packaging==24.0 pandas==1.3.5 pandas-flavor==0.6.0 parso==0.8.3 pickleshare==0.7.5 Pillow==9.5.0 prompt-toolkit==3.0.43 psutil==5.9.8 pygments==2.17.2 pyjanitor==0.23.1 pyparsing==3.1.2 pyreadr==0.4.7 python-dateutil==2.9.0.post0 pytz==2024.1 pywin32==306 pyzmq==25.1.2 scipy==1.7.3 seaborn==0.12.2 session-info==1.0.0 six==1.16.0 stdlib-list==0.10.0 tornado==6.2 traitlets==5.9.0 typing-extensions==4.7.1 UpSetPlot==0.6.1 wcwidth==0.2.13 xarray==0.20.2 zipp==3.15.0 ```

print(
    True  or None,  # True
    False or None,  # None
    sep="\n"
)

print(
    True or np.nan,     # True
    False or np.nan,    # nan
    sep="\n"
)

Me encanto la forma en la que el profesor compartió los notebooks, son perfectos para estudiar y practicar.

🚀Te enseño como corregir un error de importacion

👉Ya que estamos comenzando es fundamental que las librerias se carguen de manera correcta. Este es un error que me sucedio a mi con la libreria janitor.

Cuando corres el codigo en ocasiones tu puede saltar una anuncio que indica que a tu entorno virtual le puede estar faltanta un modulo para correr una libreria

✅La solucion la encontre gracias a @jvelezmagic y es muy sencilla. Simplemente vas a la carpeta Files, buscas el archivo requirements.txt. Alli posiblemente esté el fallo, debido a que en el proceso pudiste haber descargado modulos que son incompatibles entre si.

La leccion es que debes estar atento de que los modulos y las librerias correspondan entre si tomando en cuenta las versiones que estas utilizando.

Para simplificar el aprendizaje, aqui te dejo la estructura correcta del archivo requirements.txt:

pyjanitor
missingno
numpy
matplotlib==3.5.1
pandas
pyreadr
seaborn
session-info
upsetplot==0.6.1

Respecto a la herramienta es lo mismo si se usa Jupyter’lab?

En Python, la diferencia entre hacer una comparación con == e is radica en lo siguiente:

==: compara dos objetos, el caso más típico donde usamos una condicional.
is: compara si ambos objetos apuntan a la misma dirección en memoria.

Que genio el profe, claramente un tipo con un IQ muyy alto!, hermosos los astronautas

2. Operaciones con valores faltantes

  • Diferentes herramientas, diferentes resultados por defecto.
  • Aprender otro idioma no es solo aprender diferentes palabras para las mismas cosas, sino aprender otra forma de pensar sobre las cosas.

Aquí la página en github de los notebooks:

link

Estoy usando jupyter y estaba teniendo problemas para la instalación. Pero ChatGPT es de gran ayuda. Si estan en mi misma situación, consulten sus problemas con ChatGPT.

Lo mejor de los cursos de Jesús es que va a lo que es, teoría con aplicación, Learning by Doing.

(10:15) El que ‘None’ en la columna ‘x’ cambio a ‘nan’ mientras que en la columna ‘y’ se mantiene como ‘None’… esta conectado en cómo pandas interpreta la columna (en este caso ‘float64’ y ‘object’).

E interpretará como ‘object’ mientras que uno de sus elementos sea un objeto de pandas como pd. NA o pd.NaT.

Sin embargo todos son interpretados por pandas como ‘missing values’ o ‘valores faltantes’ (a pesar que ‘none’ significa ‘ninguno’, ‘nan’ significa ‘not an number’). PD: ‘NA’ significa ‘not available’ o ‘no disponible’.