Simplesmente Pandas

O guia introdutório a Pandas

Quando falamos de ciência de dados, geralmente nos referimos à análise de dados por meio de sumarização, visualizações, aplicação de algoritmos sofisticados que aprendem padrões (machine learning) e outras ferramentas extravagantes. Quando discutimos o termo com desenvolvedores de software, também ouvimos muito Python, a popular linguagem de programação.

Mas por que o Python é tão popular e especial no mundo da ciência de dados? Há muitas razões, e uma importante é o ecossistema Python e bibliotecas que fazem a ciência de dados parecer natural para python.

Este guia introduz pandas para desenvolvedores e tem como objetivo cobrir o os recursos mais usados pelos pandas.

para quê pandas?

Pandas, nos últimos dois anos, estabeleceram-se como uma das melhores bibliotecas para análise de dados. É tão importante o poder de pandas que uma das primeiras coisas que os cientistas de dados fazem ao receber um conjunto de dados é carregá-lo em pandas para começar a entendê-lo.

Pandas fornece tudo que for necessário para limpar, transformar e analisar dados. Essa biblioteca chega a ser tão robusta que analistas são capazes de fazer livros inteiros sobre apenas uma única biblioteca.

Aqui estão algumas das coisas que você pode fazer com pandas:

descrever

Obter informações sobre o conjunto de dados, calcular valores estatísticos, responder perguntas imediatas como médias, medianas, mínimas, máximas, correlações, distribuições e muito mais.

limpar

Remover duplicatas, substitua valores vazios, linhas de filtro, colunas;

transformar

Calcular novos valores, renomeie colunas, muta seus dados;

visualizar

Construir visualizações de última geração com matplotlib, seaborn ou outros diretamente do conjunto de dados carregados em pandas;

armazenar

Carregar e salvar dados em arquivos como CSV, JSON ou conectar-se diretamente a bancos de dados

instalação e importação

Pandas é uma biblioteca externa e, como tal, requer instalação para o seu projeto. Se você quiser acompanhar este tutorial de um novo projeto, você pode simplesmente instalar pandas executando:

pip install pandas

instalar notebook

E eu recomendo muito usar um notebook Jupyter como eu fiz para experimentar e testar os dados, então você terá que instalar isso também executando:

pip install jupyter notebook

Se você precisar de mais informações sobre como usar notebooks Jupyter, você pode verificar este guia:

importar biblioteca pandas

A última coisa antes de começar é importar a biblioteca.

import pandas as pd

Não é obrigatório fornecer um pseudônimo, mas é muito comum de usar, torna-o simples, e é assim que as pessoas fazem isso, então vamos seguir em frente.

leitura de dados

Embora você possa criar manualmente DataFrames em pandas, o que facilita o uso é sua capacidade de carregar diretamente dados de várias fontes, como CSV, JSON ou bancos de dados.

a partir de um arquivo CSV

Ler arquivos CSV é tão simples quanto uma linha de código com pandas.

df_titanic = pd.read_csv("titanic.csv")
df_titanic.head()

Importar um arquivo CSV com .read_csv() é tão simples quanto chamar uma função com o nome do arquivo. A segunda linha de código cham .head(), que imprime as cinco primeiras linhas de dados.

a partir de um arquivo JSON

Ler arquivos JSON não é mais complicado do que ler um CSV, é uma questão de uma simples chamada de função:

df_json = pd.read_json("sample.json")
df_json.head()

a partir de um banco de dados SQL

A leitura de dados de um banco de dados SQL requer algumas etapas adicionais em comparação com a leitura de arquivos CSV ou JSON. Isso ocorre porque pandas não suporta bancos de dados nativamente, mas dependem de bibliotecas de terceiros para estabelecer a conexão.

Uma vez que a conexão com o banco de dados esteja pronta, você pode trabalhar diretamente com pandas usando a função .read_sql_query

Para o nosso cenário, vamos ler dados do SQLite, mas outros mecanismos de banco de dados são suportados, como MySQL, Postgres, etc.

estabelecer conexão

Como dito anterior, precisamos estabelecer uma conexão com o banco de dados.

import sqlite3
con = sqlite3.connect("chinook.db")

consultas SQL em Pandas

Mais tarde, podemos executar diretamente consultas SQL em pandas para recuperar informações. No nosso caso, vamos apenas buscar dados de uma tabela.

df_sql = pd.read_sql_query("SELECT * FROM albums", con)
df_sql.head()

customização de parâmetros

Até agora, carregamos dados usando os valores padrão e isso funciona muito bem para a maioria dos casos. No entanto, pode haver circunstâncias em que você precisa mudar a forma de carregar e analisar os dados. As funções de leitura pandas estão completas e oferecem toneladas de personalizações. Você pode acompanhar mais sobre essas funçõesnos documentos oficiais.

Um parâmetro importante e altamente utilizado é o que permite especificar a coluna ou colunas usadas como o índice do DataFrame. Muito útil ao fatiar ou selecionar dados: index_col

df_drinks = pd.read_csv("data/drinks.csv", index_col = "country")
df_drinks.head()

salvando dados em pandas

Às vezes, realizamos alterações em nossos conjuntos de dados para facilitar a análise dos dados. No entanto, essas mudanças são perdidas a menos que as salvemos.

Pandas fornece métodos simples para armazenar um DataFrame em um arquivo ou banco de dados.

df.to_csv('saved.csv')  
df.to_json('saved.json')
df.to_sql('saved, con)

Observe que podemos armazenar os dados em qualquer tipo de arquivo, independentemente do formato que carregamos pela primeira vez.

descrevendo dados

Ao carregar os conjuntos de dados, desejamos entender sua estrutura e tomar consciência do que se trata. Nesta seção, cobriremos funções básicas de pandas que irão ajudá-lo exatamente sobre isso.

A primeira função que vamos cobrir é a função .head(), à qual já fomos introduzimos. Esta função imprime na tela as primeiras linhas de dados, e é útil explorar as colunas e tipos de um conjunto de dados pela primeira vez.

df_titanic.head()

Ou você pode passar o número específico de linhas

df_titanic.head(10)

.tail( )

Se você quiser ver as últimas linhas, você pode usar a função .tail() Assim como indicar quantas linhas retornar.

df_titanic.tail()

.info( )

Outra função interessante que você provavelmente precisa executar após o carregamento de seus dados é a função .info(), que fornece informações essenciais sobre seus conjuntos de dados, como o número de linhas e colunas, o número de valores não nulos, tipos de dados e uso de memória.info

df_titanic.info()<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 PassengerId 891 non-null int64
1 Survived 891 non-null int64
2 Pclass 891 non-null int64
3 Name 891 non-null object
4 Sex 891 non-null object
5 Age 714 non-null float64
6 SibSp 891 non-null int64
7 Parch 891 non-null int64
8 Ticket 891 non-null object
9 Fare 891 non-null float64
10 Cabin 204 non-null object
11 Embarked 889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB

Se você está tentando saber quantas e linhas de seus dados têm, então você pode obter o atributo do DataFrame:shape

df_titanic.shape(891, 12)

Se você está procurando entender melhor os valores do seu conjunto de dados, a função .describe()fornecerá um resumo estatístico de cada coluna, com informações como contagem, média, desvio padrão, etc.

df_titanic.describe()

manipulação de DataFrames

Vamos rever todos os métodos que são cruciais para a compreensão de todos os cientistas de dados.

Remoção de duplicatas

Duplicatas podem distorcer nossos resultados, por isso é essencial lidar com eles. Note que, por exemplo, carregamos um novo arquivo que contém duas duplicatas, e aqui estão os resultados

df_movies = pd.read_csv(‘movies.csv')
df_movies.shape
(77, 8)
df_movies = df_movies.drop_duplicates()
df_movies.shape
(75, 8)

Tenha em mente que isso não afetará o DataFrame original (por padrão) e, em vez disso, ele retornará um novo DataFrame com valores exclusivos. Você pode, alternativamente, passar o argumento inplace=True dentro de drop_duplicates para modificar o original em vez disso.

renomear colunas

Existem várias maneiras de renomear as colunas de quadro de dados em pandas, mas uma das maneiras mais úteis e fáceis é usar a função:

df_tmp = df_titanic.rename(
columns = {"PassengerId" : "PassId"})
df_tmp.head()

Retornará um novo DataFrame com as atualizações. Renomear com .rename() também suporta renomear mais de uma coluna de cada vez:

df_tmp = df_titanic.rename(columns = 
{"PassengerId" : "PassId",
"Pclass": "PassClass"})
df_tmp.head()

trabalhando com valores missing

Dados ausentes é um cenário da vida real e que pode ser um grande problema. Felizmente, pandas detecta os valores faltantes ou valores NA (Não Disponíveis).

Para detectar os valores nulos, usamos a função .isnull()

df_titanic.isnull()

A função retorna um novo DataFrame com a forma do original com valores booleanos (True ou False), indicando se uma determinada célula é nula ou não. Isso pode ser muito útil para realizar cálculos ou substituir valores vazios.isnull

remover linhas inteiras

Às vezes não podemos trabalhar com valores perdidos, então é melhor simplesmente remover as linhas completas. Você pode conseguir isso com a função .dropna

df_titanic.shape
(891, 12)
tmp = df_titanic.dropna()
tmp.shape
(183, 12)

A julgar pelos resultados, a maioria dos nossos registros contém pelo menos uma coluna vazia. Não seria sábio neste cenário simplesmente retirar todas essas linhas do DataFrame.

fatiamento, seleção, extração de dados

Até agora, temos trabalhado com conjuntos de dados inteiros ou realizando filtragem básica, como remover linhas vazias. Mas como podemos selecionar intencionalmente dados dos DataFrames?

Existem duas maneiras de acessar ou fatiar um DataFrame pandas, seja por coluna ou por linhas.

por coluna

Extrair dados por colunas em um DataFrame é super fácil. Basta usar com o nome da série [coluna]:

ds_survived = df_titanic['Survived']
ds_survived
type(ds_survived)

Observe que o resultado é uma DataSeries e não um DataFrame. Às vezes, como alguns métodos e propriedades diferem entre ambos, queremos transformar uma DataSeries em um DataFrame, fazemos isso usando a notação:[[]]

df_survived = df_titanic[['Survived']]
type(df_survived)

por linha

Ao selecionar dados por linha, temos mais opções do que por colunas. Podemos acessar uma linha por índices ou realizar uma pesquisa no conjunto de dados consultando ou aplicando condicionals.

Começaremos com a propriedade, permitindo o acesso a um grupo de linhas e colunas por etiquetas ou uma matriz booleana.loc

Observe que se tentarmos usar com rótulos, você precisa ter seu DataFrame indexado como fizemos no caso das bebidas DataFrame acima.loc

df_drinks.loc['Argentina']

Além disso, você precisa considerar que olhar por índice requer uma correspondência exata e é sensível ao caso, então no nosso caso, está correto, mas ou levantará uma exceção:

A saída para o código é:

beer_servings                   193
spirit_servings 25
wine_servings 221
total_litres_of_pure_alcohol 8.3
continent SA
Name: Argentina, dtype: object

Curiosamente, você também pode acessar várias linhas ao mesmo tempo usando as mesmas técnicas des listas:

df_drinks.loc['Argentina': 'Austria']

Isso retornará um novo DataFrame com todos os resultados entre e inclusivos.

Como filtrar dados sem rótulos? Você pode usar índices usando a propriedade, o que equivale a cortar em uma lista Python.

df_drinks.iloc[6:10]

Que produzirá o mesmo resultado de acima, selecionando do índice de posição 6 (Argentina) até o índice 10 (Áustria)

Também é possível atribuir um incremento (step), da mesma forma que fazemos com as listas.

df_drinks.iloc[6:10:2]

condição booleana

Às vezes você precisa mostrar apenas as linhas que atendem a algumas condições como exibir os países com mais de 320 porções de cerveja. Para isso você pode usar seleções condicionais:

df_drinks.loc[df_drinks['beer_servings'] > 320]

Vamos acabar com isso. é um condicional especial, pois se aplica a uma Série de Dados completa. O resultado será uma nova DataSeries com valores booleanos representando o resultado do condicional para cada linha no DataFrame original.

condição inteira

Nota: em alguns outros tutoriais você pode encontrar o mesmo código, mas deixando de lado, por exemplo:

df_drinks[df_drinks['beer_servings'] > 320]

estatísticas

Estatística e matemática estão entre as habilidades mais importantes que um cientista de dados deve ter em seu cinto. Felizmente, pandas facilitam a realização de cálculos estatísticos em nosso conjunto de dados.

estatísticas agregadas

Esta seção abordará como executar alguns cálculos estatísticos no conjunto de dados, como as funções média, groupby e contagem.

Começando usando a função, que retornará os valores médios da Série:

df_drinks.mean()-------------------------
Output
-------------------------
beer_servings 106.160622
spirit_servings 80.994819
wine_servings 49.450777
total_litres_of_pure_alcohol 4.717098
dtype: float64

A função devolveu os valores médios apenas das colunas numéricas, fazendo sentido já que você não pode realizar um cálculo estatístico médio em texto.

Também podemos realizar este cálculo no nível de Series, nesse caso retornaremos um único número.

df_drinks["beer_servings"].mean()-------------------------
Output
-------------------------
106.16062176165804

Vamos dizer que você quer calcular a média de algumas colunas com base em um grupo específico, então para esse objetivo você tem que usar uma função pandas chamada função.groupby()

df_drinks.groupby("continent")["beer_servings"].mean()-------------------------
Output
-------------------------
continent
AF 61.471698
AS 37.045455
EU 193.777778
OC 89.687500
SA 175.083333
Name: beer_servings, dtype: float64

Usando podemos realizar cálculos agrupados .groupby(“ “)por conjuntos de dados, por exemplo, a média de cada continente.O mesmo significa que podemos calcular a mediana , min, max , soma , e muito mais.

Outra função popular é contar o número de linhas/colunas, o que pode ser feito usando.

df.count(axis = 0)-------------------------
Output
-------------------------
beer_servings 193
spirit_servings 193
wine_servings 193
total_litres_of_pure_alcohol 193
continent 170
dtype: int64

Ao especificar o eixo=0 (valor padrão) contamos o número de linhas por coluna. No entanto, também podemos inverter o eixo (eixo=1) e contar o número de colunas por linha.

df.count(axis = 1)-------------------------
Output
-------------------------
country
Afghanistan 5
Albania 5
Algeria 5
Andorra 5
Angola 5
..
Venezuela 5
Vietnam 5
Yemen 5
Zambia 5
Zimbabwe 5
Length: 193, dtype: int64

funções comuns

Esta seção discutirá algumas das funções estatísticas mais comuns em pandas, um imperdível no arsenal de qualquer cientista de dados.

covariância

Vamos começar com a função cov que calculará a covariância em pares da coluna. Veja o código abaixo:

df_drinks.cov()

variação percentual

Outra função comumente usada pandas para calcular a variação perncentual do valor é a função .pct_chance(). Esta função calculará a variação percentual dos valores atuais em relação ao elemento anterior.

ind = pd.date_range('01/01/2020', periods = 7, freq ='W')  

df_tmp = pd.DataFrame({"A":[4, 14, 3, 6, 2, 55, 33],
"B":[5, 2, 54, 34, 2, 32, 56],
"C":[20, 20, 17, 31, 8, 5, 3],
"D":[14, 3, 6, 2, 3, 4, 12]}, index = ind)
df_tmp.pct_change()

Primeiro, criamos um índice de série de dados usando a função e um DataFrame contendo apenas valores aleatórios para fins de demonstração e finalmente aplicamos a função de alteração percentual sobre esses dados:

correlação

Vamos ver agora como calcular a relação de dois valores no que é conhecido como correlação. A função usada é chamada função e calcula a relação de todas as colunas do seu quadro de dados e não inclui os valores nulos, valores não disponíveis e dados não numéricos, como textos.corr()

df_tmp = pd.DataFrame({"A":[6, 8, 3, 4],  
"B":[51, 2, 6, 3],
"C":[7, 2, 9, 5],
"D":[5, 4, 4, 22]})
df_tmp.corr()

Usamos os valores aleatórios anteriores do exemplo de covariância para calcular a correlação das colunas.

classificação

Aprender a classificar seus dados com base em um padrão específico, como classificar o conjunto de dados de filmes com base em sua pontuação de classificação é uma das coisas mais usadas na ciência de dados ao lidar com conjuntos de dados.

df_movies['revenue_rank'] = df_movies["Worldwide Gross"].rank()
df_movies.head()

Criamos uma coluna chamada “‘revenue_rank’” com o ranking atribuído pela função baseada no “Worldwide Gross”:

conclusão

Os cientistas de dados precisam primeiro explorar, limpar e transformar seus dados antes de ir para o processo de visualização. Pandas facilita a realização dessas ações com apenas alguns comandos simples e pode ser usado para traçar os dados em vez de usar as outras bibliotecas, como matplotlib e seaborn.

Obrigado.

Composing a repository of books (i bought), authors (i follow) & blogs (direct ones) for my own understanding.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store