Aprenda a usar o Pandas Where e o NumPy Where para fazer análise de dados! Veja a diferença entre esses dois métodos e como eles funcionam.
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Na aula de hoje, vou te mostrar como fazer análise de dados com Pandas Where e NumPy Where. Você verá a diferença entre esses 2 métodos no Python e como cada um deles funciona e pode ser utilizado para a análise de dados.
Esses dois comandos nos permitem aplicar lógicas condicionais dentro da análise de dados. Com eles, podemos avaliar se o valor já existe ou não no DataFrame e, a partir do resultado, definir o que será feito.
Então, faça o download do material disponível e venha aprender na prática o que é e como fazer análise de dados com Pandas Where e NumPy Where.
A base de dados que iremos utilizar foi baixada do Kaggle e consiste em informações sobre gorjetas recebidas por garçons em dias de trabalho.
Vamos criar e visualizar as cinco primeiras linhas do nosso DataFrame para saber quais dados encontraremos.
import pandas as pd
DADOS = "dados/tips.csv"
df = pd.read_csv(DADOS)
df.head()
Dentro dessa base de dados, teremos algumas informações sobre o pedido, como o valor total da conta, o valor da gorjeta, o gênero do cliente, se é fumante, em qual dia da semana foi o atendimento, em qual horário (refeição), e quantas pessoas estavam na mesa.
Antes de partirmos para o foco da aula, é importante conhecermos um pouco mais sobre a base de dados, fazer uma análise inciial dos dados, e reconhecê-los.
Para isso, utilizaremos o método info, que retornará as informações gerais sobre a base de dados, como a quantidade de entradas, os tipos de dados de cada uma das colunas e a presença ou não de valores nulos.
df.info()
Nesse caso, não temos nenhum valor nulo e contamos com 244 entradas, sendo elas de elemento do tipo float, texto (object) e inteiro (int).
Como não temos valores nulos e os tipos de dados referentes às colunas estão corretos, não precisaremos nos preocupar em realizar nenhum tipo de tratamento inicial nessa base de dados.
Em seguida, podemos utilizar o método describe para termos algumas informações estatísticas do DataFrame, com contagem dos elementos não nulos (count), média (mean), desvio padrão (std), mínimo (min), quartis (25%, 50%, 75%) e máximos (max).
df.describe()
Podemos também verificar os valores não numéricos passando o parâmetro exclude= “number” para o método describe.
df.describe(exclude="number")
Nessa análise, podemos verificar a quantidade de valores únicos presentes nas colunas não numéricas (unique), qual valor mais aparece entre esses (top) e a quantidade em que aparece (freq).
Podemos verificar cada um dos valores únicos dessas colunas não numéricas através do método select_dtypes. Para isso, faremos um loop for, percorrendo cada uma das colunas do nosso DataFrame cujo tipo seja object.
for coluna in df.select_dtypes(include="object"):
print(f"{coluna}: {df[coluna].unique()}")
Como nosso foco principal é nas gorjetas recebidas, podemos explorar a coluna tip, criando um histograma para que possamos visualizar e compreender como se deu a distribuição dessas gorjetas.
df["tip"].hist()
É possível observar a partir desse gráfico que a maior parte das gorjetas se encontra entre 2 e 3 dólares.
Inclusive, podemos utilizar um boxplot para identificar possíveis outliers.
df.boxplot("tip", vert=False, grid=False)
Observando esse boxplot, podemos identificar alguns outliers superiores. Ou seja, valores acima do limite estabelecido pelo intervalo interquartil multiplicado por 1,5. Esses pontos são considerados atípicos em relação à distribuição geral dos dados.
Agora que fizemos o reconhecimento da nossa base de dados, podemos partir para o foco da aula, começando pelo método where do Pandas.
O método where do Pandas é utilizado em DataFrames para aplicar condições, mantendo ou substituindo valores com base na veracidade da condição.
Quando a condição é atendida, ou seja, é verdadeira, os valores originais são mantidos no DataFrame. Caso contrário, são substituídos pelos valores determinados.
Vamos ver como isso funciona na prática, destacando os valores acima da média de gorjeta. Podemos verificar essa média, com o método mean.
df["tip"].mean()
Podemos usar o método where para encontrar os valores que estão acima dessa média, passando essa condição como argumento.
df.where(df["tip"] > df["tip"].mean())
Repare que as linhas que atendem à condição estabelecida, ou seja, estão acima da média, são exibidas normalmente, enquanto as demais linhas aparecem preenchidas com o valor NaN (Not a Number).
O preenchimento com NaN é o padrão desse método, mas podemos editar essa informação passando um valor personalizado como segundo argumento para o método where.
df.where(df["tip"] > df["tip"].mean(), 0)
Observe que agora, ao invés de preencher com NaN, ele preencheu as linhas que não atendiam à condição com o número 0.
Esse foi um exemplo mais simples, mas as condições com o where podem ser mais complexas, podemos verificar múltiplos critérios com comparações numéricas e lógicas.
Por exemplo, podemos verificar apenas os valores acima da média que ocorreram aos finais de semana. No Pandas, quando queremos combinar múltiplas condições, usamos o operador & (e comercial), que funciona como o operador and no Python.
# criando dataframe apenas com valores maiores que a média e seja final de semana
df.where((df["tip"] > df["tip"].mean()) & (df["day"].isin(["Sat", "Sun"])))
Dessa forma, nosso DataFrame só exibe os registros que atendem às duas partes da condição, ou seja, valores acima da média que ocorreram aos finais de semana. O restante é preenchido com NaN porque não definimos um valor personalizado.
Olhando dessa forma, não parece muito prático, porém, a principal utilidade do where no Pandas é criar um DataFrame filtrado, apenas com as informações especificadas.
Após aplicar o método where para manter preenchidas apenas as linhas que atendam à condição desejada, podemos utilizar o método dropna para remover as linhas com os valores NaN.
Assim, conseguimos criar um novo DataFrame apenas com as informações que desejamos analisar.
df_weekend = (
df.where((df["tip"] > df["tip"].mean()) & (df["day"].isin(["Sat", "Sun"])))
.dropna()
.reset_index(drop=True)
)
df_weekend
Isso pode facilitar a leitura e a compreensão dos seus dados, aplicando as condições desejadas e gerando novos conjuntos de dados filtrados que te permite fazer análises específicas de acordo com as suas necessidades.
Assim como existe o where no Pandas, nós temos a função where no NumPy. Porém, apesar de o Pandas ter sido inicialmente construído em cima do NumPy, existem algumas diferenças entre esses dois where.
A principal diferença entre eles é que, enquanto no Pandas são mantidos os valores originais quando a condição é verdadeira e substituídos por um valor padrão quando falsa, no NumPy nós podemos especificar os valores para ambas as situações.
Ou seja, com o where do NumPy, podemos definir qual valor será exibido quando a condição for verdadeira e qual valor será exibido quando a condição for falsa.
Primeiro, vamos aplicar a condição mais simples, apenas verificando as colunas que possuem os valores acima da média.
import numpy as np
np.where(df["tip"] > df["tip"].mean())
Perceba que o resultado da função where do NumPy é um array com os índices das linhas em que a condição é verdadeira.
Mas, além da condição padrão, podemos definir os valores que serão retornados caso a condição seja verdadeira e caso a condição seja falsa. Por exemplo, podemos definir que retorne “Sim” quando for verdadeira e “Não” quando falsa.
np.where(df["tip"] > df["tip"].mean(), "Sim", "Não")
Perceba que agora temos um array com os valores de “Sim” e “Não” de acordo com a condição.
Com isso, podemos utilizar esse array para criar uma nova coluna no nosso DataFrame chamada acima_da_media, que exibirá os valores de “Sim” ou “Não”.
# criando coluna com valores de np.where
df["acima_da_media"] = np.where(df["tip"] > df["tip"].mean(), "Sim", "Não")
df.head()
Isso também pode ser feito para diversas condições, como verificar se um registro foi feito em um final de semana ou não.
df["final_de_semana"] = np.where(df["day"].isin(["Sat", "Sun"]), "Sim", "Não")
df.head()
Assim, podemos criar novas colunas que nos permitem fazer análises mais complexas e personalizadas a partir do nosso DataFrame inicial aplicando as condições desejadas.
Para finalizar, vamos utilizar o where para analisarmos os outliers dos nossos dados. Vamos definir uma função que irá receber um dataframe (a origem dos dados), a coluna de interesse para a análise e, por fim, um parâmetro chamado bigode com o valor de 1.5.
O bigode define os limites inferior e superior no box plot. Usualmente, esse limite é calculado multiplicando 1.5 pelo intervalo interquartil. Você pode ajustar esse valor conforme a sua necessidade.
Essa função vai receber esses dados e irá identificar os valores outliers com base nos quartis do conjunto de dados. Para identificar esses valores, vamos criar uma nova coluna chamada “outlier” que irá exibir os valores de “Sim” ou “Não”.
Para definir o primeiro e terceiro quartil podemos utilizar o método quantile, passando respectivamente como argumentos os valores de 0.25 e 0.75.
O intervalo interquartil (IQR) pode ser calculado como a diferença entre o Q3 (terceiro quartil) e o Q1 (primeiro quartil). Com isso, teremos os limites do Box Plot.
Tanto o limite inferior quanto o limite superior são definidos pela fórmula:
limite = quartil ± (1.5 × IQR )
Com esses limites encontrados, podemos criar a nossa condição, para verificar se o valor da coluna é menor do que o limite_inferior ou maior que o limite_superior. Vamos usar o operador lógico |, que equivale ao ou no Python.
Feito isso, vamos criar a nova coluna, utilizando o where e passando para ele a condição. Em que, se a condição for verdadeira, ele escreverá “Sim”, e se for falsa, “Não”.
Por fim, iremos retornar o dataframe gerado.
def outliers(dataframe, coluna, bigode=1.5, nova_coluna="outlier"):
q1 = dataframe[coluna].quantile(0.25)
q3 = dataframe[coluna].quantile(0.75)
iqr = q3 - q1
limite_inferior = q1 - bigode * iqr
limite_superior = q3 + bigode * iqr
condicoes = (dataframe[coluna] < limite_inferior) | (dataframe[coluna] > limite_superior)
dataframe[nova_coluna] = np.where(condicoes, "Sim", "Não")
return dataframePodemos chamar essa função, passando para ela nosso DataFrame analisado e a coluna “tip”.
Não precisamos passar o parâmetro do bigode porque utilizaremos o valor padrão que está definido como 1.5, e nem o nome da nova_coluna, pois também usaremos o padrão.
outliers(df, "tip")
Com isso, temos nossa coluna outlier criada.
No caso dessa função, ela altera o DataFrame dentro dela. Particularmente, eu não recomendo alterar o DataFrame dentro da função, mas para o propósito dessa aula, essa função consegue exemplificar bem a funcionalidade do where.
No entanto, você pode ajustar a função para que ela retorne um array e a partir desse array você pode ou não adicionar uma nova coluna ao seu DataFrame.
A partir dessa coluna outlier, podemos fazer uma contagem dos valores outliers presentes.
df["outlier"].value_counts()
Ou seja, temos 9 outliers dentro do nosso DataFrame. E podemos exibir apenas essas linhas, filtrando o nosso df.
df[df["outlier"] == "Sim"]
A identificação desses outliers nos permite insights adicionais, como padrões relacionados aos dias da semana e assim por diante.
Na aula de hoje, nós vimos como utilizar o Pandas Where e o NumPy Where para aplicar lógicas condicionais dentro das nossas análises de dados.
Compreender o funcionamento desses dois métodos nos possibilita aplicar a lógica condicional aos data frames, melhorando as possibilidades e a capacidade de nossas análises de dados.
Para acessar outras publicações de Ciência de Dados, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.
Quer sair do zero no Python e virar uma referência na sua empresa? Inscreva-se agora mesmo no Python Impressionador