Python & Pandas: Guia Essencial para Machine Learning com Python

A área de machine learning tem crescido de maneira exponencial, e com o Python à frente desse avanço, bibliotecas como o Pandas se tornaram ferramentas indispensáveis. Neste guia, exploraremos as funcionalidades do Pandas, essenciais para preparação de dados em projetos de machine learning.

O que é o Pandas? Pandas é uma biblioteca de código aberto que proporciona estruturas de dados de alto desempenho e ferramentas de análise para a linguagem de programação Python. Com Pandas, lidar com tabelas de dados se torna tão intuitivo quanto manipular planilhas no Excel.

Importando o Pandas Para começar a aproveitar as funcionalidades do Pandas, primeiro precisamos importá-lo:

import pandas as pd

1 2	import pandas as pd

Explorando a Criação de Séries com o Pandas

As séries do Pandas são estruturas que se assemelham a arrays unidimensionais e têm a flexibilidade de funcionar quase como uma coluna isolada de uma planilha. O grande diferencial de uma série é a possibilidade de associar um índice customizado a cada um de seus elementos, oferecendo uma variedade de formas para manipular e acessar os dados. Diferentemente de um índice puramente numérico, estes rótulos podem ser strings, datas, ou qualquer tipo imutável, adicionando uma camada de personalização e praticidade.

As séries se aproximam das colunas de tabelas devido a características importantes:

Estrutura Unidimensional: Assim como uma coluna de uma tabela que organiza os dados verticalmente, uma série mantém seus valores alinhados em uma única dimensão linear.
Índices Associados: Cada entrada em uma série tem um rótulo único que funciona como índice, semelhante à maneira como uma linha é identificada em uma tabela.
Operações Verticais: Processos como filtragem e agregação são feitos ao longo do eixo da série, de forma equivalente ao que seria feito com colunas de uma tabela.

Para ilustrar, tomemos um conjunto de dados de idades:

import pandas as pd
idades = [25, 30, 35]
serie_idades = pd.Series(idades)
print(idades, end='nn')
print(serie_idades, end='nn')

import pandas as pd

idades = [25, 30, 35]

serie_idades = pd.Series(idades)

print(idades, end='nn')

print(serie_idades, end='nn')

Aqui, convertemos uma lista de idades em uma série no Pandas usando pd.Series(idades). Para adicionar uma camada de detalhamento, podemos nomear cada idade:

import pandas as pd
# Associando idades a nomes
serie_nome_idades = pd.Series(idades, index=['Alice', 'Bob', 'Charlie'])
print(serie_nome_idades, end='nn')

import pandas as pd

# Associando idades a nomes

serie_nome_idades = pd.Series(idades, index=['Alice', 'Bob', 'Charlie'])

print(serie_nome_idades, end='nn')

Assim, obtemos uma série nomeada que parece e age como uma coluna de uma tabela:

Alice      25
Bob        30
Charlie    35

Alice 25

Bob 30

Charlie 35

Esta representação é muito próxima daquela de uma coluna tabular onde os índices (neste caso, nomes) e os valores (idades) estão alinhados verticalmente.

Essa estrutura nos permite acessar dados de maneira intuitiva. Por exemplo, para obter a idade de Alice, fazemos:

idade_alice = serie_nome_idades['Alice']
print(idade_alice)  # Output: 25

idade_alice = serie_nome_idades['Alice']

print(idade_alice) # Output: 25

Consideremos outro exemplo, criando uma série com índices alfabéticos:

import pandas as pd
# Criando uma série com índices alfabéticos
serie = pd.Series(data=[100, 200, 300], index=['a', 'b', 'c'])

import pandas as pd

# Criando uma série com índices alfabéticos

serie = pd.Series(data=[100, 200, 300], index=['a', 'b', 'c'])

Nesta série, valores como [100, 200, 300] são acessíveis através dos índices [‘a', ‘b', ‘c'], contrastando com o acesso tradicional por números.

Cada um desses exemplos mostra o potencial do Pandas para organizar dados de uma forma que seja tanto funcional quanto intuitivamente compreensível, evidenciando o poder das séries para a análise e manipulação de dados.

Séries com Diferentes Tipos de Dados

Séries do Pandas podem conter qualquer tipo de dados:

import pandas as pd
# Series com tipos de dados mistos
serie_mista = pd.Series(data=[100, 'Python', 3.14])
print(serie_mista, end='nn')

import pandas as pd

# Series com tipos de dados mistos

serie_mista = pd.Series(data=[100, 'Python', 3.14])

print(serie_mista, end='nn')

Aqui, 100 é um inteiro, 'Python' é uma string e 3.14 é um número de ponto flutuante.

Nesse caso, ao imprimir a variável teremos a saída a seguir, onde o tipo de dados resultante é um objeto e não um tipo de dados primitivo.

0       100
1    Python
2      3.14
dtype: object

0 100

1 Python

2 3.14

dtype: object

Séries a Partir de Dicionários

Também é possível criar uma Series diretamente de um dicionário de Python:

# Series de um dicionário
serie_dict = pd.Series({'a': 1, 'b': 2, 'c': 3})

# Series de um dicionário

serie_dict = pd.Series({'a': 1, 'b': 2, 'c': 3})

Os pares chave-valor do dicionário se tornam os índices e os dados da Series, respectivamente.

Operações em Series

Séries do Pandas são mais do que simples coleções de dados; elas vêm equipadas com a capacidade de executar uma vasta gama de operações matemáticas e estatísticas, que são cruciais para a análise de dados.

Operações Matemáticas Básicas

Você pode realizar operações matemáticas elemento a elemento diretamente em uma série, da mesma forma que faria com números individuais:

import pandas as pd
# Criando uma série com índices alfabéticos
serie = pd.Series(data=[100, 200, 300], index=['a', 'b', 'c'])
# Duplicando os valores em uma série
serie_dobrada = serie * 2
print(serie_dobrada)

import pandas as pd

# Criando uma série com índices alfabéticos

serie = pd.Series(data=[100, 200, 300], index=['a', 'b', 'c'])

# Duplicando os valores em uma série

serie_dobrada = serie * 2

print(serie_dobrada)

As operações são vetorizadas, o que significa que são aplicadas a cada item da série sem a necessidade de um loop explícito. Isso simplifica o código e melhora o desempenho.

Métodos Estatísticos Comuns

O Pandas facilita a obtenção de medidas estatísticas comuns, como média, mediana, desvio padrão e muito mais, tudo com métodos simples e diretos:

# Calculando a média dos valores
media = serie.mean()

# Encontrando a mediana
mediana = serie.median()

# Obtendo o desvio padrão
desvio_padrao = serie.std()

# Calculando a média dos valores

media = serie.mean()

# Encontrando a mediana

mediana = serie.median()

# Obtendo o desvio padrão

desvio_padrao = serie.std()

Essas funções fornecem um resumo instantâneo da distribuição dos seus dados, o que é extremamente útil na análise exploratória de dados.

Operações de Comparação e Booleanas

Séries do Pandas também suportam operações de comparação, que são úteis para filtrar dados ou testar condições:

# Verificando valores acima da média 
valores_acima_media = serie > serie.mean() 
print(valores_acima_media,'nn')
# Selecionando apenas valores acima de um determinado threshold 
valores_selecionados = serie[serie > 50]
print(valores_selecionados, 'nn')

# Verificando valores acima da média

valores_acima_media = serie > serie.mean()

print(valores_acima_media,'nn')

# Selecionando apenas valores acima de um determinado threshold

valores_selecionados = serie[serie > 50]

print(valores_selecionados, 'nn')

Isso cria uma nova série de valores booleanos (True ou False), que você pode usar para indexação condicional.

Operações com Funções Universais do NumPy

A integração perfeita com o NumPy permite que você aplique suas funções universais (ufuncs) às séries do Pandas:

import numpy as np

# Aplicando logaritmo natural a cada valor
log_valores = np.log(serie)

import numpy as np

# Aplicando logaritmo natural a cada valor

log_valores = np.log(serie)

Essa operação é muito poderosa para transformações de dados, normalização e outras análises matemáticas avançadas.

Trabalhando com Valores Faltantes

Quando trabalhamos com conjuntos de dados, é comum encontrarmos situações onde nem todas as informações estão disponíveis. Estes são os chamados valores faltantes ou “missing values”. No contexto do Pandas, esses valores são geralmente representados por NaN (Not a Number) ou None.

Dados de Exemplo

Vamos criar uma Series que representa as temperaturas médias mensais de uma cidade ao longo de um ano, incluindo alguns valores faltantes.

import pandas as pd
import numpy as np

# Criando uma Series com temperaturas médias mensais, onde alguns meses têm valores faltantes (NaN)
temperaturas = pd.Series([25.3, np.nan, 27.5, 26.4, np.nan, 24.1, 22.5, 21.8, np.nan, 23.4, 24.8, 26.2], 
                         index=['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 
                                'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'])

print("Series Original:")
print(temperaturas)

import pandas as pd

import numpy as np

# Criando uma Series com temperaturas médias mensais, onde alguns meses têm valores faltantes (NaN)

temperaturas = pd.Series([25.3, np.nan, 27.5, 26.4, np.nan, 24.1, 22.5, 21.8, np.nan, 23.4, 24.8, 26.2],

index=['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho',

'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'])

print("Series Original:")

print(temperaturas)

Identificando Valores Faltantes

A função isnull() é usada para criar uma série booleana onde cada posição reflete se o valor no dado correspondente da série original está faltando ou não. Isso é feito da seguinte maneira:

nulos = temperaturas.isnull()
print("nValores Faltantes (True indica um valor faltante):")
print(nulos)

nulos = temperaturas.isnull()

print("nValores Faltantes (True indica um valor faltante):")

print(nulos)

Preenchendo Valores Faltantes

Para preencher os valores faltantes com a média das temperaturas:

temperaturas_preenchida = temperaturas.fillna(temperaturas.mean())
print("nSeries com Valores Faltantes Preenchidos pela Média:")
print(temperaturas_preenchida)

temperaturas_preenchida = temperaturas.fillna(temperaturas.mean())

print("nSeries com Valores Faltantes Preenchidos pela Média:")

print(temperaturas_preenchida)

Removendo Valores Faltantes

Para remover os valores faltantes da Series:

temperaturas_sem_nulos = temperaturas.dropna()
print("nSeries sem Valores Faltantes:")
print(temperaturas_sem_nulos)

temperaturas_sem_nulos = temperaturas.dropna()

print("nSeries sem Valores Faltantes:")

print(temperaturas_sem_nulos)

Este exemplo demonstra como trabalhar especificamente com Series no Pandas para tratar valores faltantes. Primeiro, identificamos esses valores utilizando isnull(). Em seguida, aplicamos duas abordagens para gerenciar os dados faltantes: preenchendo-os com a média das temperaturas disponíveis, através do método fillna(), ou removendo-os completamente com dropna(). Ambas as técnicas são fundamentais para a preparação e limpeza de dados antes de realizar análises mais profundas

Utilizando .apply() para Operações Customizadas

Para operações mais complexas ou personalizadas, o método .apply() é extremamente útil. Ele permite que você aplique uma função a cada item na série:

# Aplicando uma função customizada a cada elemento da série
serie_customizada = serie.apply(lambda x: x**2 if x > 50 else x + 10)
print(serie_customizada, end='nn')

# Aplicando uma função customizada a cada elemento da série

serie_customizada = serie.apply(lambda x: x**2 if x > 50 else x + 10)

print(serie_customizada, end='nn')

Essa abordagem oferece flexibilidade máxima, já que você pode definir qualquer função, seja ela embutida, customizada ou lambda, para manipular seus dados de forma precisa.

Concatenação e Operações Aritméticas entre Séries

Você também pode realizar operações aritméticas entre séries diferentes, além de concatená-las para formar uma nova série:

# Somando valores de duas séries diferentes
soma_series = serie1 + serie2

# Concatenando séries
serie_concatenada = pd.concat([serie1, serie2])

# Somando valores de duas séries diferentes

soma_series = serie1 + serie2

# Concatenando séries

serie_concatenada = pd.concat([serie1, serie2])

Ao realizar operações aritméticas entre séries, o Pandas automaticamente alinha os dados baseado nos índices. Se um índice não estiver presente em ambas as séries, o valor resultante será NaN.

Conclusão das Operações em Séries

Dominar essas operações em séries do Pandas é fundamental para a análise e tratamento de dados. Esses métodos e funções facilitam a execução de cálculos estatísticos, manipulações de dados e preparações necessárias para análises mais profundas ou visualizações. Com o Pandas, você tem todas as ferramentas necessárias para transformar seus dados em insights valiosos de maneira eficiente e eficaz.

Criando DataFrame no Pandas

O DataFrame é uma das estruturas de dados mais importantes e úteis dentro do Pandas. Pense nele como uma tabela de dados multidimensional onde cada coluna pode conter tipos diferentes de dados, ou seja, ele é heterogêneo. Os DataFrames vêm com os dois eixos rotulados – as linhas (índice) e as colunas.

Para criar um DataFrame do zero, você pode simplesmente passar uma lista de listas ou um array 2D, junto com uma lista opcional de nomes de colunas:

import pandas as pd

# Criando um DataFrame simples
dataframe = pd.DataFrame(data=[[1, 'John'], [2, 'Jane']], columns=['ID', 'Nome'])

import pandas as pd

# Criando um DataFrame simples

dataframe = pd.DataFrame(data=[[1, 'John'], [2, 'Jane']], columns=['ID', 'Nome'])

Neste exemplo, criamos um DataFrame com duas colunas: ‘ID' e ‘Nome'. O DataFrame pode armazenar dados de diferentes tipos, como ilustrado aqui com números e strings.

DataFrames a Partir de Dicionários de Listas

Outra maneira comum de criar DataFrames é através de um dicionário de listas. Cada chave do dicionário se torna uma coluna no DataFrame, e a lista associada contém os dados para essa coluna:

# DataFrame a partir de um dicionário
dados = {
    'ID': [1, 2, 3],
    'Nome': ['John', 'Jane', 'Jim'],
    'Idade': [22, 33, 44]
}
df_dicionario = pd.DataFrame(dados)

# DataFrame a partir de um dicionário

dados = {

'ID': [1, 2, 3],

'Nome': ['John', 'Jane', 'Jim'],

'Idade': [22, 33, 44]

}

df_dicionario = pd.DataFrame(dados)

Esse método é bastante intuitivo e alinha-se ao conceito de que um DataFrame é uma coleção de Séries com o mesmo índice.

DataFrames com Índices Personalizados

Você pode especificar os índices das linhas, que é especialmente útil quando os índices têm significado próprio:

# DataFrame a partir de um dicionário
dados = {
    'ID': [1, 2, 3],
    'Nome': ['John', 'Jane', 'Jim'],
    'Idade': [22, 33, 44]
}
df_indices = pd.DataFrame(data=dados, index=['linha1', 'linha2','linha3'])
print(df_indices)

# DataFrame a partir de um dicionário

dados = {

'ID': [1, 2, 3],

'Nome': ['John', 'Jane', 'Jim'],

'Idade': [22, 33, 44]

}

df_indices = pd.DataFrame(data=dados, index=['linha1', 'linha2','linha3'])

print(df_indices)

Adicionando Colunas a um DataFrame Existente

Após criar um DataFrame, é possível adicionar novas colunas a ele:

# Adicionando uma nova coluna ao DataFrame
df_indices['Salário'] = [50000, 60000, 70000]
print(df_indices)

# Adicionando uma nova coluna ao DataFrame

df_indices['Salário'] = [50000, 60000, 70000]

print(df_indices)

Esta operação insere a coluna ‘Salário' no DataFrame existente df_indices.

Criando DataFrames Complexos

DataFrames podem ser muito mais complexos, contendo diversas colunas de tipos variados e ser usados para representar datasets grandes e multidimensionais, que são comuns em projetos de análise de dados e machine learning:

import pandas as pd
import numpy as np
# DataFrame complexo com vários tipos de dados
df_complexo = pd.DataFrame({
    'A': pd.Series([1, 2, 3], index=['primeiro', 'segundo', 'terceiro']),
    'B': np.linspace(0, np.pi, 3),
    'C': pd.date_range(start='20210101', periods=3, freq='D')
})
print(df_complexo)

import pandas as pd

import numpy as np

# DataFrame complexo com vários tipos de dados

df_complexo = pd.DataFrame({

'A': pd.Series([1, 2, 3], index=['primeiro', 'segundo', 'terceiro']),

'B': np.linspace(0, np.pi, 3),

'C': pd.date_range(start='20210101', periods=3, freq='D')

})

print(df_complexo)

O DataFrame df_complexo é criado utilizando o construtor pd.DataFrame(), que organiza os dados em uma estrutura tabular de linhas e colunas. Este DataFrame específico é composto por três colunas (‘A', ‘B', ‘C'), cada uma contendo um tipo diferente de dado.

Componentes Detalhados

Coluna ‘A'

pd.Series([1, 2, 3], index=['primeiro', 'segundo', 'terceiro']): Esta série representa a coluna ‘A' do DataFrame. Uma Series do Pandas é um array unidimensional capaz de armazenar qualquer tipo de dado (integers, strings, floats, objetos Python, etc.). A série é composta por três inteiros (1, 2, 3) e utiliza um índice personalizado (['primeiro', 'segundo', 'terceiro']), que especifica os rótulos das linhas para os valores correspondentes.

Coluna ‘B'

np.linspace(0, np.pi, 3): Esta expressão utiliza a função linspace do NumPy para gerar três valores igualmente espaçados entre 0 e π (aproximadamente 3.14159). linspace é uma função útil para gerar uma sequência de números com espaçamento uniforme entre os valores de início e fim especificados. A coluna ‘B', portanto, contém valores float que variam de 0 a π, distribuídos uniformemente.

Coluna ‘C'

pd.date_range(start='20210101', periods=3, freq='D'): Esta expressão cria uma sequência de datas usando a função date_range do Pandas. O argumento start='20210101' define a data de início da sequência como 1º de janeiro de 2021. O periods=3 especifica que a sequência deve conter três datas. O freq='D' indica que a frequência entre as datas é diária. Assim, a coluna ‘C' contém uma sequência de três datas consecutivas, começando em 1º de janeiro de 2021.

Resumo do DataFrame

Ao combinar esses componentes, o df_complexo fica estruturado da seguinte forma:

Coluna ‘A': Contém inteiros com índices personalizados.
Coluna ‘B': Contém floats representando uma sequência numérica de 0 a π.
Coluna ‘C': Contém objetos de data, especificamente três dias consecutivos a partir de 1º de janeiro de 2021.

Este DataFrame exemplifica a flexibilidade do Pandas em lidar com diversos tipos de dados em uma única estrutura, permitindo uma análise de dados complexa e variada. A capacidade de especificar índices para as séries, gerar sequências numéricas com NumPy, e criar sequências de datas facilita o manuseio de dados para análise e visualização.

Importância do DataFrame no Machine Learning

No machine learning, os DataFrames são usados para armazenar e manipular conjuntos de dados utilizados para treinar e testar algoritmos. Eles permitem uma análise exploratória eficaz, facilitando a visualização dos dados, a identificação de padrões e a limpeza de dados antes de alimentar os algoritmos de machine learning. A habilidade de manipular DataFrames com eficiência é, portanto, uma habilidade valiosa para qualquer desenvolvedor Python que trabalhe com análise de dados e machine learning.

Usando read_csv() na Prática

A função read_csv() é uma das ferramentas mais poderosas e amplamente utilizadas do Pandas, permitindo que desenvolvedores carreguem dados de arquivos CSV (Comma-Separated Values) diretamente para um DataFrame. O formato CSV é um padrão da indústria para o armazenamento de tabelas de dados devido à sua simplicidade e interoperabilidade.

Carregando um Arquivo CSV Simples

A maneira mais básica de carregar um arquivo CSV com o Pandas é passando o caminho do arquivo para a função read_csv():

import pandas as pd

# Lendo um arquivo CSV em um DataFrame
df = pd.read_csv('caminho/para/seu/arquivo.csv')

import pandas as pd

# Lendo um arquivo CSV em um DataFrame

df = pd.read_csv('caminho/para/seu/arquivo.csv')

Assim que executar este código, o Pandas lê o arquivo CSV e cria um DataFrame chamado df com os dados contidos no arquivo.

Lidando com Cabeçalhos de Colunas

Arquivos CSV geralmente contêm uma primeira linha que serve como cabeçalho, indicando o nome de cada coluna:

# Lendo um CSV com cabeçalho
df_com_cabecalho = pd.read_csv('caminho/para/seu/arquivo.csv', header=0)

# Lendo um CSV com cabeçalho

df_com_cabecalho = pd.read_csv('caminho/para/seu/arquivo.csv', header=0)

Se o arquivo CSV não tiver uma linha de cabeçalho, você pode especificar header=None e fornecer os nomes das colunas usando o parâmetro names:

# Lendo um CSV sem cabeçalho
df_sem_cabecalho = pd.read_csv('caminho/para/seu/arquivo.csv', header=None, names=['Coluna1', 'Coluna2', 'Coluna3'])

# Lendo um CSV sem cabeçalho

df_sem_cabecalho = pd.read_csv('caminho/para/seu/arquivo.csv', header=None, names=['Coluna1', 'Coluna2', 'Coluna3'])

Especificando Tipos de Dados

O Pandas é muito bom em inferir tipos de dados, mas às vezes você pode querer especificar os tipos de dados de colunas para garantir que sejam lidos corretamente:

# Especificando tipos de dados de colunas
df_tipos = pd.read_csv('caminho/para/seu/arquivo.csv', dtype={'Coluna1': int, 'Coluna2': float})

# Especificando tipos de dados de colunas

df_tipos = pd.read_csv('caminho/para/seu/arquivo.csv', dtype={'Coluna1': int, 'Coluna2': float})

Tratando Dados Faltantes

Dados faltantes são comuns em muitos conjuntos de dados e podem ser tratados durante a leitura do arquivo CSV:

# Tratando dados faltantes com o valor NaN padrão do Pandas
df_dados_faltantes = pd.read_csv('caminho/para/seu/arquivo.csv', na_values=['NA', ''])

# Tratando dados faltantes com o valor NaN padrão do Pandas

df_dados_faltantes = pd.read_csv('caminho/para/seu/arquivo.csv', na_values=['NA', ''])

Manipulando Grandes Conjuntos de Dados

Para grandes conjuntos de dados, pode ser útil ler o arquivo em pedaços. O Pandas permite que você faça isso com o parâmetro chunksize:

# Lendo um CSV em pedaços
tamanho_do_chunk = 500
chunks = pd.read_csv('caminho/para/seu/arquivo.csv', chunksize=tamanho_do_chunk)
for chunk in chunks:
    # faça algo com cada pedaço, como processamento ou análise

# Lendo um CSV em pedaços

tamanho_do_chunk = 500

chunks = pd.read_csv('caminho/para/seu/arquivo.csv', chunksize=tamanho_do_chunk)

for chunk in chunks:

# faça algo com cada pedaço, como processamento ou análise

Parâmetros Adicionais

A função read_csv() vem com vários outros parâmetros que permitem personalizar como os dados são lidos, incluindo:

usecols: para selecionar quais colunas carregar.
skiprows: para pular um número específico de linhas no início do arquivo.
nrows: para carregar um número específico de linhas.
parse_dates: para analisar colunas como datas.

Exemplo Prático de Análise Inicial

Assim que os dados são carregados em um DataFrame, a análise inicial pode começar com métodos simples, como head() para visualizar as primeiras linhas ou describe() para obter uma descrição estatística dos dados:

# Análise inicial
print(df.head())
print(df.describe())

# Análise inicial

print(df.head())

print(df.describe())

Dominar a função read_csv() é uma habilidade essencial para qualquer desenvolvedor Python interessado em análise de dados e machine learning, pois ela abre as portas para a exploração e modelagem de praticamente qualquer conjunto de dados disponível em formato CSV.

Exportando Dados de um DataFrame Exportar seus dados é tão simples quanto carregá-los. Para salvar seu DataFrame em um arquivo CSV, você usará:

df.to_csv('caminho/para/seu/novo_arquivo.csv')

1 2	df.to_csv('caminho/para/seu/novo_arquivo.csv')

Explorando um Pouco Mais os Dados em DataFrame

Para executar os exemplos a seguir, faça o download do arquivo de exemplo clicando aqui e importe o arquivo no seu Google Colab.

Agora que temos nosso arquivo pandas-sample-data.csv, vamos mergulhar na análise e exploração de dados utilizando este DataFrame. Este processo é essencial para entender a natureza dos dados com os quais estamos trabalhando.

Carregando o Arquivo CSV

Começaremos carregando o arquivo pandas-sample-data.csv em um DataFrame do Pandas:

import pandas as pd
classData = pd.read_csv('pandas-sample-data.csv')
print(classData)

import pandas as pd

classData = pd.read_csv('pandas-sample-data.csv')

print(classData)

Análise Preliminar dos Dados

Com o DataFrame carregado, realizamos uma análise preliminar para entender a estrutura dos dados:

# Visualizando as primeiras 5 linhas
print(classData.head())

# Visualizando as últimas 5 linhas
print(classData.tail())

# Visualizando as primeiras 5 linhas

print(classData.head())

# Visualizando as últimas 5 linhas

print(classData.tail())

Tipos de Dados e Informações do DataFrame

Vamos verificar os tipos de dados e obter mais informações sobre o DataFrame:

# Verificando os tipos de dados
print(classData.dtypes)

# Informações sobre o DataFrame
print(classData.info())

# Verificando os tipos de dados

print(classData.dtypes)

# Informações sobre o DataFrame

print(classData.info())

Sumário Estatístico

Analisamos estatísticas descritivas que podem nos dar insights valiosos:

# Resumo estatístico das colunas numéricas
print(classData.describe())

# Resumo estatístico das colunas categóricas
print(classData.describe(include=[object]))

# Resumo estatístico das colunas numéricas

print(classData.describe())

# Resumo estatístico das colunas categóricas

print(classData.describe(include=[object]))

Contagem de Valores Únicos

Contamos valores únicos para entender a distribuição dos dados nas colunas categóricas:

# Contagem de instrutores únicos
print(classData['Instrutor'].value_counts())

# Contagem de AE únicos
print(classData['AE'].value_counts())

# Contagem de instrutores únicos

print(classData['Instrutor'].value_counts())

# Contagem de AE únicos

print(classData['AE'].value_counts())

Seleção e Filtragem

Podemos selecionar colunas específicas e filtrar linhas para análise focada:

# Seleção de colunas específicas
df_avaliacao_inscritos = classData[['Avaliacao', 'Inscritos']]
print(df_avaliacao_inscritos, end='nn')

# Filtragem de linhas baseada em uma condição
df_filtrado = classData[classData['Avaliacao'] >= 4.5]
print(df_filtrado, end='nn')

# Seleção de colunas específicas

df_avaliacao_inscritos = classData[['Avaliacao', 'Inscritos']]

print(df_avaliacao_inscritos, end='nn')

# Filtragem de linhas baseada em uma condição

df_filtrado = classData[classData['Avaliacao'] >= 4.5]

print(df_filtrado, end='nn')

Ordenando Dados

Ordenamos o DataFrame para visualizar os dados baseados em certos critérios:

# Ordenando pela avaliação de forma descendente
df_ordenado = classData.sort_values(by='Avaliacao', ascending=False)
print(df_ordenado)

# Ordenando pela avaliação de forma descendente

df_ordenado = classData.sort_values(by='Avaliacao', ascending=False)

print(df_ordenado)

Agrupando e Agregando Dados

Agregamos dados para obter métricas por grupo, como a média de inscritos por instrutor:

# Agrupando por instrutor e obtendo a média de inscritos
df_grupo_inscritos = classData.groupby('Instrutor')['Inscritos'].mean()
print(df_grupo_inscritos)

# Agrupando por instrutor e obtendo a média de inscritos

df_grupo_inscritos = classData.groupby('Instrutor')['Inscritos'].mean()

print(df_grupo_inscritos)

Trabalhando com Dados Faltantes

Identificamos e tratamos dados faltantes para melhorar a qualidade do nosso dataset:

# Identificando dados faltantes
print(classData.isnull().sum())

# Preenchendo dados faltantes
df_preenchido = classData.fillna({'Avaliacao': classData['Avaliacao'].mean()})
print(df_preenchido)

# Identificando dados faltantes

print(classData.isnull().sum())

# Preenchendo dados faltantes

df_preenchido = classData.fillna({'Avaliacao': classData['Avaliacao'].mean()})

print(df_preenchido)

Vamos analisar cada linha do código acima.

Identificando Dados Faltantes

# Identificando dados faltantes 
print(classData.isnull().sum())

1 2	# Identificando dados faltantes print(classData.isnull().sum())

Nesta etapa, você está identificando quantos valores faltantes (NaNs – Not a Number) existem em cada coluna do DataFrame classData. O método .isnull() retorna um DataFrame booleano, onde True indica a presença de um valor faltante. Ao encadear o método .sum() após .isnull(), você está somando a quantidade de valores True (ou seja, faltantes) em cada coluna. Isso fornece um resumo rápido de quantos valores faltantes existem por coluna, o que é crucial para decidir como lidar com esses dados ausentes.

Preenchendo Dados Faltantes

df_preenchido = classData.fillna({'Avaliacao': classData['Avaliacao'].mean()})

1	df_preenchido = classData.fillna({'Avaliacao': classData['Avaliacao'].mean()})

Nesta linha, você está lidando com os dados faltantes na coluna Avaliacao do DataFrame classData. O método .fillna() é utilizado para preencher os valores NaN encontrados no DataFrame. O argumento passado para .fillna() é um dicionário que especifica a coluna a ser modificada (Avaliacao) e o valor com o qual os NaNs serão substituídos (classData['Avaliacao'].mean()).

{‘Avaliacao': classData[‘Avaliacao'].mean()}: Este dicionário indica que apenas a coluna Avaliacao deve ter seus valores NaN preenchidos. O valor utilizado para o preenchimento é a média (mean()) dos valores existentes na coluna Avaliacao. Isso é uma prática comum para manter a consistência dos dados, especialmente em colunas numéricas, onde a média pode ser uma boa estimativa para valores faltantes, assumindo que os dados ausentes são aleatoriamente distribuídos.
df_preenchido: O resultado da operação de preenchimento é atribuído a uma nova variável, df_preenchido. Isso significa que classData permanece inalterado, preservando os dados originais, enquanto df_preenchido contém a versão modificada do DataFrame, onde os valores faltantes na coluna Avaliacao foram preenchidos com a média.

Plotando Dados

Visualizamos os dados para identificar tendências e padrões usando gráficos:

# Plotando a distribuição das avaliações
classData['Avaliacao'].plot(kind='hist')

1 2	# Plotando a distribuição das avaliações classData['Avaliacao'].plot(kind='hist')

Correlações

Exploramos correlações para entender como as variáveis estão relacionadas entre si:

# Correlação entre número de inscritos e avaliação do curso
print(df[['Inscritos', 'Avaliacao']].corr())

# Correlação entre número de inscritos e avaliação do curso

print(df[['Inscritos', 'Avaliacao']].corr())

Realizando estas operações de exploração de dados, ganhamos insights valiosos e preparamos o terreno para análises mais avançadas. Esta visão holística dos dados nos permite tomar decisões informadas sobre como proceder com a limpeza de dados, análises estatísticas mais profundas ou até mesmo modelagem preditiva.

Alterando Lables de Linhas e Colunas no DataFrame

Trabalhar com DataFrames exige não apenas habilidades analíticas, mas também capacidade de organização e padronização. O Pandas facilita esse processo através do método rename, o qual nos permite modificar os rótulos das colunas e linhas para atender a diversas necessidades de análise e apresentação. Vamos explorar como você pode fazer isso com o nosso arquivo pandas-sample-data.csv.

Mudando os Rótulos das Colunas

Em nosso DataFrame, temos informações importantes que poderiam ser representadas de uma maneira mais clara. Vejamos como renomear as colunas de forma prática:

classData.rename(columns={
    'ID_Curso': 'Código_Curso', 
    'Instrutor': 'Nome_Instrutor',
    'AE': 'Assistente_Ensino',
    'Inscritos': 'Total_Inscritos',
    'Avaliacao': 'Média_Avaliação'
}, inplace=True)
print(classData)

classData.rename(columns={

'ID_Curso': 'Código_Curso',

'Instrutor': 'Nome_Instrutor',

'AE': 'Assistente_Ensino',

'Inscritos': 'Total_Inscritos',

'Avaliacao': 'Média_Avaliação'

}, inplace=True)

print(classData)

Aqui, utilizamos um dicionário para mapear os nomes antigos para os novos, e inplace=True para garantir que a mudança afete o DataFrame original.

Padronização e Limpeza dos Nomes de Colunas

Para seguir um padrão mais técnico, poderíamos querer converter todos os nomes de colunas para letras minúsculas e substituir os espaços por underscores:

classData.rename(columns=lambda x: x.lower().replace(" ", "_"), inplace=True)
print(classData)

1 2	classData.rename(columns=lambda x: x.lower().replace(" ", "_"), inplace=True) print(classData)

Renomeando as Linhas

Embora seja menos comum, às vezes pode ser necessário renomear os rótulos das linhas. Vamos supor que queremos prefixar cada índice com ‘Linha_':

classData.rename(index=lambda i: 'Linha_' + str(i), inplace=True)
print(classData)

1 2	classData.rename(index=lambda i: 'Linha_' + str(i), inplace=True) print(classData)

Renomeação Estratégica ao Carregar o CSV

Podemos também optar por renomear as colunas imediatamente após a leitura do arquivo CSV:

classData = pd.read_csv('pandas-sample-data.csv') 
classData.columns = ['Código_Curso', 'Nome_Instrutor', 'Assistente_Ensino', 'Total_Inscritos', 'Média_Avaliação']
print(classData)

classData = pd.read_csv('pandas-sample-data.csv')

classData.columns = ['Código_Curso', 'Nome_Instrutor', 'Assistente_Ensino', 'Total_Inscritos', 'Média_Avaliação']

print(classData)

Ao adotar nomes mais claros e descritivos, você melhora a compreensão e a comunicação dos dados, tornando seu trabalho mais produtivo e menos propenso a erros.

Considerações Finais

Renomear os labels é uma prática simples, mas poderosa, que pode fazer toda a diferença na gestão e interpretação dos seus dados. Se você vai apresentar seus resultados a colegas, criar visualizações, ou preparar seus dados para análise preditiva, as renomeações adequadas ajudam a manter a consistência e claridade em todo o seu processo de trabalho com o Pandas.

Selecionando Dados de um DataFrame

Quando estamos trabalhando com DataFrames no Pandas, há momentos em que precisamos selecionar dados específicos para análises pontuais. Seja uma única coluna, um conjunto de linhas, ou uma combinação dos dois, o Pandas oferece métodos eficientes para seleção.

Selecionar Colunas

Se desejarmos selecionar uma única coluna do DataFrame, podemos usar o nome da coluna entre colchetes ou como um atributo do DataFrame:

# Selecionando a coluna 'Inscritos' usando colchetes
inscritos = classData['Inscritos']

# Selecionando a coluna 'Avaliacao' como um atributo
avaliacao = classData.Avaliacao

# Selecionando a coluna 'Inscritos' usando colchetes

inscritos = classData['Inscritos']

# Selecionando a coluna 'Avaliacao' como um atributo

avaliacao = classData.Avaliacao

Para selecionar múltiplas colunas, fornecemos uma lista de nomes de colunas entre colchetes:

# Selecionando múltiplas colunas
df_selecionado = classData[['Instrutor', 'AE', 'Avaliacao']]

# Selecionando múltiplas colunas

df_selecionado = classData[['Instrutor', 'AE', 'Avaliacao']]

Seleção de Linhas no DataFrame

A habilidade de selecionar linhas específicas em um DataFrame é um elemento chave para análise de dados eficiente. Dentro do ecossistema do Pandas, há várias maneiras de se realizar esta tarefa, desde a seleção básica com loc e iloc, até métodos mais avançados. Uma técnica poderosa envolve o uso de arrays booleanos, que permite filtrar linhas com base em condições lógicas complexas.

Utilizando Arrays Booleanos para Filtragem de Dados

Arrays booleanos são criados ao aplicar operadores de comparação a colunas do DataFrame. Eles consistem em séries de valores True ou False, dependendo se a condição é satisfeita ou não para cada linha. Vejamos como podemos empregar essa técnica:

# Criando um array booleano para cursos com Avaliacao maior que 4.7
array_booleano = classData['Avaliacao'] > 4.7
print(array_booleano,end='nn')

# Selecionando linhas que satisfazem a condição
cursos_top = classData[array_booleano]
print(cursos_top,end='nn')

# Criando um array booleano para cursos com Avaliacao maior que 4.7

array_booleano = classData['Avaliacao'] > 4.7

print(array_booleano,end='nn')

# Selecionando linhas que satisfazem a condição

cursos_top = classData[array_booleano]

print(cursos_top,end='nn')

Neste exemplo, cursos_top contém apenas as linhas do DataFrame original onde a coluna Avaliacao é maior que 4.7. Isso é especialmente útil para isolar um subset de dados com características específicas.

Combinando Condições com Arrays Booleanos

Podemos combinar múltiplas condições utilizando operadores lógicos como & (e) e | (ou):

# Selecionando cursos com Avaliacao acima de 4.7 E menos de 50 Inscritos
condicao = (classData['Avaliacao'] > 4.7) & (classData['Inscritos'] < 50)
cursos_selecionados = classData[condicao]
print(cursos_selecionados, end='nn')

# Selecionando cursos com Avaliacao acima de 4.7 E menos de 50 Inscritos

condicao = (classData['Avaliacao'] > 4.7) & (classData['Inscritos'] < 50)

cursos_selecionados = classData[condicao]

print(cursos_selecionados, end='nn')

Aqui, cursos_selecionados incluirá apenas as linhas onde ambas as condições são verdadeiras.

Invertendo Condições com o Operador ~

Também é possível inverter uma condição usando o operador ~, o que é equivalente a dizer ‘não':

# Selecionando cursos que NÃO têm Avaliacao de 4.8
cursos_nao_48 = classData[~(classData['Avaliacao'] == 4.8)]

# Selecionando cursos que NÃO têm Avaliacao de 4.8

cursos_nao_48 = classData[~(classData['Avaliacao'] == 4.8)]

Com cursos_nao_48, excluímos do DataFrame as linhas que possuem Avaliação igual a 4.8.

Usando Arrays Booleanos com loc

Para uma filtragem mais avançada, podemos utilizar o array booleano com loc, que permite selecionar tanto linhas quanto colunas específicas:

# Usando 'loc' com array booleano para selecionar linhas e a coluna 'Instrutor'
instrutores_top_cursos = classData.loc[df['Avaliacao'] > 4.7, 'Instrutor']

1 2	# Usando 'loc' com array booleano para selecionar linhas e a coluna 'Instrutor' instrutores_top_cursos = classData.loc[df['Avaliacao'] > 4.7, 'Instrutor']

Assim, instrutores_top_cursos contém os nomes dos instrutores cujos cursos possuem uma avaliação superior a 4.7.

Aplicando Arrays Booleanos a Análises Complexas

Quando suas análises se tornam mais complexas, você pode encontrar necessidade de criar arrays booleanos com base em múltiplos critérios ou manipulá-los para adaptar aos seus objetivos de análise.

Arrays booleanos são uma ferramenta poderosa e flexível no seu repertório do Pandas, permitindo que você faça a seleção de dados com critérios precisos e lógica complexa, aprimorando significativamente suas capacidades de exploração e análise de dados.

Selecionar Linhas e Colunas

Navegando por Linhas e Colunas no DataFrame

Ao lidar com conjuntos de dados como o nosso ‘pandas-sample-data.csv', frequentemente você se verá na situação de necessitar não apenas selecionar linhas ou colunas isoladas, mas sim combinações específicas de ambas. O Pandas oferece um método bastante elegante e poderoso para fazer isso, que nos permite alcançar um nível de precisão sob medida para nossas análises.

Combinando loc e iloc para Seleção Específica

O método loc permite selecionar com base nos rótulos das linhas e nomes das colunas, enquanto iloc trabalha com as posições numéricas (índices) de linhas e colunas.

Vamos usar loc para obter a nota de avaliação e o instrutor de um curso específico:

# Selecionando a avaliação e o instrutor do curso MT101
avaliacao_instrutor_mt101 = classData.loc[classData['ID_Curso'] == 'MT101', ['Instrutor', 'Avaliacao']]

# Selecionando a avaliação e o instrutor do curso MT101

avaliacao_instrutor_mt101 = classData.loc[classData['ID_Curso'] == 'MT101', ['Instrutor', 'Avaliacao']]

Este comando nos dá todas as linhas onde o ID do curso é ‘MT101', mas apenas as colunas ‘Instrutor' e ‘Avaliacao'.

Selecionando Intervalos com iloc

Suponha que queremos selecionar um intervalo de cursos e somente algumas de suas características, podemos utilizar iloc da seguinte maneira:

# Selecionando os primeiros 5 cursos e apenas as colunas de 'Instrutor' e 'Avaliacao'
primeiros_cursos = classData.iloc[0:5, [1, 4]]

# Selecionando os primeiros 5 cursos e apenas as colunas de 'Instrutor' e 'Avaliacao'

primeiros_cursos = classData.iloc[0:5, [1, 4]]

Lembre-se que iloc é exclusivo na parte superior do intervalo, então este comando irá buscar as linhas de índice 0 a 4.

Filtrando por Condições Complexas e Selecionando Colunas

Quando você precisa aplicar filtros mais complexos e, ao mesmo tempo, selecionar certas colunas, você pode combinar arrays booleanos com loc:

# Selecionando cursos com avaliação maior que 4.7 e as colunas 'Instrutor' e 'Avaliacao'
cursos_avaliacao_alta = classData.loc[classData['Avaliacao'] > 4.7, ['Instrutor', 'Avaliacao']]

1 2	# Selecionando cursos com avaliação maior que 4.7 e as colunas 'Instrutor' e 'Avaliacao' cursos_avaliacao_alta = classData.loc[classData['Avaliacao'] > 4.7, ['Instrutor', 'Avaliacao']]

Aqui, o resultado conterá apenas as linhas dos cursos com nota acima de 4.7, e das colunas, somente ‘Instrutor' e ‘Avaliacao' serão retornadas.

Selecionando Baseado em Múltiplos Critérios

Podemos inclusive aplicar múltiplos critérios para selecionar nossos dados:

# Selecionando cursos de 'FI' e que tenham mais de 45 inscritos
cursos_fi_45_inscritos = classData.loc[(classData['ID_Curso'].str.contains('FI')) & (classData['Inscritos'] > 45)]

1 2	# Selecionando cursos de 'FI' e que tenham mais de 45 inscritos cursos_fi_45_inscritos = classData.loc[(classData['ID_Curso'].str.contains('FI')) & (classData['Inscritos'] > 45)]

Dessa forma, somente linhas correspondentes aos cursos de Finanças (FI) com mais de 45 inscritos serão selecionadas.

Conclusão de Seleção de Dados

A habilidade de selecionar linhas e colunas de maneira seletiva e combinada é um pilar fundamental na análise de dados, oferecendo-nos a possibilidade de enfocar em subconjuntos de dados que são mais relevantes para nossos questionamentos e análises. Com as funcionalidades avançadas do Pandas, essa tarefa não só se torna facilitada, mas também incrivelmente poderosa, permitindo-nos extrair insights preciosos e tomar decisões baseadas em dados estruturados e bem definidos.

Atualizando o DataFrame

Muito além de apenas ler e selecionar dados, a gestão eficaz de um DataFrame muitas vezes requer atualizações cuidadosas. Estas podem ser alterações pontuais em registros específicos, imputação de valores faltantes ou ajustes em massa, como recalculação de estatísticas após uma mudança nos dados.

Atualizando Valores Individuais

Suponha que você descobriu que o número de inscritos para o curso MT102, ministrado por Luiz Costa, está incorreto. Para atualizar esse valor, utilizamos:

import pandas as pd
classData = pd.read_csv('pandas-sample-data.csv') 
classData.loc[(classData['ID_Curso'] == 'MT102') & (classData['Instrutor'] == 'Luiz Costa'), 'Inscritos'] = 59
print(classData)

import pandas as pd

classData = pd.read_csv('pandas-sample-data.csv')

classData.loc[(classData['ID_Curso'] == 'MT102') & (classData['Instrutor'] == 'Luiz Costa'), 'Inscritos'] = 59

print(classData)

Imputando Valores Faltantes

Nosso DataFrame possui algumas células vazias, representando dados faltantes. Podemos decidir imputar um valor padrão ou calcular um valor baseado em outras observações:

# Imputando a média de inscritos nos cursos onde falta essa informação
media_inscritos = df['Inscritos'].mean()
df['Inscritos'].fillna(value=media_inscritos, inplace=True)

# Imputando a média de inscritos nos cursos onde falta essa informação

media_inscritos = df['Inscritos'].mean()

df['Inscritos'].fillna(value=media_inscritos, inplace=True)

Atualizações Baseadas em Condições

Às vezes, queremos atualizar uma coluna com base em uma condição em outra. Por exemplo, podemos querer dar um boost nas avaliações dos cursos com poucos inscritos para refletir uma política de incentivo:

import pandas as pd
df = pd.read_csv('pandas-sample-data.csv') 
df.loc[df['Inscritos'] < 50, 'Avaliacao'] *= 1.1

import pandas as pd

df = pd.read_csv('pandas-sample-data.csv')

df.loc[df['Inscritos'] < 50, 'Avaliacao'] *= 1.1

Alterando o Tipo de Dados de Uma Coluna

Em algumas situações, é necessário converter o tipo de dados de uma coluna para realizar certos tipos de análises ou visualizações:

# Convertendo a coluna 'Inscritos' de float para int
df['Inscritos'] = df['Inscritos'].astype(int)

# Convertendo a coluna 'Inscritos' de float para int

df['Inscritos'] = df['Inscritos'].astype(int)

É sempre uma boa prática remover ou substituir os valores Nulos ou “NaN”. Em caso de erros ao aplicar a conversão, verifique se não há valores “NaN” nos seus dados.

Se você não quer perder dados removendo linhas, outra opção é preencher os valores NaN com um valor padrão, como 0, antes de fazer a conversão. Note que a escolha do valor para preencher depende do contexto dos seus dados e da análise que você está realizando.

df['Inscritos'].fillna(0, inplace=True)
df['Inscritos'] = df['Inscritos'].astype(int)

1 2	df['Inscritos'].fillna(0, inplace=True) df['Inscritos'] = df['Inscritos'].astype(int)

Adicionando Colunas Calculadas

Digamos que queiramos adicionar uma nova coluna que mostre a relação entre o número de inscritos e a avaliação do curso:

df['Relacao_Inscritos_Avaliacao'] = df['Inscritos'] / df['Avaliacao']

1 2	df['Relacao_Inscritos_Avaliacao'] = df['Inscritos'] / df['Avaliacao']

Removendo Colunas ou Linhas

Às vezes, queremos remover colunas ou linhas do nosso DataFrame para focar em dados mais relevantes para a análise:

# Removendo a coluna 'AE' (Assistente de Ensino)
df.drop(columns='AE', inplace=True)

# Removendo a coluna 'AE' (Assistente de Ensino)

df.drop(columns='AE', inplace=True)

Renomeando Colunas em Massa

Quando decidimos padronizar nomes de colunas ou apenas queremos simplificá-los:

df.rename(columns={'Instrutor': 'Prof', 'Inscritos': 'Alunos', 'Avaliacao': 'Nota'}, inplace=True)

1 2	df.rename(columns={'Instrutor': 'Prof', 'Inscritos': 'Alunos', 'Avaliacao': 'Nota'}, inplace=True)

Reordenando Colunas

Para melhor compreensão ou apresentação, você pode querer reordenar as colunas de um DataFrame:

df = df[['ID_Curso', 'Prof', 'Alunos', 'Nota', 'Relacao_Inscritos_Avaliacao']]

1 2	df = df[['ID_Curso', 'Prof', 'Alunos', 'Nota', 'Relacao_Inscritos_Avaliacao']]

Ajustando Índices Após Alterações

Por fim, após remover ou adicionar linhas, pode ser necessário redefinir o índice do DataFrame:

df.reset_index(drop=True, inplace=True)

1 2	df.reset_index(drop=True, inplace=True)

Estas são apenas algumas das muitas operações que você pode realizar para manter, atualizar e aprimorar o seu DataFrame ‘pandas-sample-data.csv'. Ao dominar essas técnicas, você garante que seus dados estão sempre precisos, atualizados e prontos para análise, permitindo que você extraia o máximo de insights valiosos de seus conjuntos de dados.

Métodos Úteis no Pandas

O Pandas é uma poderosa biblioteca em Python dedicada à manipulação e análise de dados. Para usufruir plenamente de suas funcionalidades, é essencial familiarizar-se com uma série de métodos que simplificam e enriquecem o processo de trabalho com DataFrames. Vamos explorar estes métodos com exemplos baseados em nosso conjunto de dados ‘pandas-sample-data.csv'.

describe(): Resumo Estatístico de Alto Nível

Este método é incrivelmente útil quando você deseja uma visão geral rápida das estatísticas descritivas de um DataFrame:

resumo_estatistico = df.describe()

1 2	resumo_estatistico = df.describe()

Com resumo_estatistico, você obtém a contagem, média, desvio padrão, mínimo, percentis e máximo de todas as colunas numéricas do DataFrame.

unique(): Explorando a Diversidade de Valores

Se você estiver interessado em ver a variedade de cursos, instrutores ou assistentes de ensino, unique() é o método perfeito para isso:

valores_unicos = df['Instrutor'].unique()

1 2	valores_unicos = df['Instrutor'].unique()

valores_unicos agora contém uma lista dos instrutores sem repetições.

groupby(): Análise Agrupada por Categorias

O groupby() permite agrupar o DataFrame por uma ou mais colunas e aplicar funções de agregação:

media_por_curso = df.groupby('ID_Curso')['Avaliacao'].mean()

1 2	media_por_curso = df.groupby('ID_Curso')['Avaliacao'].mean()

media_por_curso trará a média de avaliações para cada ID de curso.

merge(): Unindo DataFrames por Informação em Comum

Imagine que você tem outro DataFrame professores_df que contém mais informações sobre os instrutores. Com merge(), você pode combinar estes DataFrames facilmente:

df_detalhado = df.merge(professores_df, on='Instrutor')

1 2	df_detalhado = df.merge(professores_df, on='Instrutor')

df_detalhado agora contém dados combinados de ambos os DataFrames com base no nome do instrutor.

pivot_table(): Tabelas Dinâmicas para Análise Multidimensional

Às vezes, você precisa reestruturar seus dados para uma análise mais complexa, o pivot_table() é essencial para isso:

tabela_dinamica = df.pivot_table(values='Inscritos', index='ID_Curso', columns='Instrutor', aggfunc='sum')

1 2	tabela_dinamica = df.pivot_table(values='Inscritos', index='ID_Curso', columns='Instrutor', aggfunc='sum')

Com tabela_dinamica, você terá uma visão dos inscritos organizada por curso e instrutor.

Maximizando o Uso dos Métodos no Pandas

Esses métodos representam apenas a superfície do que você pode alcançar com o Pandas. Quando usados em conjunto e com compreensão de suas funcionalidades, eles formam uma poderosa base para manipulação de dados e extração de insights.

Explorar métodos como describe(), unique(), groupby(), merge() e pivot_table() permite que você transforme e refine seus dados em informações valiosas com eficiência e precisão. Ao se tornar proficientes nestas técnicas, analistas e cientistas de dados estão equipados para enfrentar desafios complexos de dados e extrair conclusões significativas que impulsionam decisões informadas e estratégicas.

Este artigo é apenas o começo de sua jornada no aprendizado de machine learning com Python, mas o domínio do Pandas é um passo CRUCIAL. Pratique os conceitos aqui abordados e você estará no caminho certo para tornar-se proficiente na manipulação de dados e na implementação de modelos de machine learning poderosos e eficazes. Happy coding!

Python & Pandas: Guia Essencial para Machine Learning com Python

Dados de Exemplo

Identificando Valores Faltantes

Componentes Detalhados

Coluna ‘A'

Coluna ‘B'

Coluna ‘C'

Resumo do DataFrame

Identificando Dados Faltantes

Preenchendo Dados Faltantes

Related Posts