Python Pandas: trabalhando com dados nulos

Trabalhando com dados nulos - Trabalhando com dados nulos

Olá, meu nome é Mirla Costa!

Audiodescrição: Mirla dse declara uma mulher de pele clara. Tem cabelos pretos e cacheados com comprimento até a metade de suas costas e olhos pretos. Usa óculos de grau de armação redonda prateada, camisa preta e um batom vermelho. Ao fundo, uma parede tem duas prateleiras com objetos de decoração e está iluminada com luzes LED verde a azul. À frente de Mirla há um microfone em um suporte.

Neste vídeo, apresentarei algumas formas que o Pandas disponibiliza para trabalharmos com dados nulos. Para essa apresentação, construímos um material em um notebook do Google Colab, o qual você poderá acessar e consultar depois.

Dados nulos representam informações faltantes ou que simplesmente não existem. Dentro da programação Python, conseguimos identificar essas informações através do** tipo NaN. Pode variar também entre os tipos NA, para string, ou NaT, quando lidamos com o tipo de dados datetime.

Encontrando valores nulos

Começaremos com import da biblioteca Pandas, já que utilizaremos suas funções, em uma nova célula, executamos o código:

import pandas as pd

Após importarmos a biblioteca pandas, criamos um dataframe relacionado a vendas. É importante destacar que as colunas id_vendedor e valor_unidade não têm dados nulos, e a primeira linha desse dataframe também não terá dados nulos.

vendas = {
    "id_vendedor": [101, 102, 103, 104, 105],
    "id_cliente": [201, None, 203, 204, None],
    "quantidade_compras": [5, 3, None, 2, None],
    "valor_unidade": [20.0, 15.5, 10.0, 4.0, 25.0],
    "valor_total": [100.0, 46.5, None, None, 125.0]
}
df = pd.DataFrame(vendas)
df

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	101	201.0	5.0	20.0	100.0
1	102	NaN	3.0	15.5	46.5
2	103	203.0	NaN	10.0	NaN
3	104	204.0	2.0	4.0	NaN
4	105	NaN	NaN	25.0	125.0

Executamos a célula para a criação do nosso dataframe e já o temos. Os campos com o valor NaN são de valores nulo, como na segunda linha da coluna id_cliente.

Identificando valores nulos no dataframe

Agora que já temos nosso conjunto de dados, vamos entender como podemos identificar valores nulos em um dataframe. Existe, no Pandas, a função isnull, que podemos utilizar para identificar valores ausentes.

Em uma nova célula, executaremos o df.isnull(). Receberemos os campos que possuem valores nulos, representados como True.

df.isnull()

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	False	False	False	False	False
1	False	True	False	False	False
2	False	False	True	False	True
3	False	False	False	False	True
4	False	True	True	False	False

Essa função retorna valores booleanos, então True indica onde há valores nulos, e onde não há, será representado como False. Existem também outras funções relacionadas à identificação. Elas estão descritas no material, e você poderá ler depois.

Identificando valores nulos em uma coluna

É válido destacar que podemos utilizar a função isnull() em colunas, não precisa ser no dataframe todo. Por exemplo, vamos aplicá-la à coluna valor_total:

df["valor_total"].isnull()

#	valor_total
0	False
1	False
2	True
3	True
4	False

Observando as linhas com valores nulos

Ainda podemos utilizar essa series para observar os dados nas linhas onde há esses valores nulos, no caso, as linhas 2 e 3. Para fazer isso, chamamos o dataframe df[] e, entre os colchetes, identificamos a coluna com os valores nulos (valor_total), passando o isnull().

df[df["valor_total"].isnull()]

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
2	103	203.0	NaN	10.0	NaN
3	104	204.0	2.0	4.0	NaN

Ao executar, visualizamos as duas linhas onde estão os valores nulos da coluna especificada (valor_total).

Uma dica, a função info() nos auxilia a identificar valores nulos. Ao executamos o df.info() recebemos os dados de quantas linhas temos no banco de dados e quantos valores não nulos existem em cada linha.

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 5 columns):
 #   Column              Non-Null Count  Dtype  
---  ------              --------------  -----  
 0   id_vendedor         5 non-null      int64  
 1   id_cliente          3 non-null      float64
 2   quantidade_compras  3 non-null      float64
 3   valor_unidade       5 non-null      float64
 4   valor_total         3 non-null      float64
dtypes: float64(4), int64(1)

Observamos a marcação de 3 em id_cliente e em quantidade de compras. Isso mostra que existem valores nulos no dataframe.

Contagem de valores nulos

Agora que sabemos da existência de valores nulos, podemos contar quantos são, com a função sum() depois da função isnull(). Isso nos permite observar quantos valores nulos existem para cada coluna.

df.isnull().sum()

	0
id_vendedor	0
id_cliente	2
quantidade_compras	2
valor_unidade	0
valor_total	2

Para identificar o total geral de valores nulos, é só adicionar outra função sum() em seguida da primeira:

df.isnull().sum().sum()

6

Assim, somamos todos os valores nulos, e recebemos que existem 6 valores nulos totais dentro do nosso dataframe.

Preenchendo valores nulos

Agora que sabemos quantos são, podemos pensar em como preencher esses dados. Uma das formas que o Pandas disponibiliza para preencher esses dados é utilizando a função fillna() (Fill NA - Preencher NA) no dataframe. Entre parênteses, especificamos o valor que substituirá ou preencherá os campos nulos.

df.fillna(0)

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	101	201.0	5.0	20.0	100.0
1	102	0.0	3.0	15.5	46.5
2	103	203.0	0.0	10.0	0.0
3	104	204.0	2.0	4.0	0.0
4	105	0.0	0.0	25.0	125.0

No caso, preenchemos os valores nulos um zero (0). Ao executarmos a célula, observamos que não existem mais valores nulos, e os campos que eram nulos estão como zero.

Preenchendo os valores de uma coluna

Podemos fazer o mesmo processo em uma coluna específica, com o nosso fillna(). Especificamos a coluna do dataframe, como quantidade_compras, aplicamos a função e teremos apenas a coluna desejada com os valores preenchidos.

df['quantidade_compras'].fillna(0)

#	quantidade_compras
0	5.0
1	3.0
2	0.0
3	2.0
4	0.0

Preenchendo com valores que já existem na tabela

Outro método interessante é o ffill(), que nos permite substituir o valor NaN pelo valor da linha anterior a ele.

df.ffill()

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	101	201.0	5.0	20.0	100.0
1	102	201.0	3.0	15.5	46.5
2	103	203.0	3.0	10.0	46.5
3	104	204.0	2.0	4.0	46.5
4	105	204.0	2.0	25.0	125.0

Executamos essa célula e todos os valores NaN são substituídos pelo valor que está na linha anterior. No caso, 201 substituiu o NaN anterior. Inversamente, temos o bfill(), que substitui os valores NaN pelo valor da linha posterior.

df.bfill()

Linhas que não têm linhas posteriores, não são substituídas nesse caso, como vemos na última linha do nosso dataframe. Outra forma de preenchimento é utilizar o interpolate(), uma função que utiliza a técnica matemática de interpolação para preencher os dados que são NaN.

df.interpolate()

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	101	201.0	5.0	20.0	100.000000
1	102	202.0	3.0	15.5	46.500000
2	103	203.0	2.5	10.0	72.666667
3	104	204.0	2.0	4.0	98.833333
4	105	204.0	2.0	25.0	125.000000

Removendo valores nulos

Quando o preenchimento não é a melhor solução, podemos utilizar a função dropna(), para remover os valores nulos. Por padrão, essa função remove todos os valores nulos, então as linhas com valores nulos são cortadas.

df.dropna()

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	101	201.0	5.0	20.0	100.0

Nesse caso, termos apenas a primeira linha como resultado. Caso não queiramos cortar as linhas, mas sim as colunas onde houver NaN, usamos parâmetro chamado axis. Definirmos o parâmetro como 1, porque o padrão é 0. Quando fazemos isso, ficam apenas as colunas que não têm valores nulos.

df.dropna(axis=1)

#	id_vendedor	valor_unidade
0	101	20.0
1	102	15.5
2	103	10.0
3	104	4.0
4	105	25.0

Removendo valores nulos com base em uma coluna específica

Outra possibilidade é filtrarmos. Usaremos o dropna() para remover as linhas com base nos valores nulos de uma coluna específica. Para isso, usamos o parâmetro subset. Nele, definimos as colunas que precisam ser analisadas.

df.dropna(subset = ['id_cliente'])

#	id_vendedor	id_cliente	quantidade_compras	valor_unidade	valor_total
0	101	201.0	5.0	20.0	100.0
2	103	203.0	NaN	10.0	NaN
3	104	204.0	2.0	4.0	NaN

Executamos a célula e apenas as linhas onde há NaN na nossa coluna especificada (id_cliente) foram cortadas. As outras não são afetadas.

Conclusão

Existe também uma extensão desse material para conhecer outros parâmetros interessantes para ajustar o dropna(). Com isso, já aprendemos as funções e os parâmetros necessários para tratar os dados nulos utilizando o Pandas.

Agora, você tem aptidão para fazer os exercícios.

Boas práticas e até mais!

Sobre o curso Python Pandas: trabalhando com dados nulos

O curso Python Pandas: trabalhando com dados nulos possui 8 minutos de vídeos, em um total de 13 atividades. Gostou? Conheça nossos outros cursos de Data Science em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Trabalhando com dados nulos