Ejercicio de validación de datos

Hola, si desean saber cuales son las filas con valores nulos y en que columnas se encuentran pueden usar el siguiente código:

Hallamos cuales son las filas con al menos un valor nulo

Visualizamos las filas con al menos un valor nulo :

Pensé que solo iba a aprender de validación de datos y terminé aumentando como por x10 mis conocimientos en manejo de pandas y python

Este curso está muy bueno!!

Para quienes no sabiamos de la existencia de .pipe(), lo que hace es Aplicar la función entre paréntesis a mi df, acá se usó para no asignar todo el proceso anterior a una variable, pero podemos tener el mismo resultado si utilizamos el siguiente código para hacer la gráfica de la proporción de valores nulos por variable:

sns.displot(
    preprocess_penguins_df.isna().melt(), y='variable', hue='value', multiple='fill', aspect=2
)

Un método de la librería pandes que nos suele dar mucha información del dataframe es info(), la cual si la aplicamos a nuestro conjunto de datos de pingüinos nos daría el siguiente resultado:

RangeIndex: 344 entries, 0 to 343
Data columns (total 8 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   species            344 non-null    object 
 1   island             344 non-null    object 
 2   bill_length_mm     342 non-null    float64
 3   bill_depth_mm      342 non-null    float64
 4   flipper_length_mm  342 non-null    float64
 5   body_mass_g        342 non-null    float64
 6   sex                333 non-null    object 
 7   year               344 non-null    int64  
dtypes: float64(4), int64(1), object(3)
memory usage: 21.6+ KB

Validacion de Datos

• dtypes muestra el tipo de dato de cada variable

preprocess_penguins_df.dtypes

• Forma alternativa de presentar el codigo de manera lineal

(
    preprocess_penguins_df
    .dtypes
    .value_counts()
)

• shape muestra el tamaño del dataset

preprocess_penguins_df.shape

• isnull() asigna True para celdas donde hay valores nulos y False donde no los hay. any() permite resumir toda la informacion en una tabla

(
    preprocess_penguins_df
    .isnull()
    .any()
)

• sum() suma todos los valores de una variable dada. En este caso permite mostrar la cantidad de valores nulos por cada variable

(
    preprocess_penguins_df
    .isnull()
    .sum()
)

• Para contar todos los valores nulos que existen en la tabla se agrega la funcion sum nuevamente.

(
    preprocess_penguins_df
    .isnull()
    .sum()
    .sum()
)

• Para mostrar la proporcion de valores nulos que existen en una tabla, utilizamos la libreria seaborn para verlo de manera grafica

(
    preprocess_penguins_df
    .isnull()
    .melt() #convierte el dataframe en un formato de solo dos identificadores columna 'variable', 'valor'
    .pipe( # encadena funciones que esperan objetos de tipo Series, DataFrame o GroupBy
        lambda df:(
            sns.displot(
                data=df,
                y='variable',
                hue='value',
                multiple='fill',
                aspect=2
            )
        )
    )
)

• Para los valores nulos en todo el conjunto de datos utilizamos un mapa de calor de la libreria seaborn

(
    preprocess_penguins_df
    .isnull()
    .transpose()
    .pipe(
        lambda df:(
            sns.heatmap(
                data=df
            )
        )
    )
)

Para explorar valores nulos algo práctico que hago es calcular su porcentaje

# % of NaN Values
(df.isna().sum() / df.shape[0])  * 100

# result: 
species              0.000000
island               0.000000
bill_length_mm       0.581395
bill_depth_mm        0.581395
flipper_length_mm    0.581395
body_mass_g          0.581395
sex                  3.197674
year                 0.000000

Tremenda clase, muy util.

escribiendo .T te trae la transpuesta de una matriz, en este caso el df se comporta como una

(
  pre_penguin_df
  .isnull()
  .T
)

Por fin un curso de EDA donde no se hacen análisis de forma básica como en la mayoría de otros cursos en otras plataformas. Esto es oro puro!!!

In Pandas, the pipe() function is used to chain custom functions together in a single expression.

The pipe() function allows you to apply a sequence of custom functions to a DataFrame or Series, where the output of one function is used as the input to the next function. This can make your code more concise and easier to read, especially when you need to perform multiple operations on the same DataFrame or Series.

Here’s a simple example that demonstrates how the pipe() function works. Suppose you have the following DataFrame:

import pandas as pd
import numpy as np

data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
df = pd.DataFrame(data)

You can use the pipe() function to apply a sequence of custom functions to this DataFrame, like this:

def add_one(df):
    return df + 1

def multiply_by_two(df):
    return df * 2

result = df.pipe(add_one).pipe(multiply_by_two)

In this example, we define two custom functions (add_one() and multiply_by_two()) that modify a DataFrame in some way. We then call the pipe() function twice, passing in each custom function as an argument. The pipe() function then applies these functions to the DataFrame in sequence, with the output of one function becoming the input to the next function.

In the end, the result variable will contain the following DataFrame:

   A   B
0  4  10
1  6  12
2  8  14

This DataFrame is the result of first adding one to each element of the original DataFrame, and then multiplying each element by two.

Note that the pipe() function is optional and not always necessary. You can also apply multiple functions to a DataFrame using method chaining or by passing the output of one function as the input to the next function directly. However, the pipe() function can make your code more readable and easier to maintain in some cases.

El problema de deepnote es que muy lento en ocasiones.

Para saber el conteo total de filas, total de campos nulos, total de filas con algun campo nulo y ademas, cuantas filas quedarian luego de borrar los campos nulos puedes usar el siguiente codigo

null_fields = sum(
    prepocess_penguins_df
    .isnull()
    .values
    .ravel()
    ) # con esto podemos contar el total de campos nulos

null_rows = sum(
    [True for idx,row in prepocess_penguins_df.iterrows() if any(row.isnull())] 
    # esta list comprehension te permite valida por cada fila y columna si existe o no un campo  nulo y lo cuenta mediente un condicional
)

total_rows = sum(
    [True for idx,row in prepocess_penguins_df.iterrows()]
)

print(f'Numero de campos nulos: {null_fields} \nNumero de filas que tengan al menos 1 campo nulo: {null_rows} \nTotal de filas: {total_rows} \nCantidad total despues de borrar las filas con campos nulos: {total_rows - null_rows}') 

Esta clase es muy útil 🥇

Otra manera de ver la existencia de valores nulos es mediante una gráfica con seaborn.

sns.heatmap(preprocess_penguins_df.isnull(), yticklabels=False, cbar=False, cmap="Blues");

Hola, si no entendiste el grafico de 8:50.
Este grafico busca demostrarte en que parte del dataset no se tiene informacion.
en el eje Y, tienes las variables= columnas.
si vas a la tabla original y buscas el rango por ejemplo de 1 a 8 vas a ver que hay de 1 a 8 una observacion = fila que no tiene informacion.
entonces:
vamos con un ejemplo.
digamos que quieres saber a que se refiere la 4ta linea en el heatmap.
entonces, identificas el numero:
176, ve a la tabla original y mira en el 176 a que observacion se refiere:
aqui encontré la observacion(fila)
preprocess_penguins_df.iloc[178]
con iloc puedo buscar una fila en especifico
species Gentoo
island Biscoe
bill_length_mm 44.5
bill_depth_mm 14.3
flipper_length_mm 216.0
body_mass_g 4100.0
sex NaN
year 2007
Name: 178, dtype: object
y segun el heat map:
el numero 176(en el dataset 178).
la informacion restante es SEX.
y si, es cierto, mira que en el dataset lo que está en null es el sexo.
si hubiera mas

es sin duda un hermoso grafico, un poquitico complejo para entender a primeras.
pero dale, tu puedes variables en null pues entonces esa linea sería mas larga.

Una libreria que nos puede ayudar a ver los valores nulos es missingno !!

Para ver la proporción de valores nulos con una sola línea se puede usar simplemente missingno.

import missingno as mno

mno.bar(df)

print("Numero de observaciones = {}".format(pingui_df.shape[0]))
print("Total numero de columnas = {}".format(pingui_df.columns.shape[0]))
print("Recuento de columnas con valores nulos:-")
print(pingui_df.isnull().sum())

Si quieren saber cuantos registros tienen mas de un valor faltante sin utilizar el método gráfico, utilicen el siguiente código

 (
    preprocess_penguins_df
    .isnull()
    .transpose()
    .sum(axis=0)
    .value_counts()
)

aquí se están sumando los False y los True pero a lo largo de las filas. ‘0’ son los registros que no tienen ningún dato faltante, ‘1’ son los que tienen un solo dato faltante, y ‘5’ son los que tienen 5 datos faltantes. Como pueden ver, la suma de la cantidad de ‘1’ y ‘5’ da 11, que son las filas eliminadas al final.

en total vi las primeras 2 clases 3 veces, por que no me atraía el curso y lo abandonaba, esta vez seguí y wooow, se pone muy bueno el curso,

las primeras dos clases me siguen pareciendo poco dinamicas, pero agradezco haber seguido viendo y recomendare este curso a compañeros

Utilizando .isnull como .isna obtuve el mismo resultado.

Dejo la plantilla para quien quiera usar plotly no tenga que modificar con update_layout a cada rato la figura.

import plotly.graph_objects as go
import plotly.io as pio

pio.templates['new_template'] = go.layout.Template()
pio.templates['new_template']['layout']['font'] = {'family': 'verdana', 'size': 16, 'color': 'white'}
pio.templates['new_template']['layout']['paper_bgcolor'] = 'black'
pio.templates['new_template']['layout']['plot_bgcolor'] = 'black'
pio.templates['new_template']['layout']['xaxis'] = {'title_standoff': 10, 'linecolor': 'black', 'mirror': True, 'gridcolor': '#EEEEEE'}
pio.templates['new_template']['layout']['yaxis'] = {'title_standoff': 10, 'linecolor': 'black', 'mirror': True, 'gridcolor': '#EEEEEE'}
pio.templates['new_template']['layout']['legend_bgcolor'] = 'rgb(117, 112, 179)'
pio.templates['new_template']['layout']['height'] = 700
pio.templates['new_template']['layout']['width'] = 1000
pio.templates['new_template']['layout']['autosize'] = False

pio.templates.default = 'new_template'

import plotly.express as px

preprocess_penguins_df.isna().melt().pipe(lambda df:(px.histogram(df, y='variable', color='value', opacity=0.8)))

preprocess_penguins_df.isnull().transpose().pipe(lambda df:(px.imshow(df, color_continuous_scale='Portland')))

Es interesante la forma de eliminar los valores nulos. No sabia que se podia usar este metodo. Es muy util.

¿Cuántas observaciones perdemos si eliminamos los datos faltantes?

¿Cuál es la proporción de valores nulos por cada variable?

Una alternativa:

Si agregamos las siguientes líneas:

Muy interesante:

help(palmerpenguins.penguins)

Wowww esto se está poniendo interesante jeje

Buenisimo como explica Jesus, un grande!!

Jesus++;

• isna() y isnull() son dos funciones equivalentes en Pandas.

• isnull() fue la función originalmente introducida en Pandas para verificar valores nulos.

• isna() se agregó como un alias de isnull() posteriormente para proporcionar una opción más intuitiva y coherente con la terminología de Python.

Pipe: Es un operador que permite tomar la salida de un comando y pasarla como entrada de otro comando.
melt: Retorna los valores por variable y value

Excelente curso, brinda todas las funciones necesarias para responder preguntas fundamentales al momento de realizar análisis exploratorio de datos

In Pandas, isna() and isnull() are essentially the same thing. They are both used to detect missing values in a DataFrame or Series. According to the Pandas documentation, isna() is an alias for isnull().¹²

I hope that helps! Let me know if you have any other questions.

Source: Conversation with Bing, 3/21/2023(1) Pandas Isna Vs Isnull - Differences Explained - Stack Vidhya. https://www.stackvidhya.com/pandas-isna-vs-isnull/ Accessed 3/21/2023.
(2) Is there any distinction between isnull() and isna() method of pandas … https://medium.com/geekculture/is-there-any-distinction-between-isnull-and-isna-method-of-pandas-dataframe-47095c16f026 Accessed 3/21/2023.
(3) python - Difference between isna() and isnull() in pandas - Data … https://datascience.stackexchange.com/questions/37878/difference-between-isna-and-isnull-in-pandas Accessed 3/21/2023.
(4) Pandas isna() and isnull(), what is the difference?. https://stackoverflow.com/questions/52086574/pandas-isna-and-isnull-what-is-the-difference Accessed 3/21/2023.

Tambien podriar utilizar el metodo info() de pandas. Que proporciona información del tipo de datos y la cantidad de registros por columna.

Una manera de responder a la pregunta “¿Cuántas observaciones perdemos si eliminamos los datos faltantes?” es mediante la siguiente instrucción:

(df.shape)[0] - ((df.dropna()).shape)[0]

• La validación de datos es un proceso importante que implica la verificación de la integridad y exactitud de los datos antes de su análisis y uso.

La validación de datos es necesaria para garantizar que los resultados obtenidos a partir de los datos sean precisos y confiables.
isnull() y isna() son dos funciones que se utilizan para detectar valores faltantes (NA) en un DataFrame de Pandas. Sin embargo, hay una diferencia sutil entre ellos.

isnull() es una función que se utiliza para detectar valores NA en un DataFrame de Pandas. Devuelve un DataFrame booleano que indica si cada elemento en el DataFrame es un valor NA o no.

isna() es un alias para isnull(), por lo que ambas funciones son equivalentes.

En resumen, ambas funciones cumplen el mismo propósito, y puedes usar la que prefieras o la que consideres más fácil de recordar o leer en el código.

Para calcular nulos de forma descendente, yo utilizo:

df.isna().sum().sort_values(ascending = False)

ya que el target es determinar el sexo podríamos ignorar los null en sexo para obtener los valores nulos y en ese caso se puede hacer con este código que nos da solo 2 cols

df[df.drop(columns='sex').isnull().any(axis=1)]

Con este código Filtre los datos con nulos para visualizar el mapa de calor solo con los elementos con datos nulos.

sns.heatmap(
            data = (
                    df_penguins.isnull()
                             .replace({True: 1, False: 0})
                             .assign(Total_Nulos=lambda x: x.sum(axis=1))
                             .pipe(
                                 lambda x: x[x['Total_Nulos'] > 0]
                             .T
                             )
                    )
           );

Para saber cuantos registros perdimos sería con el siguiente código.

df_penguins.shape[0] - df_penguins_nn.shape[0]

Donde:

• df_penguins_nn es mi df donde ya eliminé los registros con valores nulos.

También podemos obter información con:

.info()