– Análise de Dados com o Pandas – O que é e para que serve
O Pandas é mais uma biblioteca disponível que nos auxilia a sermos mais eficientes. Sem dúvida, é uma das mais importante bibliotecas do Python. O Pandas nos permite importar e tratar uma quantidade enorme de dados em poucas linhas de código, e muito rápido.
É uma das ferramentas mais usadas para análise de dados e data Science.
Se tornou uma “convenção” importar esta biblioteca como pd. Portanto, não estranhe se sempre ler pd ao invés de pandas.
import panda as pd
– Pandas e csv
Quando estamos tratando muitos dados é muito comum que esses arquivos estejam em arquivos .csv. Esse formato é muito comum ao se extrair dados de sistemas. Existem algumas bibliotecas que permitem importar esses dados para o Python, mas o Pandas é uma das mais conhecidas e é extremamente simples de se fazer a extração.
Para importarmos os dados usaremos a função abaixo:
pd.read_csv()
Além disso, precisamos criar uma variável que receberá esses dados e informar o caminho de onde se encontra o arquivo que será importado no nosso exemplo. Chamaremos essa variável de vendas_df.
import pandas as pd
vendas_df = pd.read_csv(r'C:\Users\Joaop\Google Drive\Python Impressionador\Contoso - Vendas - 2017.csv', sep=';')
• vendas_df – Variável que receberá os dados importados.
• pd. – Acionando pandas.
• r' – Indica raw string. Ou seja, informa ao pandas que nenhum dos caracteres do caminho indicado são caracteres especiais.
• C: – Caminho que se encontra o arquivo.
• sep=';' – Indica que o texto em csv deverá ser separado a cada “;”.
Podemos ver que a importação foi feita. O pandas por padrão já nos fornece uma tabela formatada que nos permite visualizar melhor os dados. Além disso, nos informa o número de linhas e colunas da tabela no canto inferior esquerdo.
import pandas as pd
vendas_df = pd.read_csv(r'C:\Users\Joaop\Google Drive\Python Impressionador\Contoso - Vendas - 2017.csv', sep=';')
vendas_df
– Dataframe do Pandas
Essa tabela do pandas é chamada de dataframe. O poder do pandas passa por ela.
Podemos ver as colunas do Dataframe como as chaves de um Dicionário.
Veja o exemplo ao lado, usando o ´nome da coluna ‘ID Cliente’ o pandas nos dá os resultados da coluna, além de alguns dados sobre ela que nos ajudam a entendêla
lista_clientes = vendas_df['ID Cliente']
lista_clientes
_________________
0 6825
1 18469
2 19730
3 29326
4 22617
...
980637 10353
980638 31750
980639 12003
980640 25550
980641 28707
Name: ID Cliente, Length: 980642, dtype: int64
Da mesma forma, as linhas podem ser vistas como Listas. Essa comparação possui alguns detalhes, mas são bem parecidas. Se quisermos apenas 1 linha ou diversas linhas podemos usar a estrutura apresentada abaixo:
import pandas as pd
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
vendas_df[:3]
____________________________
Se quisermos apenas uma linha precisamos usar a estrutura um pouco distinta da utilizada nas listas. O Pandas precisa sempre de um intervalo, logo precisamos de um início e um fim. Como no exemplo abaixo, onde o início é a linha 2 e o fim linha 3.
import pandas as pd
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
vendas_df[2:3]
____________________________
Também é possível pegarmos várias colunas de um dataframe. Inclusive, se quisermos criar outro dataframe a partir dessas colunas basta atribuirmos ela a uma nova variável.
No exemplo ao lado, vamos criar um novo dataframe apenas com as colunas ‘ID Cliente ‘ e ‘Quantidade Vendida’.
Perceba que ao indicarmos ao pandas quais colunas buscamos, aproveitamos para armazena-las em um novo dataframe chamado “df_vendas_cliente”
Perceba que criamos uma lista dentro do colchetes que utilizamos para sinalizar as colunas que serão filtradas.
import pandas as pd
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
df_vendas_clientes = vendas_df[['ID Cliente','Quantidade Vendida']]
df_vendas_clientes
____________________________
Até agora, pegamos uma linha, uma coluna, várias linhas, várias colunas, mas além disso, também podemos acessar um valor específico de um dataframe.
No exemplo ao lado, pegamos o valor específico da linha de índice 100 da coluna ‘ID Cliente’. Perceba que assim como ocorrem nas listas, o índice a o número da linha são diferentes pois a tabela começa com índice 0 (ZERO).
import pandas as pd
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
vendas_df['ID Cliente'][100]
__________________________
15871
Agora que entendemos como fazer esses filtros vamos entender como podemos ter uma visão geral do nosso dataframe antes de iniciarmos mais profundamente nossas análises.
O pandas nos fornece um método que resume todas as colunas nos fornecendo informações importantes que podem acabar direcionando as próximas etapas de análise.
.info()
Este método nos permite entender os tipos dos dados de cada uma das colunas, nome das colunas, se as linhas destas colunas são não nulas, etc.
import pandas as pd
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
vendas_df.info()
_____________________
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 980642 entries, 0 to 980641
Data columns (total 10 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Numero da Venda 980642 non-null int64
1 Data da Venda 980642 non-null object
2 Data do Envio 980642 non-null object
3 ID Canal 980642 non-null int64
4 ID Loja 980642 non-null int64
5 ID Produto 980642 non-null int64
6 ID Promocao 980642 non-null int64
7 ID Cliente 980642 non-null int64
8 Quantidade Vendida 980642 non-null int64
9 Quantidade Devolvida 980642 non-null int64
dtypes: int64(8), object(2)
memory usage: 74.8+ MB
– Tratamento de Dados e Múltiplas Bases
Antes de qualquer análise, temos uma etapa muito importante. A verdade que é uma etapa um pouco chata e trabalhosa, mas o Pandas nos ajuda muito fazer dessa etapa algo mais fácil e direto. Antes de qualquer alteração vamos importar novamente nossas bases e usar o método .display() que nos permitirá visualizar todas as bases.
Importante, lembrar que o caminho para importar os arquivos vai depender de onde os seus arquivos estão. No exemplo ao lado, como os arquivos estão DENTRO da MESMA pasta do nosso arquivo do Jupyter, não precisamos indicar a pasta.
Outro ponto importante é o encoding. É provável, que as bases que você usará possuem caracteres do português. O Python não reconhece esses símbolos por padrão. Por isso, algumas vezes precisamos usar o encoding para “traduzir” nossas bases para o Python.
import pandas as pd
#às vezes precisaremos mudar o encoding. Possiveis valores para testar:
#encoding='latin1', encoding='ISO-8859-1', encoding='utf-8' ou então encoding='cp1252'
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
produtos_df = pd.read_csv(r'Contoso - Cadastro Produtos.csv', sep=';')
lojas_df = pd.read_csv(r'Contoso - Lojas.csv', sep=';')
clientes_df = pd.read_csv(r'Contoso - Clientes.csv', sep=';')
#usaremos o display para ver todos os dataframes
display(vendas_df)
display(produtos_df)
display(lojas_df)
display(clientes_df)
_______________________________
Quando usamos o PANDAS, é muito comum importarmos bases muito maiores do que precisamos. O ideal na fase de tratamento de dados é termos apenas o necessário para nossa análise pois isso fará com que nosso programa seja mais eficiente.
Vamos olhar uma extração da base “clientes_df”. Podemos ver que, temos uma série de colunas vazias que não agregam nenhum valor a nossa análise.
Uma forma de fazer esse tratamento é retirando do dataframe as informações inúteis. Para essa retirada, utilizamos o método abaixo:
.drop()
O método .drop() funciona como uma espécie de “delete”. Ele tira do nosso dataframe as colunas ou linhas indicadas. Vamos dizer que nossa intenção é retirar as colunas indicadas no nosso print. Usando o drop, vamos passar o intervalo dessas colunas e indicar se o que queremos é retirar as colunas ou as linhas, conforme indicado na linha de código ao lado.
Para esse método, temos 2 valores para o argumento axis:
• AXIS=1 - > Retira COLUNAS;
• AXIS=0 - > Retira LINHAS;
A T E N Ç Ã O !
O default do método .drop() é retirar LINHAS, portanto, se não indicarmos axis=1, o PANDAS irá retirar todas as linhas das colunas indicadas, OU SEJA, TODAS AS COLUNAS DA PLANILHA.
Outra forma que podemos tratar um dataframe para termos apenas as informações necessárias é criar um novo dataframe apenas com as colunas que queremos.
É mais comum usar essa abordagem em casos onde queremos poucos dados em relação ao todo da base de dados.
Vamos considerar que no nosso exemplo usaremos essa mesma lógica para cada uma das 4 bases que foram importadas. No entanto, trabalhar com 3 dataframes pode não ser
a melhor opção em alguns casos. Portanto, vamos juntar esses dataframes em um único dataframe utilizando o método abaixo:
.merge()
#juntando os dataframes
vendas_df = vendas_df.merge(produtos_df, on='ID Produto')
vendas_df = vendas_df.merge(lojas_df, on='ID Loja')
vendas_df = vendas_df.merge(clientes_df, on='ID Cliente')
#exibindo o dataframe final
display(vendas_df)
____________________________
A T E N Ç Ã O !
O método .MERGE() necessita que colunas IGUAIS possuam TÍTULOS IGUAIS, caso contrário serão consideradas colunas distintas. Caso seja necessário renomear uma coluna, usaremos o método .RENAME()
– Análises e Visualização de Dados no Pandas (Parte 1)
Agora que temos nosso dataframe apenas com as informações que queremos, vamos começar nossa análise. Vamos dizer que nossa análise se baseia em saber quais dos clientes mais vezes comprou. Além da contagem vamos aproveitar e fazer um gráfico que
nos permita analisar visualmente esse tema. Para a contagem de vezes usaremos o método:
.value_counts()
Já para o gráfico usaremos o método :
.plot()
Perceba que apenas esses métodos não são o suficiente para uma análise boa ... O gráfico ainda está estranho, o eixo x do gráfico está ilegível... Vamos entender como melhorar esses temas!
frequencia_clientes = vendas_df['E-mail do Cliente'].value_counts()
display(frequencia_clientes)
frequencia_clientes.plot()
_____________________________
karen33@adventure-works.com 77
chloe77@adventure-works.com 74
julia43@adventure-works.com 69
josé64@adventure-works.com 68
destiny66@adventure-works.com 68
..
vshave74@oaic.gov.au 1
csalefy@ning.com 1
okaret19@themeforest.net 1
aromainhy@narod.ru 1
pfeldonie@privacy.gov.au 1
Name: E-mail do Cliente, Length: 38907, dtype: int64
<matplotlib.axes._subplots.AxesSubplot at 0x226955a7100>
Para melhorarmos a análise, primeiro, vamos olhar para os dados que importam. Perceba que ao usarmos o .value_counts() criamos um rank de e-mails do maior para o menor. Ou seja, temos uma lista rankeada onde a posição [0] corresponde ao maior, [1] ao segundo
maior, etc.... Se usarmos isso juntamente ao método .plot(), podemos plotar o gráfico apenas dos clientes mais relevantes.
Vamos agora melhorar a visualização do nosso gráfico usando alguns dos argumentos disponíveis dentro do método .plot(). No nosso caso, usaremos o argumento figsize que requer uma tupla de valores (largura, altura). Isso permitirá estendermos o gráfico e termos uma melhor visualização do que ocorre no eixo X
frequencia_clientes = vendas_df['E-mail do Cliente'].value_counts()
frequencia_clientes[:5].plot(figsize=(15, 5))
– Análises e Visualização de Dados no Pandas (Parte 2)
Vamos analisar agora as lojas que apresentaram a melhor performance em vendas.
A lógica é muito parecida com o anterior, no entanto, antes contamos quantas vezes o e-mail aparecia para sabermos quem mais comprou.
Agora vamos precisar somar todos as vendas das lojas. Para isso, usaremos outros 2 métodos .GROUPBY() e .SUM () conforme apresentado ao lado:
• .GROUPBY() → Agrupa os dados iguais da coluna indicada (doc)
• .SUM() → Soma todos os dados indicados (doc)
Perceba que utilizamos o groupby antes do sum para que o Python entenda que precisa somar baseado no agrupamento.
Perceba que as informações descartadas não foram perdidas visto que criamos uma variável vendas_lojas que recebeu essa extração do dataframe original.
Visto que não perdemos informação, podemos descartar também as informações que não agregam valor, ficando apenas com “Quantidade Vendida”, conforme o print ao lado. Para isso, vamos filtrar nosso df vendas_lojas usando a estrutura apresentada ao lado.
vendas_lojas = vendas_df.groupby('Nome da Loja').sum()
vendas_lojas = vendas_lojas[['Quantidade Vendida']]
display(vendas_lojas)
________________________
Agora já temos uma tabela bem mais interessante e intuitiva, mas podemos melhorar ainda mais por exemplo colocando-a em ordem decrescente de vendas.
Para isso, usaremos o método .sort_values().
ATENÇÃO este sort_values que usaremos não é o mesmo que vimos até aqui. Este sort_values, é o sort do PANDAS e apesar de o resultado ser o mesmo, possui argumentos distintos. Em caso de dúvidas, consulte a documentação.
Caso o argumento ascending não seja fornecido, será considerada a ordem crescente. Como não é o que queremos, vamos inserí-lo após a coluna que desejamos ranquear usando a sintaxe:
ascending = False
#ordenando o dataframe
vendas_lojas = vendas_lojas.sort_values('Quantidade Vendida', ascending = False)
display(vendas_lojas)
________________________________
Já temos nossa tabela apresentada de forma bem intuitiva, agora vamos usar essa informação para gerar um gráfico com essas informações.
Novamente, usaremos o método .plot() (doc)
Como temos uma tabela já ordenada, podemos usar a estrutura [:5] por exemplo, para pegarmos apenas o TOP 5 de lojas em vendas. Se nossa intenção fosse pegar as últimas 5 lojas, por exemplo, poderíamos usar [-5:]
Outra possibilidade, é usar o argumento kind=‘bar’ para plotarmos o gráfico no modelo de barras verticais.
#ordenando o dataframe
vendas_lojas = vendas_lojas.sort_values('Quantidade Vendida', ascending = False)
#podemos plotar em um gráfico
vendas_lojas[:5].plot(figsize=(15, 5), kind='bar')
__________________________________________
– Filtrando um dataframe
Algo bastante comum nas análises é precisarmos filtrar as informações baseados em alguns critérios. Vamos voltar a usar nosso dataframe original vendas_df para aprendermos como filtrar informações utilizando o pandas.
Primeiro, vamos avaliar qual a taxa de devoluções que temos na empresa CONTOSO. Ela será nossa referência para sabermos quais lojas estão com taxa de devolução superior. Para isso, podemos calcular a soma da coluna QUANTIDADE DEVOLVIDA sobre a soma da coluna QUANTIDADE VENDIDA, conforme apresentado no print ao lado.
Vamos aproveitar para usar o format que já conhecemos de módulos anteriores. ☺
qtde_vendida = vendas_df['Quantidade Vendida'].sum()
qtde_devolvida = vendas_df['Quantidade Devolvida'].sum()
print('{:.2%}'.format(qtde_devolvida / qtde_vendida))
____________________________
1.17%
Agora que temos nossa taxa de todo o dataframe, vamos calcular de uma loja específica.
Como temos uma coluna “ID LOJA”, vamos usá-la para o filtro. Além disso, vamos criar uma variável específica para armazenamento dos dados dessa loja VENDAS_LOJASCONSOTOEUROPEONLINE.
vendas_lojacontosoeuropeonline = vendas_df[vendas_df['ID Loja'] == 306]
display(vendas_lojacontosoeuropeonline)
qtde_vendida = vendas_lojacontosoeuropeonline['Quantidade Vendida'].sum()
qtde_devolvida = vendas_lojacontosoeuropeonline['Quantidade Devolvida'].sum()
print('{:.2%}'.format(qtde_devolvida / qtde_vendida))
_______________________
Alcançamos o resultado, mas vamos entender melhor a linha onde filtramos para que a sintaxe faça um pouco mais de sentido.
Primeiro, vamos pegar a parte interna código:
vendas_df[‘ID Loja’] == 306
Se executarmos apenas esse código no Python, vamos ter a tabela ao lado como resultado. Perceba que o que estamos fazendo aqui é olhar linha a linha se o ID LOJA é == 306. É como se fizéssemos um for e um IF, linha a linha checando se ID Loja == 306.
No próximo slide vamos voltar para nosso código original e entender como essa tabela influencia o resto do código.
Voltando para o código completo, temos que vendas_df[‘ID Loja’] == 306 nos retorna um df que indica se essa condição é atendida ou não. Para nos auxiliar, vamos guardar essa tabela na df loja306.
Ao usarmos vendas_df [loja306] o que estamos fazendo é aplicando essa tabela a vendas_df indicando quem fica e quem sai. Assim, o Python nos retornará a tabela ao lado já filtrada com apenas os valores que atendem a condição [‘ID Loja’]==306.
#vendas_lojacontosoeuropeonline = vendas_df[vendas_df['ID Loja'] == 306]
loja306 = vendas_df['ID Loja'] == 306
vendas_lojacontosoeuropeonline = vendas_df[loja306]
display(vendas_lojacontosoeuropeonline)
__________________________________
Podemos também ter situações onde apenas 1 critério não é suficiente para nossa análise.
Vamos dizer que além da loja, também quero saber quais vendas não tiveram devolução, ou seja ‘Quantidade Devolvida’ == 0.
Aqui usaremos a mesma lógica que usávamos no IF quando tínhamos mais de 1 condição.
Em geral, usávamos AND ou OR dependendo do que queríamos. Aqui não será diferente. Como queremos uma loja específica E Quantidade devolvida=0, usaremos o comparador lógico AND (ou &). Podemos perceber que o número de linhas antes de 42mil foi reduzido a 35 mil. Isso ocorre pois além da condição loja ==306, temos também devoluções == 0.
df_loja306semdev = vendas_df[(vendas_df['ID Loja'] == 306) & (vendas_df['Quantidade Devolvida'] == 0)]
display(df_loja306semdev)
___________________________
– Adicionando e Modificando Colunas
Voltando para nosso dataframe vendas_df original, vamos entender como adicionar e modificar colunas do nosso dataframe.
Como podemos ver no print ao lado, apesar de parecem formatadas como datas, ao importar os dados das nossas bases .csv o Python as classificou com TYPE OBJECT e não como DATETIME que é a classificação esperada quando se trabalha com datas.
No próximo slide, vamos entender como realizar esse processo.
Para realizarmos essa transformação do tipo da coluna de objeto para datetime, iremos usar o método:
pd.to_datetime()
Este método se utiliza de 2 argumentos. O primeiro a coluna que será modificada e o segundo o formato que será utilizado na transformação.
Perceba que ao realizarmos essa transformação, perceba que a coluna data da Venda que antes estava caracterizada como object agora está caracterizada com o datetime64[ns]. Essa transformação, apesar de não alterar “esteticamente” o que temos na tabela, nos permite gerar informações que envolvem datas de forma mais simples. E isso é o que veremos no próximo slide.
Vamos pegar o nosso dataframe novamente:
import pandas as pd
#importando os arquivos
vendas_df = pd.read_csv(r'Contoso - Vendas - 2017.csv', sep=';')
produtos_df = pd.read_csv(r'Contoso - Cadastro Produtos.csv', sep=';')
lojas_df = pd.read_csv(r'Contoso - Lojas.csv', sep=';')
clientes_df = pd.read_csv(r'Contoso - Clientes.csv', sep=';')
#limpando apenas as colunas que queremos
clientes_df = clientes_df[['ID Cliente', 'E-mail']]
produtos_df = produtos_df[['ID Produto', 'Nome do Produto']]
lojas_df = lojas_df[['ID Loja', 'Nome da Loja']]
#mesclando e renomeando os dataframes
vendas_df = vendas_df.merge(produtos_df, on='ID Produto')
vendas_df = vendas_df.merge(lojas_df, on='ID Loja')
vendas_df = vendas_df.merge(clientes_df, on='ID Cliente').rename(columns={'E-mail': 'E-mail do Cliente'})
display(vendas_df)
_________________________
vendas_df.info()
______________________
<class 'pandas.core.frame.DataFrame'>
Int64Index: 980642 entries, 0 to 980641
Data columns (total 13 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Numero da Venda 980642 non-null int64
1 Data da Venda 980642 non-null object
2 Data do Envio 980642 non-null object
3 ID Canal 980642 non-null int64
4 ID Loja 980642 non-null int64
5 ID Produto 980642 non-null int64
6 ID Promocao 980642 non-null int64
7 ID Cliente 980642 non-null int64
8 Quantidade Vendida 980642 non-null int64
9 Quantidade Devolvida 980642 non-null int64
10 Nome do Produto 980642 non-null object
11 Nome da Loja 980642 non-null object
12 E-mail do Cliente 980642 non-null object
dtypes: int64(8), object(5)
memory usage: 104.7+ MB
Tendo uma coluna formatada como datetime, podemos usar métodos específicos deste tipo. Isso nos permite coletar informações de forma simples e direta.
Veja o exemplo ao lado. Aqui utilizamos 2 novos conceitos juntos:
1) Adicionar colunas a um dataframe;
2) Métodos .dt específicos para tipo datetime;
Para o primeiro conceito perceba que apenas colocamos o nome da coluna que queremos criar dentro do [ ] de vendas_df. A lógica utilizada aqui é a seguinte:
• A coluna existe em vendas_df?
• Se sim, faremos a ação na coluna existente;
• Se não, criaremos uma nova coluna que será adicionada após da última coluna existente.
Para o segundo conceito, usaremos a estrutura .dt.XXX para extrairmos do dado a informação desejada
vendas_df['Data da Venda'] = pd.to_datetime(vendas_df['Data da Venda'], format='%d/%m/%Y')
vendas_df['Ano da Venda'] = vendas_df['Data da Venda'].dt.year
vendas_df['Mes da Venda'] = vendas_df['Data da Venda'].dt.month
vendas_df['Dia da Venda'] = vendas_df['Data da Venda'].dt.day
display(vendas_df)
vendas_df.info()
______________________
Novas colunas criadas
• .dt.year → extrai o ano da coluna ‘Data da Venda’;
• .dt.month → extrai o mês da coluna ‘Data da Venda’;
• .dt.day → extrai o dia da coluna ‘Data da Venda’;
– Modificando e Consultando Valores DF
Utilizando nosso vendas_df vamos entender como acessar e modificar os valores deste dataframe. Para acessar esses dados usaremos dois métodos do pandas chamados:
.loc[ ]
.iloc[ ]
Essencialmente eles possuem a mesma função, mas a forma de indicação do dado é distinta. O loc pode se utilizar de strings para a “busca”, enquanto o iloc apenas se utiliza de valores de posição.
A imagem ao lado nos mostra o uso do .LOC. Perceba, que antes de utilizarmos este método, nós utilizamos outro método .set_index() que nos permite indicar qual coluna será utilizada como Índice.
novo_produtos_df = novo_produtos_df.set_index('Nome do Produto')
display(novo_produtos_df.head())
______________________
.set_index() Estabelece que essa coluna será a referência para o uso do .loc[ ]
O mesmo processo é utilizado no caso do .ILOC [ ]. No entanto, nesse caso não usaremos o “Nome do Produto” como ÍNDICE e sim seu ÍNDICE no Dataframe.
A T E N Ç Ã O !
Lembre-se que assim como nas listas, os índices se iniciam no valor 0 (ZERO). Portanto, se quisermos o produto da 3ª linha, usaremos o índice 2.
No caso da coluna usaremos o mesmo princípio, mas vamos considerar que a coluna com ÍNDICE 0 será a seguinte a coluna definida como INDEX pelo método set_Index. Como Nome do produto é a coluna escolhida, “Descrição do produto” será 0 e “Preço Unitário” a posição 5. Conforme apresentado na imagem ao lado.
.set_index() Estabelece que essa coluna será a referência para o uso do .iloc[ ]
#vamos pegar o preço produto Contoso Optical Wheel OEM PS/2 Mouse E60 Black
#por loc
print(novo_produtos_df.loc['Contoso Optical Wheel OEM PS/2 Mouse E60 Black', 'Preco Unitario'])
#por iloc
print(novo_produtos_df.iloc[2, 5])
_______________
13
13
Sabendo dessas duas formas vamos entender como modificar um valor do nosso df.
Vamos dizer que o que nos interessa é alterar o preço do produto ID873 ( Contoso Wireless Laser Mouse E50 Grey) para 23.
Na figura ao lado faremos essa alteração utilizando o .loc[ ], visto que sabemos qual o nome exato do produto, mas não sabemos qual a sua posição exata.
Antes:
Depois:
#novo_produtos_df.loc['Contoso Wireless Laser Mouse E50 Grey', 'Preco Unitario'] = 23
novo_produtos_df.loc[novo_produtos_df['ID Produto'] == 873, 'Preco Unitario'] = 23
display(novo_produtos_df.head())
_________________
– Exportando para .CSV
Já aprendemos como buscar arquivos .CSV do nosso computador, tratá-los no PANDAS, mas é possível criar um arquivo .CSV com os dados modificados ?
Como quase tudo no Python, SIM, é possível! Para isso, usaremos o método abaixo:
.to_csv().
Assim como apresentado ao lado, é bem simples realizar essa exportação. Nesse exemplo específico, estamos criando este arquivo .CSV na mesma pasta onde temos o nosso arquivo do Jupyter.
vendas_df.to_csv(r'Novo Vendas 2017.csv', sep=';')
• vendas_df Dataframe que será exportado.
• to_csv Método .to_csv indicando que vendas_df será exportado para um arquivo .csv
• r Indica que se trata de uma raw string, ou seja, não possui caracteres especiais como ‘\n’ por exemplo
• 'Novo Vendas 2017.csv' Indica o nome do arquivo a ser criado.
• sep=';' Indica que as colunas serão separadas com ‘;’ no nosso arquivo .CSV
Vamos imaginar agora que temos um dicionário e que temos interesse em transforma-lo em um arquivo .CSV. Um caminho possível é transformá-lo em um dataframe e posteriormente através do método .to_csv realizarmos a exportação. Para transformarmos um dicionário em dataframe, usaremos o método .from_dict() (doc).
Vamos dar uma olhada no código abaixo:
vendas_produtos = {'iphone': [558147, 951642], 'galaxy': [712350, 244295], 'ipad': [573823, 26964], 'tv': [405252, 787604], 'máquina de café': [718654, 867660], 'kindle': [531580, 78830], 'geladeira': [973139, 710331], 'adega': [892292, 646016], 'notebook dell': [422760, 694913], 'notebook hp': [154753, 539704], 'notebook asus': [887061, 324831], 'microsoft surface': [438508, 667179], 'webcam': [237467, 295633], 'caixa de som': [489705, 725316], 'microfone': [328311, 644622], 'câmera canon': [591120, 994303]}
vendas_produtos_df = pd.DataFrame.from_dict(vendas_produtos, orient='index')
• Transforma
um dicionário
em dataframe.
• Indica qual o dicionário será convertido.
• Indica o que serão as CHAVES. Neste caso serão LINHAS.
No entanto, apesar de termos transformado nosso dicionário em um dataframe, as colunas ainda não são intuitivas. Sendo apresentadas com os valores 0 e 1.
Vamos tratá-las usando um método já conhecido, o .rename() e aí sim vamos exporta-lo para um arquivo .csv.
vendas_produtos_df = pd.DataFrame.from_dict(vendas_produtos, orient='index')
vendas_produtos_df = vendas_produtos_df.rename(columns={0: 'Vendas 2019', 1: 'Vendas 2020'})
vendas_produtos_df.to_csv(r'Novo Vendas Produtos.csv', sep=',', encoding='latin1')
– Lendo um csv diretamente da internet
Saindo do nosso próprio PC, vamos aprender como interagir com arquivos .csv existentes na internet. O primeiro caso é apresentado ao lado. Nesse caso, temos um link que se parece como um link qualquer de internet, mas na realidade ele não abre uma página, mas sim baixa um arquivo. Perceba por exemplo o fim do link onde temos =download.
Nesse caso, usaremos o mesmo princípio utilizado anteriormente com o read_csv(). A única diferença é que ao invés de utilizarmos um caminho do nosso computador, usaremos um caminho “externo”.
Criei um arquivo csv e disponibilizei o link para download no Drive: https://drive.google.com/uc?authuser=0&id=1Ru7s-x3YJuStZK1mqr_qNqiHVvdHUN66&export=download
=download Link não associado a uma página, mas sim a um download.
import pandas as pd
url = 'https://drive.google.com/uc?authuser=0&id=1Ru7s-x3YJuStZK1mqr_qNqiHVvdHUN66&export=download'
cotacao_df = pd.read_csv(url)
display(cotacao_df)
_________________________
No segundo caso, o nosso link de download não é tão direto quanto o anterior.
Vamos usar o link abaixo como exemplo:
Se usarmos este link, teremos um HTTPERROR que essencialmente é um erro que nos informa que não conseguimos estabelecer uma conexão com a página desejada.
Por isso, vamos precisar tratar esse link antes de importá-lo.
Para isso usaremos novas bibliotecas: a IO e REQUEST
Com o código ao lado (não vale tanto a pena decorá-lo) e sim entende-lo. Basicamente, sempre que tiver interesse nessa operação poderá usar 90% deste código, só alterando o que for particular.
import pandas as pd
import requests
import io
url = 'http://portalweb.cooxupe.com.br:8080/portal/precohistoricocafe_2.jsp?d-3496238-e=2&6578706f7274=1'
conteudo_url = requests.get(url).content
arquivo = io.StringIO(conteudo_url.decode('latin1'))
cafe_df = pd.read_csv(arquivo, sep=r'\t', engine='python')
display(cafe_df)
• Busca (.get) o conteúdo (.content) do link url
• StringIO decodifica (.decode) o conteúdo gerado na linha anterior
• Busca os dados decodificados da linha anterior e cria um arquivo .csv com separador
‘\t’
– Obs: Integração de Python com Excel - Pandas ou openpyxl
Nesta aula veremos como integrar o Python com o Excel. Existem 2 formas principais e muito utilizadas para fazer isso: Pandas e Openpyxl. Com essas 2 formas, você poderá resolver a maioria dos problemas envolvendo integração com o Excel.
Pandas
• Mais usada no geral
• Trata o Excel como uma base de dados
• Faz o que quiser com o arquivo
• Pode desafazer a estrutura original do arquivo, caso queira editar
Openpyxl
• Trata o excel como uma planilha, mesmo que essa planilha tenha vários elementos
• Edita “como se fosse um VBA”
• Menos eficiente
• Mantém mais a estrutura original do arquivo, mas cuidado porque não necessariamente tudo
Agora vamos resolver um desafio usando as 2 formas de integração com o Excel. Temos uma planilha de produtos e serviços. Com o aumento de imposto sobre os serviços, teremos que atualizar o preço dos produtos impactados pela mudança.
Desafio
Novo multiplicador Imposto Serviços: 1.5
Nosso objetivo é utilizar as 2 formas de integração (Pandas e Openpyxl) para importar a planilha e modificar o multiplicador de imposto, cujo tipo seja serviço. Nesse caso, teremos que modificar os multiplicadores de 1.3 para 1.5 nas células D3, D5, D7 e D8.
É importante ressaltar que como estamos usando o Jupyter, as ferramentas Pandas e Openpyxl vêm instaladas. Mas se você estiver usando pycharm, vscode ou outra ferramenta, você terá que instalar o Pandas e o Openpyxl. Mas é recomendado que
você utilize o Jupyter, pois ele é a melhor ferramenta para trabalhar com análise de dados e com o Pandas.
• Usando o Pandas
Vamos começar resolvendo o desafio pelo Pandas.
# pandas
import pandas as pd
tabela = pd.read_excel("Produtos.xlsx")
display(tabela)
______________________
O que precisamos fazer agora é atualizar os valores do multiplicador nas linhas em que o tipo é serviço. Como o Pandas não puxa as
fórmulas do Excel, então além de atualizar esses valores, precisamos fazer o cálculo de Preço Base Reais com os novos valores.
# atualizar o multiplicador
tabela.loc[tabela["Tipo"]=="Serviço", "Multiplicador Imposto"] = 1.5
# fazer a conta do Preço Base Reais
tabela["Preço Base Reais"] = tabela["Multiplicador Imposto"] * tabela["Preço Base Original"]
tabela.to_excel("ProdutosPandas.xlsx")
Arquivo ProdutosPandas.xlsx
Para que o Pandas não salve o arquivo Excel com a coluna de índice, devemos acrescentar o argumento index=False, como na imagem abaixo.
tabela.to_excel("ProdutosPandas.xlsx",index=False)
Pronto! Agora o arquivo ProdutosPandas.xlsx está sem a coluna de índice.
• Usando o Openpyxl
Vamos agora resolver o desafio com o Openpyxl.
# openpyxl
from openpyxl import Workbook, load_workbook
planilha = load_workbook("Produtos.xlsx")
aba_ativa = planilha.active
for celula in aba_ativa["C"]:
if celula.value == "Serviço":
linha = celula.row
aba_ativa[f"D{linha}"] = 1.5
planilha.save("ProdutosOpenPy.xlsx")
• Importando do Openpyxl somente os métodos Workbook e load_workbook, e não a biblioteca inteira.
• O arquivo Excel está na mesma pasta do código.
• Quando rodamos planilha.active, ele nos dá a aba ativa do nosso arquivo, que é a aba que aparece ativa quando abrimos o arquivo Excel. Nesse caso, temos só 1 aba no nosso arquivo.
• For percorre todas as linhas que estão preenchidas da Coluna C (“Tipo”) e verifica se o valor de cada célula é igual a “Serviço”. Se for igual a “Serviço”, armazena o valor desta
linha na variável linha e modifica o valor da célula de mesmo valor de linha na Coluna D (“Multiplicador Imposto”) para 1.5.
• O f antes do texto torna esse texto uma f-string, uma string que pode ser formatada com variáveis (nesse caso, pela variável linha). Por exemplo, se o valor de linha for 5, então ficará aba_ativa[“D5”] = 1.5. Isso significa que a célula de coluna “D” e linha 5 receberá o valor 1.5.
• Salvando o arquivo com nome diferente do arquivo Original para as alterações não serem feitas no arquivo principal.
Arquivo ProdutosOpenPy.xlsx
Nesse caso, não precisamos editar a coluna “Preço Base Reais” porque as fórmulas nas células se mantiveram e o cálculo com os novos valores foi feito automaticamente. O gráfico também se manteve, como podemos visualizar na imagem acima.
No Pandas, essas fórmulas e gráficos não se mantiveram, porque enquanto o Openpyxl enxerga a planilha do Excel como uma planilha, o Pandas a enxerga apenas como uma base de dados.
Então essas são as 2 formas que você tem para integrar o Python com o Excel e dependendo da sua aplicação, uma forma pode ser melhor do que a outra.
– Criando barra de progresso em Python - tqdm
Uma dúvida comum principalmente quando estamos trabalhando com bases muito grandes é: “Tá demorando, será que travou?” O Pandas nos permite criar uma barra de progresso para acalmarmos nossa ansiedade.
Para criarmos a barra de progresso usaremos a biblioteca tqdm (doc) conforme apresentado ao lado.
Para nosso exemplo, o tamanho da barra de progresso será o tamanho proporcional ao tamanho da coluna ID LOJA do nosso dataframe vendas_df.
Além do tqdm, também usaremos o método .update para atualizar esta barra de acordo com seu progresso.
from tqdm import tqdm
pbar = tqdm(total=len(vendas_df['ID Loja']), position=0, leave=True)
for i, id_loja in enumerate(vendas_df['ID Loja']):
pbar.update()
if id_loja == 222:
vendas_df.loc[i, 'Quantidade Devolvida'] += 1
display(vendas_df)
_______________________
100%|██████████████████████████████████████████████████████████████████████▋| 976688/980642 [00:16<00:00, 72815.83it/s]
Nenhum comentário:
Postar um comentário