Como ler banco de dados gigantes, considerados BigData com Python? Vamos aprender 2 formas diferentes de fazer essa leitura hoje!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Fala Impressionadores! Hoje eu quero falar sobre como trabalhar com bases gigantes no Pandas, ou o famoso BigData com Python!
Em alguns casos nós vamos ter que trabalhar com bases de dados muito grandes e isso pode ser um problema já na hora de ler as informações.
Como são muitas informações é possível que o seu sistema já nem consiga ler toda a base de dados, imagine processar tudo o que precisa com essas informações.
Por esse motivo eu quero te mostrar como trabalhar com BigData no Python para que você saiba o que fazer quando tiver uma base muito grande e o seu sistema não suportar.
É possível tentar ler a base de dados direta no Python, mas se isso consumir demais do seu computador ou do seu sistema, você pode ler base de dados em partes no Python.
Isso quer dizer que vamos criar um for (estrutura de repetição) para ler pedaços do código e executar uma tarefa só com essa parte. Depois vamos repetir para toda a base de dados.
Esse processo acaba demorando muito mais e fica um pouco mais complexo, mas não consome tanto do seu sistema!
Dito isso, vamos para a aula! – BigData com Python
O que consideramos efetivamente como Big Data?
Essencialmente é o volume de dados, o volume de informações que vai trazer essa diferença entre você fazer uma análise de dados normal ou começar a trabalhar com Big Data.
Então não existe uma categoria expressa em que alguém disse, a partir de tanto, começa a ser considerado Big Data.
Qual é o desafio?
Nesse exemplo que vamos fazer hoje, temos uma base de dados chamada large.csv que é uma base de 17 GB, esta base de dados está disponível no material didático desta aula.
Quando você começa a entrar nesse nível de GB de informações as suas bases de dados começam a ficar muito pesadas, você vai começar a encontrar alguns problemas.
Vamos primeiro importar essa base de dados para dentro do Python e exibi-la.
Normalmente vamos fazer isso importando o Pandas.
import pandas as pd
tabela = pd.read_csv("large.csv")
display(tabela)Quando rodarmos este código ele até consegue ler a base de dados, mas devido ao tamanho da base isso vai demorar muito.
Outro ponto, é que o código está tentando ler toda a base de uma única vez, pode ser que o seu computador não tenha memória o suficiente para suportar essa leitura, então, vamos pausar a leitura e tratar de outra forma.
Obs. Para pausar você pode clicar no stop várias vezes sou clicar no Kernel e clicar em Restart & Clear Output.
1ª Forma de Ler o Código
Uma dica importante é que você pode construir a sua estrutura de código inteira, apenas com um pedaço da base de dados usando o nrows.
import pandas as Pd
tabela = pd.read_csv("large.csv, nrows=10000")
display(tabela)Dessa forma ele vai ler a base de dados somente até a linha dez mil e ignorar o restante. Isso é bom porque dez mil é um valor grande o suficiente para que você faça uma análise, mas pequeno o bastante para não travar seu computador.
Após rodar o código você só precisa apagar o nrows=10000 e ler a base de dados inteira.
2ª Forma de Ler o Código
A segunda forma de ler a base de dados é por partes, separamos em partes e lemos uma de cada vez, vamos criar essa estrutura dentro do For e utilizar o chunksize, para dividir a cada dez mil linhas até finalizar a base.
Digamos que precisamos calcular o valor recebido e o valor pago de todas as moedas que temos na base de dados.
Como vamos fazer isso?
For chunk in pd.read_csv(“large.csv”, chunksize=10000)
Colunas = [“Amount Received”, “Receiving Currency”, “Amount Paid”]
Chunk_filtrado = chunk[colunas]
//Esta primeira parte do código nada mais é do que a tabela -> chunk somente com as 3 colunas que selecionamos -> Amount Received, Receiving Currency e Amount Paid
//Após reduzir a tabela, precisamos agrupar os valores das colunas por moeda, para isso vamos criar uma variável que vai receber o total de moedas e vamos usar o SUM para somar os valores numéricos.
resumo = chunk_filtrado.groupby(“Receiving Currency”).sum()
display(resumo)
break
//Como este código terá que rodar para toda a base, isso vai demorar, então podemos colocar um break para interromper na primeira leitura e assim observar o resultado, depois é só retirar o break.Observe que o código está muito eficiente e rápido, e como parou na primeira leitura podemos aproveitar para ajustar a formatação:
pd.options.display.float_format = “{:,.2f}”.format
For chunk in pd.read_csv(“large.csv”, chunksize=10000)
Colunas = [“Amount Received”, “Receiving Currency”, “Amount Paid”]
Chunk_filtrado = chunk[colunas]
resumo = chunk_filtrado.groupby(“Receiving Currency”).sum()
display(resumo)
break
Agora que já temos os valores formatados, temos que observar mais uma questão que pode gerar um problema na análise do resultado.
Como estamos analisando por partes a cada dez mil linhas, no final, quando o código rodar por completo, teremos vários blocos de resultado.
Vários blocos como este impresso acima, então, se você quiser analisar o valor total da base de dados em Euro, por exemplo, terá que antes fazer um código para juntar esses resultados.
Como somar os resultados?
O primeiro passo é retirar o nome das moedas do índice, veja que no resultado os nomes das moedas estão como índice na primeira coluna, isso vai nos atrapalhar a juntar, vamos utilizar o as_index=False para impedir que as moedas se tornem índices.
pd.options.display.float_format = “{:,.2f}”.format
For chunk in pd.read_csv(“large.csv”, chunksize=10000)
Colunas = [“Amount Received”, “Receiving Currency”, “Amount Paid”]
Chunk_filtrado = chunk[colunas]
resumo = chunk_filtrado.groupby(“Receiving Currency”, as_index=False).sum()
display(resumo)
break
A segunda coisa que vamos fazer é criar uma tabela vazia, assim ao invés de exibir a tabela resumo vamos adicionar os resultados nesta tabela vazia.
pd.options.display.float_format = “{:,.2f}”.format
contador = 0
For chunk in pd.read_csv(“large.csv”, chunksize=10000)
Colunas = [“Amount Received”, “Receiving Currency”, “Amount Paid”]
Chunk_filtrado = chunk[colunas]
resumo = chunk_filtrado.groupby(“Receiving Currency”, as_index=False).sum()
tabela = pd.concat([tabela, resumo] )
contador += 1
if contador > 2:
break
display (tabela)Feito isso todos os resultados estão sendo guardados na variável formando uma única tabela, porém, a cada vez que um resultado é gerado as moedas se repetem e vamos ter novamente que somar esses valores repetidos.
pd.options.display.float_format = “{:,.2f}”.format
contador = 0
For chunk in pd.read_csv(“large.csv”, chunksize=10000)
Colunas = [“Amount Received”, “Receiving Currency”, “Amount Paid”]
Chunk_filtrado = chunk[colunas]
resumo = chunk_filtrado.groupby(“Receiving Currency”, as_index=False).sum()
tabela = pd.concat([tabela, resumo] )
contador += 1
if contador > 2:
break
tabela = tabela.groupby(“Receiving Currency”, as_index=False).sum()
display (tabela)Esta questão de ter que somar as moedas duas vezes deixa o código um pouco repetitivo, você pode se perguntar se vale a pena fazer isso, mas a questão é que podemos fazer com menos linhas de código como no primeiro exemplo, mas isso vai custar mais processamento do computador.
Na verdade, é mais uma questão de equilíbrio, você deve ajustar conforme as suas possibilidades.
Se rodarmos o código agora ele já vai mostrar os valores somados de cada moeda apenas uma vez.
Após conferir que o resultado está correto, podemos retirar do código o contador que colocamos, o if e o break, assim o código está pronto para rodar toda a base de dados.
pd.options.display.float_format = “{:,.2f}”.format
For chunk in pd.read_csv(“large.csv”, chunksize=10000)
Colunas = [“Amount Received”, “Receiving Currency”, “Amount Paid”]
Chunk_filtrado = chunk[colunas]
resumo = chunk_filtrado.groupby(“Receiving Currency”, as_index=False).sum()
tabela = pd.concat([tabela, resumo] )
tabela = tabela.groupby(“Receiving Currency”, as_index=False).sum()
display (tabela)Nesta aula mostrei duas formas de rodar uma base de dados considerada uma BigData, essas bases muito grandes geram um consumo alto da memória do computador, por isso precisamos saber modos diferentes de fazer essa leitura, adequando o código a realidade do nosso computador ou do computador da empresa.
A primeira forma de ler esta base é com um código mais curto que consegue ler a base de dados, porém, consumindo mais a memória do seu computador.
A segunda opção que eu trouxe é um código maior e mais complexo, mas que consegue partir o código em blocos menores e permite economizar a memória e poupar o seu computador.
Eu fico por aqui! Até a próxima! Um abraço,
Para acessar outras publicações de Python, clique aqui!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.