Python
Dominando o DataFrame Dropna: Um Guia para Iniciantes

Dominando o DataFrame Dropna: Um Guia para Iniciantes

MoeNagy Dev

Lidando com Dados Ausentes no Pandas com df.dropna()

Os Fundamentos de Dados Ausentes no Pandas

Entendendo valores nulos e NaN no Pandas

No Pandas, dados ausentes são representados pelo valor especial NaN (Not a Number). NaN é um valor de ponto flutuante usado para indicar a ausência de um valor válido. Isso é importante de entender porque o Pandas trata os valores NaN de maneira diferente de valores numéricos regulares ou valores None.

import pandas as pd
 
# Criando um DataFrame com valores ausentes
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
print(df)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 2  None  7.0
# 3  4  8.0

No exemplo acima, o DataFrame df contém valores ausentes representados por None e NaN.

Reconhecendo a importância de lidar com dados ausentes

Dados ausentes são um desafio comum na análise de dados e podem ter um impacto significativo na precisão e confiabilidade dos seus resultados. Ignorar ou lidar incorretamente com dados ausentes pode levar a conclusões enviesadas, previsões incorretas e insights pouco confiáveis. Portanto, é essencial ter um sólido entendimento de como lidar efetivamente com dados ausentes em seus fluxos de trabalho do Pandas.

Apresentando df.dropna()

O que é df.dropna()?

O método df.dropna() no Pandas é uma ferramenta poderosa para remover linhas ou colunas com dados ausentes de um DataFrame. Esse método permite que você personalize o comportamento de como os dados ausentes são tratados, tornando-o uma solução versátil e flexível para lidar com conjuntos de dados incompletos.

Quando usar df.dropna()

O método df.dropna() é tipicamente usado quando...Quando você deseja remover linhas ou colunas com dados ausentes do seu DataFrame. Isso pode ser útil em cenários onde:

  1. Você precisa preparar um conjunto de dados limpo para análise ou modelagem adicional.
  2. A presença de dados ausentes pode afetar negativamente o desempenho dos seus modelos de aprendizado de máquina.
  3. Você deseja visualizar seus dados sem a distorção causada por valores ausentes.
  4. Você precisa cumprir requisitos ou restrições específicos que exigem um conjunto de dados completo.

Removendo Linhas com Dados Ausentes

Excluindo linhas com quaisquer valores NaN

A maneira mais simples de remover linhas com dados ausentes é usar o método df.dropna() sem nenhum argumento:

import pandas as pd
 
# Criando um DataFrame com valores ausentes
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
 
# Excluindo linhas com quaisquer valores NaN
df_dropped = df.dropna()
print(df_dropped)
#    A    B
# 0  1  5.0
# 3  4  8.0

Neste exemplo, o método df.dropna() remove quaisquer linhas que contenham pelo menos um valor NaN, resultando em um novo DataFrame df_dropped com apenas as linhas completas.

Excluindo linhas com colunas específicas contendo NaN

Você também pode especificar quais colunas considerar ao excluir linhas com dados ausentes. Isso é feito passando o parâmetro subset para df.dropna():

# Excluindo linhas com valores NaN na coluna 'A'
df_dropped_A = df.dropna(subset=['A'])
print(df_dropped_A)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 3  4  8.0
 
# Excluindo linhas com valores NaN nas colunas 'A' e 'B'
df_dropped_AB = df.dropna(subset=['A', 'B'])
print(df_dropped_AB)
#    A    B
# 0  1  5.0
# 3  4  8.0

No primeiro exemplo, df.dropna(subset=['A']) exclui as linhas em que a coluna 'A' contém valores NaN. No segundo exemplo, df.dropna(subset=['A', 'B']) exclui as linhas em que ambas as colunas 'A' e 'B' contêm valores NaN.

Personalizando o comportamento do df.dropna()

O método df.dropna() oferece vários parâmetros adicionais para personalizar seu comportamento.

  • how: Especifica a condição para descartar linhas. Pode ser 'any' (padrão) para descartar linhas com quaisquer valores NaN, ou 'all' para descartar linhas apenas se todos os valores forem NaN.
  • thresh: Especifica o número mínimo de valores não-NaN necessários para uma linha ser mantida.
  • subset: Especifica as colunas a serem consideradas ao descartar linhas.
# Descartando linhas com todos os valores NaN
df_dropped_all = df.dropna(how='all')
print(df_dropped_all)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 3  4  8.0
 
# Descartando linhas com menos de 2 valores não-NaN
df_dropped_thresh = df.dropna(thresh=2)
print(df_dropped_thresh)
#    A    B
# 0  1  5.0
# 3  4  8.0

No primeiro exemplo, df.dropna(how='all') descarta linhas onde todos os valores são NaN. No segundo exemplo, df.dropna(thresh=2) descarta linhas com menos de 2 valores não-NaN.

Removendo Colunas com Dados Ausentes

Descartando colunas com quaisquer valores NaN

Para remover colunas com quaisquer valores NaN, você pode usar o parâmetro axis=1 no método df.dropna():

# Descartando colunas com quaisquer valores NaN
df_dropped_cols = df.dropna(axis=1)
print(df_dropped_cols)
#    A
# 0  1
# 1  2
# 2  None
# 3  4

Neste exemplo, o método df.dropna(axis=1) descarta a coluna 'B' porque ela contém valores NaN, deixando apenas a coluna 'A' no DataFrame resultante df_dropped_cols.

Descartando colunas com um certo limite de valores NaN

Você também pode especificar um limite para o número máximo de valores NaN permitidos em uma coluna antes que ela seja descartada. Isso é feito usando o parâmetro thresh:

# Descartando colunas com mais de 1 valor NaN
df_dropped_threshold = df.dropna(axis=1, thresh=3)
print(df_dropped_threshold)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 2  None  7.0
# 3  4  8.0

Neste exemplo, df.dropna(axis=1, thresh=3) descarta as colunas que têm mais de 1 valor NaN (já que o DataFrame tem 4 linhas), mantendo as colunas 'A' e 'B' no DataFrame resultante df_dropped_threshold.

Lidando com colunas com dados mistos.

Ao trabalhar com colunas que contêm uma mistura de tipos de dados, incluindo valores NaN, o método df.dropna() pode se comportar de maneira diferente, dependendo dos tipos de dados. Isso porque o Pandas trata os valores ausentes em diferentes tipos de dados de maneira diferente.

# Criando um DataFrame com tipos de dados mistos
data = {'A': [1, 2, None, 4], 'B': [5, None, '7', 8]}
df = pd.DataFrame(data)
print(df)
#    A     B
# 0  1   5.0
# 1  2   NaN
# 2  None  7
# 3  4   8.0
 
# Removendo colunas com qualquer valor NaN
df_dropped_mixed = df.dropna(axis=1)
print(df_dropped_mixed)
#    A
# 0  1
# 1  2
# 2  None
# 3  4

Neste exemplo, a coluna 'B' contém uma mistura de valores numéricos e de string, incluindo NaN. Ao usar df.dropna(axis=1), a coluna 'B' é removida porque contém valores NaN, mesmo que o valor de string '7' não seja considerado um valor ausente pelo Pandas.

Para lidar com colunas com tipos de dados mistos, você pode precisar converter os tipos de dados ou usar métodos alternativos para lidar com dados ausentes, como imputação ou técnicas de limpeza de dados.

Técnicas Avançadas com df.dropna()

Combinando df.dropna() com outras operações do Pandas

O método df.dropna() pode ser combinado com outras operações do Pandas para criar fluxos de trabalho de limpeza e pré-processamento de dados mais complexos. Por exemplo, você pode usar df.dropna() em conjunto com df.fillna() para lidar com dados ausentes de uma maneira mais abrangente.

# Combinando df.dropna() e df.fillna()
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
 
# Preencher valores ausentes com 0 e, em seguida, remover linhas com qualquer NaN
df_cleaned = df.fillna(0).dropna()
print(df_cleaned)
#    A  B
# 0  1  5
# 3  4  8

Neste exemplo, o método df.fillna(0) preenche os valores ausentes com 0, e, em seguida, o método df.dropna() remove quaisquer linhas restantes com valores NaN.

Preservando o DataFrame original com .copy()

Ao usar df.dropna(), é importante estar ciente de que o método modifica o DataFrame original. Se você quiser preservar o DataFrame original, você pode usar o método .copy() para criar uma cópia antes de aplicar df.dropna(). Você deseja preservar o DataFrame original, você pode usar o método .copy() para criar um novo DataFrame antes de aplicar df.dropna().

# Preservando o DataFrame original
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
 
# Criar uma cópia do DataFrame antes de remover as linhas
df_copy = df.copy()
df_dropped = df_copy.dropna()
 
print("DataFrame original:")
print(df)
print("\nDataFrame copiado e removido:")
print(df_dropped)

Neste exemplo, df_copy = df.copy() cria um novo DataFrame df_copy que é uma cópia do original df. A operação df.dropna() é então realizada em df_copy, preservando o DataFrame original df.

Lidando com dados faltosos em séries temporais

Ao trabalhar com dados de séries temporais, lidar com valores ausentes pode ser particularmente importante, pois lacunas nos dados podem impactar significativamente sua análise e previsão. O método df.dropna() pode ser usado para remover linhas com dados ausentes em dados de séries temporais, mas você também pode precisar considerar abordagens alternativas, como interpolação ou preenchimento para frente/para trás, dependendo do seu caso de uso específico.

# Exemplo de como lidar com dados faltosos em séries temporais
import pandas as pd
 
# Criar um DataFrame de série temporal de amostra com valores ausentes
dates = pd.date_range(start='2022-01-01', end='2022-01-10', freq='D')
data = {'A': [1, 2, None, 4, 5, None, 7, 8, 9, 10]}
df_ts = pd.DataFrame(data, index=dates)
 
# Remover linhas com qualquer valor NaN
df_ts_dropped = df_ts.dropna()
print(df_ts_dropped)
#            A
# 2022-01-01  1
# 2022-01-02  2
# 2022-01-04  4
# 2022-01-05  5
# 2022-01-07  7
# 2022-01-08  8
# 2022-01-09  9
# 2022-01-10 10

Neste exemplo, o DataFrame df_ts representa uma série temporal com valores ausentes. O método df.dropna() é usado para remover as linhas com valores NaN, resultando no DataFrame df_ts_dropped.

Melhores Práticas e Considerações

Avaliando o impacto da remoção de dados

Ao usar df.dropna(), é importante considerar.

Instruções Condicionais

As instruções condicionais em Python permitem que você execute diferentes blocos de código com base em certas condições. A instrução condicional mais comum é a instrução if-elif-else.

idade = 25
if idade < 18:
    print("Você é menor de idade.")
elif idade >= 18 and idade < 65:
    print("Você é adulto.")
else:
    print("Você é idoso.")

Neste exemplo, o programa verifica o valor da variável idade e imprime a mensagem apropriada com base na faixa etária.

Loops

Os loops em Python permitem que você execute repetidamente um bloco de código. Os dois tipos de loop mais comuns são os loops for e while.

Loops for

Os loops for são usados para iterar sobre uma sequência, como uma lista, tupla ou string.

frutas = ["maçã", "banana", "cereja"]
for fruta in frutas:
    print(fruta)

Este código irá gerar a seguinte saída:

maçã
banana
cereja

Loops while

Os loops while são usados para executar um bloco de código enquanto uma determinada condição for verdadeira.

contador = 0
while contador < 5:
    print(contador)
    contador += 1

Este código irá gerar a seguinte saída:

0
1
2
3
4

Funções

As funções em Python são blocos de código reutilizáveis que executam uma tarefa específica. Elas podem receber argumentos e retornar valores.

def cumprimentar(nome):
    print(f"Olá, {nome}!")
 
cumprimentar("Alice")
cumprimentar("Bob")

Este código irá gerar a seguinte saída:

Olá, Alice!
Olá, Bob!

Você também pode definir funções com argumentos padrão e argumentos de comprimento variável.

def calcular_area(comprimento, largura, altura=None):
    if altura is None:
        return comprimento * largura
    else:
        return comprimento * largura * altura
 
print(calcular_area(5, 10))       # Saída: 50
print(calcular_area(2, 3, 4))     # Saída: 24

Módulos e .Pacotes

A biblioteca padrão do Python fornece uma ampla gama de módulos internos que você pode usar em seus programas. Você também pode criar seus próprios módulos e pacotes para organizar seu código.

import math
print(math.pi)  # Saída: 3.141592653589793

Neste exemplo, importamos o módulo math e usamos a constante pi dele.

Você também pode importar funções ou atributos específicos de um módulo:

from math import sqrt, pi
print(sqrt(16))  # Saída: 4.0
print(pi)       # Saída: 3.141592653589793

Entrada e Saída de Arquivos

O Python fornece funções internas para ler e escrever em arquivos.

# Escrevendo em um arquivo
with open("example.txt", "w") as file:
    file.write("Este é um arquivo de texto de exemplo.")
 
# Lendo de um arquivo
with open("example.txt", "r") as file:
    content = file.read()
    print(content)  # Saída: Este é um arquivo de texto de exemplo.

A declaração with garante que o arquivo seja fechado corretamente após as operações serem concluídas.

Tratamento de Exceções

O mecanismo de tratamento de exceções do Python permite que você lide com erros e situações inesperadas em seu código.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Erro: Divisão por zero")
else:
    print(f"Resultado: {result}")
finally:
    print("Este bloco será sempre executado.")

Este código irá gerar a seguinte saída:

Erro: Divisão por zero
Este bloco será sempre executado.

Programação Orientada a Objetos (POO)

O Python suporta programação orientada a objetos, o que permite que você crie classes e objetos personalizados.

class Carro:
    def __init__(self, marca, modelo, ano):
        self.marca = marca
        self.modelo = modelo
        self.ano = ano
 
    def ligar(self):
        print(f"O {self.ano} {self.marca} {self.modelo} foi ligado.")
 
meu_carro = Carro("Toyota", "Corolla", 2020)
meu_carro.ligar()  # Saída: O 2020 Toyota Corolla foi ligado.

Neste exemplo, definimos uma classe Carro com um método __init__ para inicializar os atributos do objeto e um método ligar para simular a ação de ligar o carro.## Conclusão

Neste tutorial, você aprendeu sobre vários conceitos do Python, incluindo instruções condicionais, loops, funções, módulos e pacotes, entrada e saída de arquivos, tratamento de exceções e programação orientada a objetos. Essas habilidades fundamentais ajudarão você a construir aplicativos Python mais complexos e robustos. Lembre-se de praticar e experimentar com os exemplos de código fornecidos para solidificar seu entendimento desses tópicos.

MoeNagy Dev.