Python
Desmistificando o NaN do Pandas: Um Guia para Iniciantes

Desmistificando o NaN do Pandas: Um Guia para Iniciantes

MoeNagy Dev

Entendendo os Básicos do pandas.isnull() e pandas.isna()

Explorando o Conceito de pandas.isnull() e pandas.isna()

O que são pandas.isnull() e pandas.isna()?

As funções pandas.isnull() e pandas.isna() são usadas para identificar valores ausentes em um DataFrame ou Série do Pandas. Essas funções retornam uma máscara booleana com o mesmo formato da entrada, onde True indica um valor ausente e False indica um valor não ausente.

Aqui está um exemplo:

import pandas as pd
 
# Criar um DataFrame de exemplo
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Verificar valores ausentes
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

No exemplo acima, o método df.isnull() retorna um DataFrame booleano indicando a presença de valores ausentes em cada célula.

Entendendo a diferença entre pandas.isnull() e pandas.isna()

As funções pandas.isnull() e pandas.isna() são essencialmente as mesmas e podem ser usadas de forma intercambiável. Ambas as funções servem ao mesmo propósito de identificar valores ausentes em um DataFrame ou Série.

A principal diferença é que pandas.isna() é uma maneira mais moderna e recomendada de verificar valores ausentes, pois fornece melhor suporte para lidar com diferentes tipos de dados, incluindo valores NaN do NumPy, None do Python e os próprios indicadores de valores ausentes do Pandas.

Na maioria dos casos, você pode usar pandas.isna() em vez de pandas.isnull() sem problemas. No entanto, se você precisar manter a compatibilidade com versões mais antigas do Pandas, talvez precise usar pandas.isnull().

Lidando com dados ausentes com o pandas.isna()

Uma vez que você tenha identificado... Preenchendo os valores ausentes usando pandas.isnull() ou pandas.isna(), você pode usar vários métodos para lidar com eles. Algumas técnicas comuns incluem:

  1. Substituindo valores ausentes: Você pode substituir valores ausentes por um valor específico ou um valor calculado com base nos dados.
df['A'] = df['A'].fillna(0)  # Substituir valores ausentes na coluna 'A' por 0
  1. Excluindo linhas ou colunas com valores ausentes:
df = df.dropna(subset=['A', 'B'])  # Excluir linhas com quaisquer valores ausentes nas colunas 'A' ou 'B'
  1. Imputando valores ausentes: Você pode usar várias técnicas de imputação, como imputação pela média, mediana ou moda, para preencher os valores ausentes.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Interpolando valores ausentes: Para dados de séries temporais, você pode usar interpolação para estimar valores ausentes com base nos dados circundantes.
df = df.interpolate()  # Interpolar valores ausentes no DataFrame

Aplicando pandas.isnull() e pandas.isna() na Manipulação de Dados

Identificando valores ausentes em um DataFrame

Você pode usar as funções pandas.isnull() ou pandas.isna() para identificar valores ausentes em um DataFrame:

import pandas as pd
 
# Criar um DataFrame de exemplo
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Verificar valores ausentes
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

O DataFrame booleano resultante indica a presença de valores ausentes em cada célula.

Lidando com valores ausentes usando pandas.isnull() e pandas.isna()

Você pode usar a máscara booleana retornada por pandas.isnull() ou pandas.isna() para realizar várias operações no DataFrame, como:

  1. Substituindo valores ausentes:
df['A'] = df['A'].fillna(0)
df['B'] = df['B'].fillna(df['B'].mean())
  1. Excluindo linhas ou colunas com valores ausentes:
```python
df = df.dropna(subset=['A', 'B'])  # Remover linhas com quaisquer valores ausentes nas colunas 'A' ou 'B'
df = df.dropna(how='all')  # Remover linhas com todos os valores ausentes
df = df.dropna(axis=1)  # Remover colunas com quaisquer valores ausentes
  1. Preenchendo valores ausentes:
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Substituindo valores ausentes por um valor específico

Você pode substituir valores ausentes por um valor específico usando o método fillna():

# Substituir valores ausentes na coluna 'A' por 0
df['A'] = df['A'].fillna(0)
 
# Substituir valores ausentes na coluna 'B' pela média da coluna
df['B'] = df['B'].fillna(df['B'].mean())

Removendo linhas ou colunas com valores ausentes

Você pode remover linhas ou colunas com valores ausentes usando o método dropna():

# Remover linhas com quaisquer valores ausentes nas colunas 'A' ou 'B'
df = df.dropna(subset=['A', 'B'])
 
# Remover linhas com todos os valores ausentes
df = df.dropna(how='all')
 
# Remover colunas com quaisquer valores ausentes
df = df.dropna(axis=1)

Técnicas Avançadas com pandas is nan

Combinando pandas.isnull() e pandas.isna() com outros métodos do DataFrame

Você pode combinar as funções pandas.isnull() ou pandas.isna() com outros métodos do DataFrame para realizar operações mais complexas. Por exemplo, você pode usá-las em filtragem condicional, transformação de dados e muito mais.

# Filtrar linhas com valores ausentes na coluna 'A'
filtered_df = df[df['A'].isnull()]
 
# Preencher valores ausentes na coluna 'B' com a mediana dos valores não ausentes nessa coluna
df['B'] = df['B'].fillna(df['B'].median())
 
# Criar uma nova coluna indicando a presença de valores ausentes na coluna 'A'
df['has_missing_A'] = df['A'].isnull()

Filtragem condicional baseada em valores ausentes

Você pode usar a máscara booleana retornada por pandas.isnull() ou pandas.isna() para realizar filtragem condicional em seu DataFrame:

# Filtrar.

linhas com valores ausentes na coluna 'A' filtered_df = df[df['A'].isnull()]

Filtrar linhas com valores não ausentes na coluna 'B'

non_missing_df = df[~df['B'].isnull()]


#### Preenchendo valores ausentes usando várias técnicas
Além da simples substituição de valores, você pode usar técnicas mais avançadas para preencher valores ausentes, como:

1. **Preenchimento com média/mediana/moda**:
```python
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Preenchimento por KNN:
from fancyimpute import KNNImputer
imputer = KNNImputer(n_neighbors=5)
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Preenchimento Iterativo:
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
imputer = IterativeImputer()
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Essas técnicas avançadas de preenchimento podem ser particularmente úteis ao lidar com padrões de dados ausentes mais complexos ou recursos interdependentes.

Explorando Casos de Uso Específicos para pandas is nan

Limpeza e pré-processamento de dados com pandas is nan

Um dos principais casos de uso para pandas.isnull() e pandas.isna() está na etapa de limpeza e pré-processamento de dados de uma análise de dados ou pipeline de aprendizado de máquina. Essas funções podem ajudá-lo a identificar e lidar com valores ausentes, o que é um passo crucial para garantir a qualidade e confiabilidade dos seus dados.

Aqui está um exemplo de como você pode usar pandas.isna() para limpar e pré-processar um conjunto de dados:

import pandas as pd
 
# Carrega o conjunto de dados
df = pd.read_csv('dataset.csv')
 
# Identifica valores ausentes
missing_values = df.isna().sum()
print(missing_values)
 
# Exclui linhas com valores ausentes em qualquer coluna
df = df.dropna()
 
# Preenche valores ausentes na coluna 'age' com a mediana
df['age'] = df['age'].fillna(df['age'].median())
 
# Cria uma nova coluna indicando a presença de valores ausentes na coluna 'income'
df['has_m.
```python
df['missing_income'] = df['income'].isna()

Neste exemplo, primeiro identificamos o número de valores ausentes em cada coluna usando df.isna().sum(). Em seguida, excluímos quaisquer linhas com valores ausentes em qualquer coluna e preenchemos os valores ausentes na coluna 'age' com a mediana. Finalmente, criamos uma nova coluna que indica a presença de valores ausentes na coluna 'income'.

Lidando com valores ausentes em dados de séries temporais

Ao trabalhar com dados de séries temporais, lidar com valores ausentes pode ser particularmente desafiador. pandas.isnull() e pandas.isna() podem ser combinados com outras funções específicas de séries temporais para lidar com valores ausentes nesses conjuntos de dados.

import pandas as pd
 
# Criar um DataFrame de série temporal de amostra
df = pd.DataFrame({'A': [1, 2, None, 4, 5], 'B': [5, None, 7, 8, 9]},
                  index=pd.date_range('2022-01-01', periods=5, freq='D'))
 
# Identificar valores ausentes
print(df.isna())
#             A     B
# 2022-01-01 False False
# 2022-01-02 False  True
# 2022-01-03  True False
# 2022-01-04 False False
# 2022-01-05 False False
 
# Interpolar valores ausentes
df = df.interpolate()
print(df)
#             A    B
# 2022-01-01  1  5.0
# 2022-01-02  2  6.0
# 2022-01-03  3  7.0
# 2022-01-04  4  8.0
# 2022-01-05  5  9.0

Neste exemplo, criamos um DataFrame de série temporal de amostra com valores ausentes. Em seguida, usamos o método interpolate() para estimar os valores ausentes com base nos dados circundantes.

Lidando com valores ausentes em modelos de aprendizado de máquina

Os valores ausentes podem ter um impacto significativo no desempenho dos modelos de aprendizado de máquina. pandas.isnull() e pandas.isna() podem ser usados para identificar e lidar com valores ausentes antes de alimentar os dados em um modelo de aprendizado de máquina.

import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression
 
# Carregar o conjunto de dados
df = pd.read_csv('dataset.csv')
 
# Identificar valores ausentes
missing_values = df.isna().sum()
print(missing_values)
 
# Imp.
```Preencher valores ausentes usando a imputação da média
imputer = SimpleImputer(strategy='mean')
X = imputer.fit_transform(df.drop('target', axis=1))
y = df['target']
 
# Treinar um modelo de regressão linear
model = LinearRegression()
model.fit(X, y)

Neste exemplo, primeiro identificamos os valores ausentes no conjunto de dados usando df.isna().sum(). Em seguida, usamos o SimpleImputer do scikit-learn para preencher os valores ausentes usando a média de cada recurso. Finalmente, treinamos um modelo de regressão linear nos dados preenchidos.

O tratamento de valores ausentes é uma etapa crítica na preparação de dados para modelos de aprendizado de máquina, pois muitos modelos não podem lidar diretamente com valores ausentes. Usando pandas.isnull() e pandas.isna(), você pode garantir

Funções

As funções são blocos de código reutilizáveis que executam uma tarefa específica. Elas podem aceitar entradas, realizar operações e retornar saídas. As funções ajudam a organizar e modularizar seu código, tornando-o mais legível e manutenível.

Aqui está um exemplo de uma função simples que calcula a área de um retângulo:

def calculate_area(length, width):
    """
    Calcula a área de um retângulo.
 
    Args:
        length (float): O comprimento do retângulo.
        width (float): A largura do retângulo.
 
    Returns:
        float: A área do retângulo.
    """
    area = length * width
    return area
 
# Uso
rectangle_length = 5.0
rectangle_width = 3.0
rectangle_area = calculate_area(rectangle_length, rectangle_width)
print(f"A área do retângulo é {rectangle_area} unidades quadradas.")

Neste exemplo, a função calculate_area recebe dois parâmetros, length e width, e retorna a área calculada. A função também inclui uma docstring que fornece uma breve descrição da função e os parâmetros e valor de retorno esperados.

Módulos e Pacotes

A biblioteca padrão do Python fornece uma ampla gama de módulos internos, que são coleções de funções, classes e variáveis. Você também pode criar seus próprios módulos. Módulos e pacotes para organizar seu código e torná-lo mais reutilizável.

Aqui está um exemplo de como criar um módulo simples:

# my_module.py
def greet(name):
    """
    Cumprimenta a pessoa com o nome fornecido.
 
    Args:
        name (str): O nome da pessoa a ser cumprimentada.
 
    Returns:
        str: A mensagem de saudação.
    """
    return f"Olá, {name}!"

Para usar o módulo, você pode importá-lo em outro arquivo Python:

# main.py
import my_module
 
greeting = my_module.greet("Alice")
print(greeting)  # Saída: Olá, Alice!

Pacotes são coleções de módulos organizados em diretórios. Eles permitem agrupar módulos relacionados e fornecer uma estrutura hierárquica para seu código. Aqui está um exemplo de como criar um pacote simples:

my_package/
    __init__.py
    utils/
        __init__.py
        math_functions.py
        string_functions.py

Os arquivos __init__.py são usados para definir a estrutura do pacote e especificar quais módulos devem ser importados quando o pacote é importado.

# my_package/utils/math_functions.py
def add(a, b):
    return a + b
 
def subtract(a, b):
    return a - b
# main.py
from my_package.utils import math_functions
 
result = math_functions.add(5, 3)
print(result)  # Saída: 8

Exceções

Exceções são eventos que ocorrem durante a execução de um programa e interrompem o fluxo normal das instruções do programa. O Python possui um mecanismo de tratamento de exceções integrado que permite lidar e gerenciar essas situações inesperadas.

Aqui está um exemplo de como tratar uma exceção ZeroDivisionError:

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Erro: Divisão por zero.")
        return None
 
print(divide(10, 2))  # Saída: 5.0
print(divide(10, 0))  # Saída: Erro: Divisão por zero.

Neste exemplo, a função divide tenta dividir o primeiro argumento pelo segundo argumento. Se ocorrer uma ZeroDivisionError, a função imprime uma mensagem de erro e retorna None. DivisionError ocorre, a função captura a exceção e imprime uma mensagem de erro, então retorna None.

Você também pode criar exceções personalizadas definindo suas próprias classes de exceção que herdam da classe Exception ou de uma de suas subclasses.

class NegativeValueError(Exception):
    """Lançada quando um valor negativo é encontrado."""
    pass
 
def calculate_square_root(number):
    if number < 0:
        raise NegativeValueError("Não é possível calcular a raiz quadrada de um número negativo.")
    return number ** 0.5
 
try:
    print(calculate_square_root(16))  # Saída: 4.0
    print(calculate_square_root(-4))
except NegativeValueError as e:
    print(e)  # Saída: Não é possível calcular a raiz quadrada de um número negativo.

Neste exemplo, a função calculate_square_root levanta uma exceção personalizada NegativeValueError se o número de entrada for negativo. A exceção é então capturada e tratada no bloco try-except.

Entrada/Saída de Arquivos

O Python fornece funções e métodos internos para ler e escrever em arquivos. A maneira mais comum de trabalhar com arquivos é usando a função open(), que retorna um objeto de arquivo que pode ser usado para realizar várias operações de arquivo.

Aqui está um exemplo de como ler e escrever em um arquivo:

# Escrevendo em um arquivo
with open("example.txt", "w") as file:
    file.write("Esta é a primeira linha.\n")
    file.write("Esta é a segunda linha.\n")
 
# Lendo de um arquivo
with open("example.txt", "r") as file:
    contents = file.read()
    print(contents)
    # Saída:
    # Esta é a primeira linha.
    # Esta é a segunda linha.

Neste exemplo, a função open() é usada para abrir um arquivo chamado "example.txt" no modo de escrita ("w") e escrever duas linhas de texto nele. Em seguida, o arquivo é aberto no modo de leitura ("r") e o conteúdo é lido e impresso.

A instrução with é usada para garantir que o arquivo seja fechado corretamente após as operações serem concluídas, mesmo que uma exceção ocorra.

Você também pode ler arquivos linha por linha.

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())
    # Saída:
    # Esta é a primeira linha.
    # Esta é a segunda linha.

Neste exemplo, o método strip() é usado para remover o caractere de nova linha de cada linha.

Expressões Regulares

Expressões regulares (regex) são uma ferramenta poderosa para correspondência de padrões e manipulação de texto. O módulo re integrado do Python fornece um conjunto abrangente de funções e métodos para trabalhar com expressões regulares.

Aqui está um exemplo de como usar expressões regulares para validar um endereço de e-mail:

import re
 
def is_valid_email(email):
    """
    Verifica se o endereço de e-mail fornecido é válido.
 
    Args:
        email (str): O endereço de e-mail a ser validado.
 
    Returns:
        bool: True se o endereço de e-mail for válido, False caso contrário.
    """
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    if re.match(pattern, email):
        return True
    else:
        return False
 
print(is_valid_email("example@example.com"))  # Saída: True
print(is_valid_email("invalid_email"))  # Saída: False

Neste exemplo, a função is_valid_email recebe um endereço de e-mail como entrada e usa um padrão de expressão regular para verificar se o endereço de e-mail é válido. A função re.match() é usada para aplicar o padrão ao endereço de e-mail e retornar um resultado booleano.

As expressões regulares podem ser usadas para uma ampla gama de tarefas de processamento de texto, como:

  • Pesquisar por padrões específicos no texto
  • Extrair informações do texto
  • Substituir ou modificar o texto com base em padrões
  • Validar dados de entrada

Embora as expressões regulares possam ser poderosas, elas também podem se tornar complexas e difíceis de ler, especialmente para casos de uso mais avançados. É importante equilibrar o uso de expressões regulares com outras técnicas de processamento de texto, como manipulação de strings e métodos de string integrados.

Conclusão

Neste tutorial, você aprendeu sobre vários conceitos de nível intermediário em Python.Conceitos de Python, incluindo funções, módulos e pacotes, tratamento de exceções, entrada e saída de arquivos e expressões regulares. Esses tópicos são essenciais para a construção de aplicativos Python mais complexos e robustos.

Lembre-se, a melhor maneira de melhorar suas habilidades em Python é praticar, experimentar e aprender continuamente. Explore a biblioteca padrão do Python, leia a documentação e participe de comunidades on-line para expandir seu conhecimento e ficar atualizado com os últimos desenvolvimentos no ecossistema Python.

Feliz codificação!

MoeNagy Dev.