Python
Pandas Where: Dominando a Poderosa Ferramenta de Filtragem

Pandas Where: Dominando a Poderosa Ferramenta de Filtragem

MoeNagy Dev

Os Fundamentos do Pandas Where

Entendendo o propósito e a funcionalidade do método pandas where()

O método where() na biblioteca Pandas é uma ferramenta poderosa para filtragem condicional e seleção de dados. Ele permite criar um novo DataFrame ou Série aplicando uma condição booleana a um existente, preservando a estrutura e a forma originais dos dados.

A sintaxe básica do método where() é:

df.where(condição, other=None, inplace=False, axis=None, level=None, errors='raise', try_cast=False)

Aqui, condição é uma expressão booleana que determina quais elementos no DataFrame ou Série devem ser mantidos. O parâmetro other especifica o valor a ser usado no lugar dos elementos que não atendem à condição.

Reconhecendo a importância da filtragem condicional na análise de dados

A filtragem condicional é uma operação fundamental na análise de dados, pois permite que você se concentre em subconjuntos específicos de seus dados que são relevantes para sua análise. Isso é particularmente útil ao trabalhar com conjuntos de dados grandes ou complexos, onde você precisa identificar e extrair rapidamente as informações mais importantes para sua pesquisa ou objetivos de negócios.

Ao dominar o método where() no Pandas, você pode desbloquear poderosas capacidades de manipulação de dados, permitindo que você:

  • Identifique outliers ou anomalias em seus dados
  • Filtre dados com base em critérios específicos, como intervalos de datas ou localizações geográficas
  • Realize cálculos ou transformações condicionais em seus dados
  • Combine múltiplas condições para refinar sua seleção de dados
  • Integre registros condicionais.Compreendendo e usando efetivamente o método where() é uma habilidade crucial para qualquer analista de dados ou cientista de dados que trabalha com Pandas.

Aplicando Pandas Where a Dados Numéricos

Filtrando linhas com base em condições numéricas

Vamos começar explorando como usar o método where() para filtrar linhas em um DataFrame com base em condições numéricas. Suponha que temos um DataFrame df com os seguintes dados:

   age  income
0   25   50000
1   32   65000
2   41   75000
3   28   45000
4   35   60000

Para selecionar apenas as linhas onde a idade é maior que 30, podemos usar o seguinte código:

df_older = df.where(df['age'] > 30)
df_older

Isso nos dará um novo DataFrame df_older com os seguintes dados:

     age  income
1   32.0  65000
2   41.0  75000
4   35.0  60000

Observe que as linhas onde a condição df['age'] > 30 não foi atendida foram substituídas por valores NaN.

Combinando múltiplas condições usando operadores lógicos (e, ou, não)

Você também pode combinar várias condições usando operadores lógicos como e, ou e não. Por exemplo, para selecionar as linhas onde a idade está entre 30 e 40 (inclusive), você pode usar o seguinte código:

df_middle_age = df.where((df['age'] >= 30) & (df['age'] <= 40))
df_middle_age

Isso nos dará um novo DataFrame df_middle_age com os seguintes dados:

     age  income
1   32.0  65000
4   35.0  60000

Lidando com valores ausentes com pandas where()

O método where() também pode ser útil para lidar com valores ausentes em seus dados. Se você quiser substituir os valores NaN por um valor específico, pode usar o parâmetro other. Por exemplo, para substituir os valores NaN por 0, você pode usar o seguinte código:

df_filled = df.where(df['age'] > 30, 0)
df_filled

Isso nos dará um novo DataFrame df_filled com os seguintes dados:

    age  income
0  25.0  50000
1  32.0  65000
2  41.0  75000
3   0.0  45000
4  35.0  6000.# Pandas Where com Máscaras Booleanas

## Criando máscaras booleanas para filtragem condicional

Além de usar expressões booleanas diretamente no método `where()`, você também pode criar máscaras booleanas e usá-las para filtrar seus dados. Isso pode ser particularmente útil quando você precisa aplicar a mesma condição a várias colunas ou quando você deseja reutilizar uma condição complexa em várias partes do seu código.

Por exemplo, vamos criar uma máscara booleana para selecionar as linhas onde a `idade` é maior que 30 e a `renda` é maior que 60.000:

```python
mask = (df['idade'] > 30) & (df['renda'] > 60000)
df_filtrado = df.where(mask)
df_filtrado

Isso nos dará um novo DataFrame df_filtrado com os seguintes dados:

     idade  renda
1   32.0  65000
2   41.0  75000

Aproveitando máscaras booleanas para seleção de dados avançada

As máscaras booleanas também podem ser usadas para realizar operações de seleção de dados mais complexas. Por exemplo, você pode usar máscaras booleanas para selecionar linhas e colunas específicas, ou para criar novas colunas com base em lógica condicional.

Suponha que queiramos criar uma nova coluna alta_renda que seja True se a renda for maior que 60.000 e False caso contrário. Podemos fazer isso usando o método where() e uma máscara booleana:

df['alta_renda'] = df['renda'].where(df['renda'] > 60000, False)
df

Isso nos dará o seguinte DataFrame:

    idade  renda alta_renda
0   25  50000      False
1   32  65000       True
2   41  75000       True
3   28  45000      False
4   35  60000      False

Otimizando o desempenho com máscaras booleanas

O uso de máscaras booleanas também pode ajudar a melhorar o desempenho de suas operações Pandas, especialmente ao trabalhar com grandes conjuntos de dados. As operações booleanas geralmente são mais rápidas do que iterar sobre um DataFrame linha por linha, portanto, aproveitar as máscaras booleanas pode tornar seu código mais eficiente e escalável.

Pandas Where em Dados de Texto e Categóricos

Filtrando linhas com base em condições de string ou categóricas

O where(). O método where()` no Pandas não se limita a dados numéricos; você também pode usá-lo para filtrar linhas com base em condições de string ou categóricas. Isso pode ser particularmente útil ao trabalhar com dados baseados em texto ou dados que foram codificados como categorias.

Por exemplo, digamos que temos um DataFrame df com os seguintes dados:

   name  department
0  Alice       Sales
1   Bob   Marketing
2  Carol  Accounting
3  David       Sales
4  Emily   Marketing

Para selecionar as linhas onde o department é 'Sales', podemos usar o seguinte código:

df_sales = df.where(df['department'] == 'Sales')
df_sales

Isso nos dará um novo DataFrame df_sales com os seguintes dados:

     name department
0  Alice     Sales
3  David     Sales

Lidando com diferenças de maiúsculas e minúsculas e correspondências parciais

Por padrão, as comparações de string no método where() são sensíveis a maiúsculas e minúsculas. Se você precisar realizar comparações insensíveis a maiúsculas e minúsculas, você pode usar os métodos str.lower() ou str.upper() para normalizar o texto antes de aplicar a condição.

Por exemplo, para selecionar as linhas onde o name contém o substring 'a', independentemente do caso, você pode usar o seguinte código:

df_a_names = df.where(df['name'].str.contains('a', case=False))
df_a_names

Isso nos dará um novo DataFrame df_a_names com os seguintes dados:

     name  department
0  Alice     Sales
2  Carol  Accounting
4  Emily   Marketing

Combinando condições baseadas em texto com o pandas where()

Você também pode combinar várias condições baseadas em texto usando os mesmos operadores lógicos (and, or, not) que você usou para condições numéricas. Isso permite que você crie regras de filtragem mais complexas com base nas características dos seus dados.

Por exemplo, para selecionar as linhas onde o department é 'Sales' ou 'Marketing', você pode usar o seguinte código:

df_sales_or_marketing = df.where((df['department'] == 'Sales') | (df['department'] == 'Marketing'))
df_sales_or_marketing

Isso nos dará um novo Da. df_sales_or_marketing com os seguintes dados:

     name  department
0  Alice     Vendas
1    Bob   Marketing
3  David     Vendas
4  Emily   Marketing

Pandas Where na Transformação de Dados

Usando o pandas where() para atualizações seletivas de dados

O método where() também pode ser usado para atualizar seletivamente os valores em um DataFrame ou Série. Isso pode ser útil quando você precisa aplicar lógica condicional para modificar elementos específicos de seus dados.

Por exemplo, digamos que queremos aumentar os valores de renda em 10% para todos os funcionários com idade maior que 35. Podemos fazer isso usando o seguinte código:

df['renda'] = df['renda'].where(df['idade'] <= 35, df['renda'] * 1.1)
df

Isso nos dará o seguinte DataFrame atualizado:

    idade  renda
0     25  50000.0
1     32  65000.0
2     41  82500.0
3     28  45000.0
4     35  66000.0

Aplicando lógica condicional para modificar colunas específicas

O método where() também pode ser usado para aplicar lógica condicional para modificar colunas específicas em um DataFrame. Isso pode ser útil para limpeza de dados, engenharia de recursos ou outras tarefas de transformação de dados.

Por exemplo, digamos que queremos substituir todos os valores negativos de renda por 0. Podemos fazer isso usando o seguinte código:

df['renda'] = df['renda'].where(df['renda'] >= 0, 0)
df

Isso nos dará o seguinte DataFrame atualizado:

    idade  renda
0     25  50000.0
1     32  65000.0
2     41  75000.0
3     28  45000.0
4     35  60000.0

Integrando o pandas where() em fluxos de trabalho de limpeza e pré-processamento de dados

O método where() pode ser uma ferramenta poderosa para tarefas de limpeza e pré-processamento de dados. Combinando-o com outras operações do Pandas, você pode criar fluxos de trabalho complexos de transformação de dados que podem lidar com uma ampla gama de desafios relacionados a dados.

Por exemplo, você pode usar where() para identificar e lidar com outliers, preencher valores ausentes ou codificar variáveis ​​categóricas com base em condições específicas. Ao incorporar where() em seu fluxo de trabalho de pré-processamento de dados, você pode criar soluções mais robustas e flexíveis.# Operações Pandas Where e Groupby

Aplicando o pandas where() em contextos de groupby

O método where() também pode ser usado em conjunto com a funcionalidade groupby() do Pandas para realizar filtragem condicional e seleção dentro de contextos de nível de grupo.

Por exemplo, digamos que temos um DataFrame df com os seguintes dados:

   department  age  income
0      Sales   25  50000
1   Marketing   32  65000
2  Accounting   41  75000
3      Sales   28  45000
4   Marketing   35  60000

Para selecionar os funcionários de cada departamento que têm uma idade maior que a idade média do departamento, podemos usar o seguinte código:

dept_avg_age = df.groupby('department')['age'].transform('mean')
df_filtered = df.where(df['age'] > dept_avg_age)
df_filtered

Isso nos dará um novo DataFrame df_filtered com os seguintes dados:

   department   age  income
1   Marketing  32.0  65000
2  Accounting  41.0  75000

Agregações condicionais e filtragem de nível de grupo

O método where() também pode ser usado para realizar agregações condicionais ou filtragem de nível de grupo dentro de um contexto groupby(). Isso pode ser útil para calcular métricas específicas do grupo ou identificar subgrupos que atendem a critérios específicos.

Por exemplo, para calcular a renda média dos funcionários de cada departamento que têm mais de 30 anos, podemos usar o seguinte código:

df.loc[df['age'] > 30].groupby('department')['income'].mean()

Isso nos dará a seguinte saída:

department
Accounting    75000.0
Marketing     62500.0
Sales         55000.0
Name: income, dtype: float64

Explorando casos de uso para pandas where() em análise baseada em grupo

A combinação de where() e groupby() abre uma ampla gama de possibilidades para análise de dados baseada em grupo. Alguns casos de uso adicionais incluem:

  • Identificar os melhores ou piores desempenhos

Conclusão.Trabalhando com Estruturas de Dados

Listas

Listas são a estrutura de dados mais versátil em Python. Elas podem conter elementos de diferentes tipos de dados, e seu tamanho pode ser alterado dinamicamente. Aqui está um exemplo de criação e manipulação de uma lista:

# Criando uma lista
minha_lista = [1, 2, 3, 'quatro', 5.6]
 
# Acessando elementos
print(minha_lista[0])  # Saída: 1
print(minha_lista[-1])  # Saída: 5.6
 
# Modificando elementos
minha_lista[2] = 'três'
print(minha_lista)  # Saída: [1, 2, 'três', 'quatro', 5.6]
 
# Adicionando elementos
minha_lista.append(6)
minha_lista.insert(2, 'novo')
print(minha_lista)  # Saída: [1, 2, 'novo', 'três', 'quatro', 5.6, 6]
 
# Removendo elementos
del minha_lista[3]
minha_lista.remove('quatro')
print(minha_lista)  # Saída: [1, 2, 'novo', 5.6, 6]

Tuplas

Tuplas são semelhantes a listas, mas são imutáveis, o que significa que seus elementos não podem ser modificados após a criação. Tuplas são definidas usando parênteses em vez de colchetes.

# Criando uma tupla
minha_tupla = (1, 2, 'três', 4.5)
 
# Acessando elementos
print(minha_tupla[0])  # Saída: 1
print(minha_tupla[-1])  # Saída: 4.5
 
# Tentar modificar uma tupla gerará um erro
# minha_tupla[2] = 'novo'  # TypeError: 'tuple' object does not support item assignment

Dicionários

Dicionários são coleções desordenadas de pares chave-valor. Eles são definidos usando chaves {} e cada par chave-valor é separado por dois-pontos :.

# Criando um dicionário
pessoa = {
    'nome': 'João da Silva',
    'idade': 35,
    'ocupação': 'Engenheiro de Software'
}
 
# Acessando valores
print(pessoa['nome'])  # Saída: João da Silva
print(pessoa.get('idade'))  # Saída: 35
 
# Adicionando/modificando elementos
pessoa['email'] = 'joao.silva@exemplo.com'
pessoa['idade'] = 36
print(pessoa)  # Saída: {'nome': 'João da Silva', 'idade': 36, 'ocupação': 'Engenheiro de Software', 'email': 'joao.silva@exemplo.com'}
 
# Removendo elementos
del pessoa['ocupação']
print(pessoa)  # Saída: {'nome': 'João da Silva', 'idade': 36, 'email': 'joao.silva@exemplo.com'}

Conjuntos

Conjuntos são coleções desordenadas de elementos únicos.

Conjuntos

Conjuntos em Python são coleções de elementos únicos. Eles são definidos usando chaves {} ou a função set().

# Criando um conjunto
meu_conjunto = {1, 2, 3, 4, 5}
print(meu_conjunto)  # Saída: {1, 2, 3, 4, 5}
 
# Adicionando elementos
meu_conjunto.add(6)
print(meu_conjunto)  # Saída: {1, 2, 3, 4, 5, 6}
 
# Removendo elementos
meu_conjunto.remove(3)
print(meu_conjunto)  # Saída: {1, 2, 4, 5, 6}
 
# Operações de conjunto
conjunto1 = {1, 2, 3}
conjunto2 = {2, 3, 4}
print(conjunto1 | conjunto2)  # União: {1, 2, 3, 4}
print(conjunto1 & conjunto2)  # Interseção: {2, 3}
print(conjunto1 - conjunto2)  # Diferença: {1}

Fluxo de Controle

Instruções Condicionais

Instruções condicionais em Python permitem que você execute diferentes blocos de código com base em certas condições.

# Instrução if-else
idade = 18
if idade >= 18:
    print("Você é um adulto.")
else:
    print("Você é menor de idade.")
 
# Instrução elif
pontuacao = 85
if pontuacao >= 90:
    print("A")
elif pontuacao >= 80:
    print("B")
elif pontuacao >= 70:
    print("C")
else:
    print("D")

Loops

Loops em Python permitem que você execute repetidamente um bloco de código.

# Loop for
frutas = ['maçã', 'banana', 'cereja']
for fruta in frutas:
    print(fruta)
 
# Loop while
contador = 0
while contador < 5:
    print(contador)
    contador += 1

List Comprehensions

List comprehensions fornecem uma maneira concisa de criar listas em Python.

# Maneira tradicional
numeros = [1, 2, 3, 4, 5]
quadrados = []
for num in numeros:
    quadrados.append(num ** 2)
print(quadrados)  # Saída: [1, 4, 9, 16, 25]
 
# Usando list comprehension
quadrados = [num ** 2 for num in numeros]
print(quadrados)  # Saída: [1, 4, 9, 16, 25]

Funções

Funções em Python permitem que você encapsule código reutilizável.

# Definindo uma função
def saudar(nome):
    print(f"Olá, {nome}!")
 
# Chamando a função
saudar("Alice")  # Saída: Olá, Alice!
 
# Funções com valores de retorno
def adicionar_numeros(a, b):
    return a + b
 
resultado = adicionar_numeros(3, 4)
print(resultado)  # Saída: 7

Módulos e Pacotes

O design modular do Python permite que você organize seu código.

# Importando um módulo
import math
print(math.pi)  # Saída: 3.141592653589793
 
# Importando uma função específica de um módulo
from math import sqrt
print(sqrt(16))  # Saída: 4.0
 
# Importando um módulo com um alias
import numpy as np
print(np.array([1, 2, 3]))  # Saída: [1 2 3]

Conclusão

Neste tutorial, você aprendeu sobre várias estruturas de dados em Python, incluindo listas, tuplas, dicionários e conjuntos. Você também explorou instruções de fluxo de controle, funções e o design modular do Python. Esses conceitos são fundamentais para escrever código Python eficaz e eficiente. À medida que você continuar a aprender e praticar, poderá aproveitar essas ferramentas para construir aplicativos mais complexos e poderosos.

MoeNagy Dev.