Pipeline de dados: combinando Python e orientação a objeto

Desenvolvimento do projeto - Apresentação

Você já construiu um pipeline de dados utilizando apenas a linguagem Python?

Sou Igor Nascimento Alves e serei o seu instrutor no curso Pipeline de Dados: Combinando Python e orientação a objeto.

Audiodescrição: Igor é um homem de pele clara, cabelo curto preto, barba rala, usando uma camiseta preta e fones de ouvido intraauriculares. No cenário, podemos encontrar do lado direito uma luminária azul e uma miniatura do Harry Potter. Do lado esquerdo, uma bandeira azul com o brasão da Corvinal, também do universo Harry Potter.

O intuito deste curso é que possamos conhecer os principais fundamentos da engenharia de dados. Vamos fazer isso através da construção de um pipeline de dados. Este pipeline cuidará da etapa de extração, transformação e carregamento de dados. Também precisaremos criar um pipeline que seja reutilizável para outras situações.

Neste curso, não iremos explorar as principais ferramentas de Big Data. Embora sejam muito importantes, acreditamos que é ainda mais crucial que você consiga construir um sólido fundamento antes de passar para essas ferramentas mais robustas.

Dessa forma, entender o fundamento da engenharia de dados, o porquê de certas ferramentas tomarem certas decisões e todas as etapas que envolvem o pipeline de dados é extremamente importante.

Neste curso, iremos desenvolver lógica de programação e reforçar conceitos dessa lógica, mas o nosso foco principal é apresentar a engenharia de software aplicada no universo da engenharia de dados.

Vamos também construir usando a orientação a objeto. Por isso, vamos usar esse paradigma da programação para criar nossas soluções. É muito importante que você já tenha tido contato com lógica de programação antes deste curso. Mesmo que reforcemos esses conceitos, esperamos que você já tenha tido contato com laços de repetição, como o FOR, ou condicionais, como o IF.

Agora que compreendemos o que vamos aprender, vamos pensar no projeto que iremos desenvolver. Trata-se da fusão de duas grandes empresas. Essas duas empresas se fundiram e possuem bases de dados diferentes. Ou seja, temos dados vindos de origens diferentes e que podem ter estruturas diferentes.

Elas precisam gerar um relatório para entender os resultados dessa fusão. As vendas aumentaram, diminuíram ou estão concentradas na empresa A ou na empresa B? Para ter todos esses insights (perspectivas), a equipe de BI, a equipe de Analytics, precisa desses dados.

Por essa razão, foi criada uma equipe de pessoas desenvolvedaoras de dados, responsáveis por pegar as duas fontes de dados, fazer as transformações necessárias e disponibilizar esses dados. Mas não só isso, precisamos construir um pipeline que possamos reproduzir nos meses seguintes, quando essa demanda reaparecer.

Através desse projeto, vamos conhecer todos os fundamentos da engenharia de dados. Estou muito animado para desenvolver esse projeto junto com você. Então, vamos lá?

Desenvolvimento do projeto - Iniciando o projeto

Olá! Nós somos o time de pessoas Engenheiras de Dados responsável por lidar com os dados da fusão de duas grandes empresas do varejo, que vendem vários tipos de produtos como miojo, sabão em pó, dentre outros.

Essas duas grandes empresas se uniram, passando a fazer parte da mesma liderança. A fusão ocorreu há um mês e elas precisam entender como foi o impacto dessa mudança nas vendas. Então, precisam reunir os dados tanto da Empresa A quanto da Empresa B e combiná-los.

Vamos unir esses dados para fornecer ao time de Analytics e ao time de Business Intelligence (BI), os quais vão construir relatórios para a liderança monitorar. Desejamos gerar insights sobre o total de vendas de produtos de determinada categoria no último mês, o que é muito importante para a liderança.

Nosso papel como pessoas engenheiras de dados é coletar os dados das duas empresas, combiná-los e realizar as transformações necessárias para que sejam compatíveis.

Como estamos lidando com duas empresas diferentes, teremos que trabalhar com diferenças nos nomes dos campos, na quantidade de colunas e em muitos outros aspectos. Nossa responsabilidade é lidar com essas diferenças, consolidar todas essas informações em um único arquivo e fornecer a solução para o time de Analytics.

Outro ponto importante é que essa demanda será recorrente. Nos próximos meses, será necessário repetir a fusão desses dois arquivos e disponibilizá-los. Por isso, ao construirmos essa solução, precisamos levar em consideração que ela deve ser reprodutível para os outros meses.

Quais ambientes podemos usar para este projeto?

Estou muito animado para montar esse projeto com você, mas nosso primeiro passo é criar esse ambiente. Nossa equipe conta com várias pessoas trabalhando nesse projeto e precisamos criar um ambiente que seja igual para todas. Existem diferentes maneiras de atingir esse objetivo.

Vamos optar por um ambiente que nos permita conhecer várias ferramentas: o Linux. Para isso, vamos usar o Windows Subsystem for Linux (WSL), que é uma máquina virtual onde conseguimos utilizar a distribuição do sistema operacional Linux no nosso sistema Windows.

Se você possui uma máquina com Windows, poderá usar esse sistema operacional. Se você não tem acesso ao WSL, mas possui um Linux, pode trabalhar no projeto diretamente no Linux. No entanto, se não tem acesso a uma máquina Linux e não quer ou não pode instalar o WSL, pode usar o Google Colab, que é uma solução na nuvem bastante prática.

O Colab permitirá que você execute a maioria das etapas do projeto. Contudo, algumas etapas, como a construção da estrutura do nosso projeto, que é o que faremos agora, não serão possíveis de serem realizadas lá. Ainda assim, vale a pena testar os comandos que usaremos aqui no Colab, já que ele roda uma máquina Linux por trás.

Se você consegue acompanhar o passo a passo comigo, eu sugiro que execute a atividade de preparação do ambiente e crie esse ambiente Linux na sua máquina. Nesse caso, instale o WSL.

Vamos partir do princípio que você já instalou o WSL, e vamos começar a montar a estrutura desse projeto que precisa ser reprodutível para todas as pessoas da equipe.

Vamos lá?

Iniciando a construção do ambiente

Nosso primeiro passo é abrir o WSL, que nos apresentará uma tela de terminal. Aqui, podemos utilizar alguns comandos Linux. Caso você não esteja familiarizado, não se preocupe. Vamos reforçar esses conceitos de comandos Linux com atividades e apresentá-los alguns. Por exemplo, o ls, um comando que mostra todas as pastas que temos no diretório em que estamos atualmente.

ls

Observem que nada foi exibido ao rodarmos o comando ls, isso acontece porque acabamos de criar o sistema operacional e não inserimos nada ainda.

Criando estrutura de pastas

Para começar o projeto, vamos criar algumas estruturas de pastas que serão a nossa estrutura do projeto. Para fazer isso, vamos digitar o comando mkdir, que é de criar um diretório ou pasta. Podemos chamar a nossa pasta de Documentos, por exemplo.

mkdir Documentos

Teclamos "Enter" e não obtivemos retorno. Mas ao repetirmos o comando ls, obtemos a pasta:

Documentos

Para acessá-la, utilizamos o comando cd (change directory) passando o nome da pasta.

cd Documentos

Dentro de Documentos, desejamos criar uma nova pasta que se relacione ao nosso projeto. Essa pasta será importante e desejamos que toda a equipe tenha essa mesma estrutura. Para ela, escolhemos o nome pipeline_dados e usamos o comando mkdir.

mkdir pipeline_dados

Teclamos "Enter" e nada retornará. Podemos usar o comando ls ou dir para visualizarmos a pasta.

dir

Obtemos dentro da pasta Documentos:

pipeline_dados

Para entrar nessa pasta, digitamos cd pipeline_dados.

cd pipeline_dados

Estamos agora dentro da pasta pipeline_dados.

Criando a pasta de dados brutos

Dentro do diretório pipeline_dados, vamos agora construir uma estrutura de pastas que faça sentido para a maioria dos projetos de Engenharia de Dados. Primeiro, precisamos de um local para guardar os dados brutos.

Para isso, vamos usar o comando mkdir novamente e criar a pasta data_raw, onde ficarão armazenados os dados na forma que eles vieram da origem, como uma espécie de backup.

mkdir data_raw

Ao usarmos o comando dir, obtemos a pasta data_raw.

Criando uma pasta para os dados transformados

Onde vamos salvar os dados depois que forem transformados? Podemos criar uma pasta para isso, chamada data_processed, onde ficarão os dados transformados e trabalhados.

mkdir data_processed

Dessa forma, temos duas pastas em nosso diretório que atende ao projeto. Quais são as outras etapas importantes?

Além disso, teremos a etapa de explorar os nossos dados e conhecê-los. Para isso, também precisamos de uma pasta, onde guardaremos o código que utilizaremos para essa exploração de dados. Costumamos fazer essa exploração de dados por meio de Jupyter Notebooks, que são ferramentas que nos permitem rodar tanto o código Python quanto gerar Markdowns.

Criando pasta de exploração de dados

Para conseguirmos organizar um documento que tenha código e descrição do que aquele código está fazendo, podemos criar uma pasta para nossos notebooks. Então digitaremos mkdir notebooks e apertamos "Enter".

mkdir notebooks

Criando pasta de scripts

A última pasta que pensamos em construir para nossa estrutura será a pasta de scripts. Mas por quê?

Depois que concluímos a etapa de exploração de nossos dados e definimos como queremos tratar e disponibilizar esses dados, vamos transformar toda essa lógica de Python (serpente) em um script. Com um único comando, podemos executar esse script e ele executará todo o processo.

Então, vamos criar uma pasta para nossos scripts digitando mkdir scripts, e apertamos "Enter".

mkdir scripts

Agora, podemos usar o comando ls e visualizamos nossas quatro pastas:

data_processed

data_raw

notebooks

scripts

Essas pastas formarão a estrutura do nosso projeto, composta por data_processed, data_raw, notebooks e scripts.

Inserindo informações na pasta data_raw

Agora, precisamos começar a alimentar essas pastas. Elas estão criadas, mas não têm nenhuma informação dentro delas. Como podemos preenchê-las? Vamos começar pelo data_raw.

Nossos dados estão disponíveis no GitHub. Terá um link nas atividades com o GitHub. Nele, teremos dois arquivos: um em JSON (javascript object notation) e um arquivo CSV (comma-separated values).

• dados_empresaA.json
• dados_empresaB.csv

Cada empresa, dada suas estruturas, determinou que seus dados seriam salvos em um formato. Então, a empresa A salva seus dados em JSON. Provavelmente, porque esses dados vêm de uma API (Application Programming Interface). Uma solução que você navega na internet e consegue extrair esses dados.

Então, o padrão é retornar esses arquivos em JSON. Já o arquivo CSV da empresa B, provavelmente vem de um banco de dados. Eles trabalharam com um banco de dados simples e exportaram esses dados desse mês em um formato CSV para nos fornecer.

Aqui, já conseguimos perceber uma diferença que talvez precisemos trabalhar. Esses dados estão estruturados e salvos de maneira diferente. Mas já nos preocupamos com isso. Primeiro, queremos fazer o download desses dados.

Como podemos fazer o download desses dados e trazê-los para nossa máquina WSL (Windows Subsystem for Linux)? Voltando ao nosso terminal, vamos rodar um comando para isso. Primeiro, precisamos entrar na pasta onde queremos salvar os dados. Então, vamos usar cd e procurar a pasta que queremos, que é a data_raw.

cd data_raw

Entramos na pasta. Aqui, nosso terminal já está bem poluído, difícil de visualizar. Podemos apertar no teclado "Ctrl + L" e ele limpará esse terminal. Na verdade, dará um scroll para baixo e fará sumir todas as informações que tínhamos.

Podemos usar o comando chamado wget. O comando wget do Linux é capaz de acessar uma requisição e fazer o download desses dados. Então, vamos passar o comando wget e a URL onde estão nossos dados.

wget https://github.com/alura-cursos/Pipeline-de-dados-combinando-Python-e-orientcao-a-objeto/blob/main/data_raw/dados_empresaA.json

Vamos copiar a URL onde está nosso arquivo e podemos fazer o comando download. Nossos arquivos não são tão grandes. Esse download será bem rápido. Podemos verificar se está tudo certo apertando o dir e visualizamos que dentro da nossa pasta, temos nosso arquivo JSON.

Ele está com um nome diferente, tipo dados_empresaA.json e tem um token grande. Deixaremos na atividade uma URL que não tem essa versão do token e aprenderemos a renomear esse arquivo para termos um nome mais simples e fácil de identificar.

Mas vamos focar agora no próximo arquivo. Fizemos o download do arquivo JSON da empresa A e agora desejamos o outro arquivo da empresa B, do tipo CSV. Para isso, vamos repetir o mesmo comando, wget, e colar nossa URL e apertar "Enter".

Novamente, ele fará o download bem rápido. Podemos apertar "Ctrl + L" para limpar o terminal, e dir para exibir os arquivos dentro de nosso terminal. Então, temos os dois arquivos, um JSON e um CSV.

• dados_empresaA.json
• dados_empresaB.csv

Com esses arquivos, populamos nossa primeira pasta da nossa estrutura.

Próximos Passos

Nosso próximo passo agora é explorar esses dados. Como podemos ler e conhecer que tipo de informação tem em nossos dados? Quais são as colunas, quantas linhas têm, e que ferramenta podemos utilizar para fazer essa exploração?

Já dei uma dica para você que será através do Jupyter Notebook. E é esse ambiente, esse local para utilizarmos o Jupyter Notebook que quero construir com você em breve.

Desenvolvimento do projeto - Conhecendo os dados

No projeto de pipeline de dados, já preparamos a estrutura de pastas. Portanto, temos uma estrutura que todas as pessoas da equipe vão ter igual.

Agora temos esse padrão, em que temos o pipeline de dados, temos uma pasta para os dados crus, uma pasta para os dados processados e uma pasta para os notebooks, que será a ferramenta que utilizaremos para explorar e conhecer esses dados e decidir que tipo de tratamentos eles precisam.

Conseguimos padronizar esta etapa de pastas, mas e o ambiente? Como faremos para que o Python que estamos rodando aqui na máquina tenha as mesmas ferramentas do nosso colega de trabalho? Essas ferramentas, além de instaladas, precisam estar nas mesmas versões, para terem os mesmos comportamentos.

Criando ambiente reprodutível

Precisamos criar um ambiente que seja reproduzível em todas as máquinas. Vamos focar nisso agora, para podermos explorar nossos dados. No Terminal, voltamos uma pasta. Para isso, podemos digitar o comando cd ...

cd ..

Ao pressionarmos "Enter", ele vai subir uma pasta. Estávamos na pasta Documentos, pipeline_dados, data_raw. Subimos uma. Agora estamos em Documentos, pipeline_dados. Esta é a pasta principal do nosso projeto e é nela que desejamos criar o ambiente virtual Python.

Esse ambiente virtual Python garante que conseguiremos isolar o Python do restante da máquina. Temos a versão global do Python na máquina, onde podemos fazer a instalação de diversos pacotes.

E teremos essa versão, onde determinamos quais pacotes vão ser instalados e em quais versões. Conseguimos isolar isso através de um ambiente virtual.

Criando o Ambiente Virtual na pasta pipeline_dados

Vamos construí-lo através de um comando, que é o Python. Chamar o próprio Python no terminal. No ambiente Linux, precisamos colocar a versão:python 3. Agora, vamos acessar o módulo que cria esse ambiente virtual.

Inserimos um espaço -m, para acessar um módulo específico do Python. Utilizaremos o módulo venv, que é o módulo responsável por criar ambientes virtuais. Então, venv, inserimos mais um espaço.

Agora, damos um nome para a pasta onde serão salvos os arquivos do nosso ambiente virtual. Por padrão, utilizamos o .venv. Por que ponto? No Linux, o ponto vai criar uma pasta oculta. Essa pasta não vai ficar visível pois não é interessante a gente manipulá-la.

É uma pasta do funcionamento do Python, então é mais interessante que ela seja oculta. E o nome venv é um nome padrão, mas podemos optar por outros nomes para esse ambiente virtual.

python3 -m venv .venv

Após pressionar "Enter", ele gera uma mensagem dizendo que precisamos instalar essa ferramenta. Se você fez a atividade preparatória do ambiente, provavelmente já resolveu esse problema.

Eu quis deixar essa mensagem aqui, porque é importante conhecermos. No nosso primeiro contato com o ambiente Linux, haverá muitas coisas que não estão instaladas. Ele tem o Python já instalado por padrão, mas precisamos nos preocupar com a versão do Python que estamos trabalhando e com a instalação inicial dos pacotes, como o venv que estamos tentando utilizar e o pip.

Comandos que garantem a instalação e atualização dos pacotes

Para isso, vamos rodar alguns comandos que garantem essa instalação. Eles estão bem descritos nas atividades. O primeiro comando que vamos rodar é o de atualização do sistema. sudo apt-get update.

sudo apt-get update

Será solicitado a senha que fizemos na hora que preparamos o ambiente Linux e será feita a instalação e atualização desses pacotes. Esse processo pode levar um tempo.

Depois da primeira atualização, podemos fazer o upgrade dos pacotes. Primeiro o download dos pacotes, depois a instalação deles. Então, colocaremos o comando sudo apt-get upgrade -y, onde o -y indica "yes" para confirmar a instalação.

sudo apt-get upgrade -y

Já conseguimos atualizar todos os pacotes no Linux e agora vamos checar a versão do nosso Python. Para isso, temos o comando python3 --version.

python3 --version

É indicado que estamos trabalhando com o Python 3.10.12. É importante ter essa mesma versão? Sim, pois as bibliotecas Python mudam com o tempo, então podem ter comandos que vão deixar de funcionar, dependendo do momento que você está fazendo esse projeto.

Voltando para a criação do ambiente

Com a versão verificada, agora podemos voltar ao nosso foco, que era criar um ambiente. Lembram que o comando de criar um ambiente não funcionou? Podemos pressionar a seta para cima no teclado para visualizar os comandos que já rodamos. Retornamos ao comando python3 -m venv .venv.

python3 -m venv .venv

Teclamos "Enter".

Não funcionou porque só atualizamos os pacotes do Linux. Agora precisamos instalar essa ferramenta, agora que o ambiente foi preparado. Ele indica qual comando temos que rodar: apt install python3.10-venv. Digitamos o comando sudo apt install python3-pip -y para confirmar a instalação. Será iniciado o processo de instalação da ferramenta.

sudo apt install python3-pip -y

Preparamos o ambiente do Linux e agora vamos focar na criação do venv. Necessitamos do pacote venv. Com a instalação terminada, temos acesso ao pip, que é a ferramenta do Python responsável por fazer o download de pacotes.

Estes pacotes são soluções, códigos Python que trazem simplicidade para trabalhar. Por exemplo, caso queiramos trabalhar com muitos dados, podemos fazer a instalação do pandas, que é uma ferramenta comum, através do pip.

Se desejamos trabalhar com visualizações, podemos instalar, através do pip, o matplotlib e assim por diante. Nosso interesse é criar um ambiente. Agora que já temos acesso ao pip, podemos fazer a instalação do venv. Novamente, o comando sudo apt install python3-venv -y.

E agora seguimos para a última instalação dos pacotes necessários para que o Python trabalhe e criemos nosso ambiente virtual. Essa instalação é rápida e agora podemos voltar usando a setinha para cima no teclado até python3 -m venv .venv.

python3 -m venv .venv

Pressionamos "Enter" vai fazer com que o processo leve um tempo, porque ele está criando toda a estrutura de pastas do Python, isolando um ambiente só para nós. Caso tente mostrar essa pasta com ls ou dir, ela não vai aparecer porque optamos por ela ser oculta, o .venv.

Ao estarmos trabalhando no VSCode, que é a ferramenta que utilizamos neste projeto, conseguimos visualizar essa pasta e explorar um pouco mais. Criamos o ambiente. Como podemos utilizar esse ambiente agora? Precisamos ativá-lo.

Ativando o Ambiente

O comando para ativar esse ambiente é source .venv/bin/activate. Esse é o comando para ativar o ambiente Python. Agora vamos deixar de usar o Python padrão da máquina e começar a utilizar esse que preparamos, que está novo, sem instalações de biblioteca, e podemos reproduzir este mesmo ambiente em outros projetos.

source .venv/bin/activate

Após pressionarmos "Enter", sabemos que o ambiente foi ativado quando, ao visualizarmos no lado esquerdo, ao lado do nome do nosso usuário, observamos .venv entre parênteses, que é o nome do seu ambiente virtual.

Exemplo com o usuário do instrutor:

(.venv) igor@PC:~/Documentos/pipeline_dados$

Agora que estamos dentro do ambiente, podemos começar a fazer as instalações das bibliotecas necessárias.

Instalando as Bibliotecas

Neste momento, vamos instalar o Jupyter Notebook para explorar nossos dados. Para isso, temos o comando do pip. Vamos utilizá-lo agora. pip install notebook ==7.0.3, nesta parte estamos especificando uma versão, ==7.0.3.

Dentro do contexto de criar projetos seguindo padrões de engenharia de software, é muito importante ter versionamento dos pacotes utilizados para garantir o funcionamento do projeto, independente do equipamento usado.

pip install notebook ==7.0.3

Então, instalamos uma versão específica do Jupyter Notebook. Durante a instalação, serão feitos downloads de vários pacotes pré-requisito. Assim que a instalação terminar, poderemos sair do ambiente do terminal Linux e partir para o VSCode.

VSCode

O VSCode é a ferramenta, a IDE e o editor de texto que vamos usar para manipular o nosso código, tanto de Jupyter Notebook quanto Scripts Python. Com a instalação concluída, podemos rodar o comando code .. Que é o comando responsável por abrir o VSCode na pasta atual.

code .

Gostaria de ressaltar a importância de visitar a atividade de preparação do ambiente onde ensinamos sobre a instalação do VSCode. Isso é relevante pois mesmo que já utilize o VSCode na sua máquina Windows, para ter acesso à máquina Linux que criamos, precisamos instalar alguns plugins de WSL.

No canto inferior esquerdo do VSCode vai aparecer a conexão "WSL: Ubuntu-22.04" se você seguiu as instruções corretamente. Caso encontre problemas, procure auxílio no fórum ou no Discord. Se tudo estiver certo, veremos no lado esquerdo a estrutura de pastas que criamos:

• PIPELINE_DADOS [WSL: UBUNTU-22.04]
  • .venv
  • data_processed
  • data_raw
  • notebooks
  • scripts

Para começar a exploração dos dados, pressionamos "Ctrl + J" para sumir o terminal e no canto esquerdo, no explorador, e clicamos em "notebooks". Não tem nada dentro da pasta, então podemos clicar com o botão direito e criar um novo arquivo. Esse arquivo pode ser nomeado como exploracao.ipynb.

É importante manter a extensão .ipynb para que o VSCode possa identificar que está trabalhando com Jupyter Notebook. Se estiver acostumado com o VSCode, saiba que ele sempre faz sugestões de plugins, de alterações. Siga o que achar melhor. No caso, clicamos em "Install".

Durante a exploração do Jupyter Notebook, se você estiver trabalhando com Colab, a interface será parecida. No canto superior esquerdo, temos a opção de criar um novo código, criar um Markdown, que é aquela célula de texto onde podemos destacar o que estamos fazendo nessa etapa.

Ao digitarmos "lendo os dados" na caixa de python e teclarmos "Shift + Enter", será exibido um menu flutuante com uma opção questionando se desejamos instalar ou habilitar as extensões sugeridas. Temos as instalações do Python e do Jupyter instaladas, importantes de serem feitas.

Com a instalação finalizada, podemos rodar essa célula.

Vamos verificar como está sendo feita a instalação dos plugins, focaremos no do Jupyter Notebook, porque o de Python já foi exibido na janela de extensões. Do lado esquerdo do VSCode, selecionamos o ícone de extensões (são os plugins criados para facilitar o nosso processo dentro do VSCode para trabalharmos com determinadas linguagens).

No campo de busca na parte superior, digitamos e buscamos por "Jupyter". Observem que apesar de termos o Jupyter instalado, temos uma mensagem questionando se desejamos realizar essa instalação no WSL na versão Linux. Selecionamos essa opção.

Com a instalação concluída, vamos rodar novamente a célula em markdown. Agora, sim, está sendo feita a pergunta que comentei: qual ambiente do Python desejamos utilizar? Isso na opção "Ambiente do Python…" na parte superior.

Desejamos usar o ambiente que criamos, então selecionamos "Ambiente do Python…" e escolhemos a opção ".venv (Python 3.10.12)". Assim, a célula de código é executada. Ao criarmos uma célula em markdown e digitarmos "Lendo os dados" e executarmos, obtemos o resultado desejado.

Temos o texto "Lendo os dados" informando o que essa etapa do Jupyter Notebook está fazendo e abaixo uma célula de código padrão, onde podemos digitar códigos em Python. Por exemplo, para fazer a conta 10+10, basta pressionar "Shift+Enter", e o Python executará a conta.

20

Para explorar nossos dados, vamos criar uma variável. Primeiro, queremos ler nossos dados em JSON. Então, vamos digitar path_json na célula de código, e indicar onde estão nossos dados. A partir da pasta notebook, precisamos subir uma pasta. Lembre-se que para retornar uma pasta usamos ...

path_json = ''../data_raw/'

Mas observem que está com aquele nome enorme.

Um detalhe importante é que caso os arquivos estejam com nomes complexos ou confusos, é possível renomeá-los. Para isso, basta clicar com o botão direito no arquivo, selecionar "renomear" e inserir o novo nome.

• dados_empresaA.json
• dados_empresaB.csv

Após feito isso, podemos voltar para o nosso Jupyter Notebook. Desejamos iniciar lendo os dados em json.

path_json = ''../data_raw/dados_empresaA.json'

Então, criamos uma variável para armazenar o caminho onde estão nossos dados. Agora, na próxima célula de código, desejo realizar a leitura desses dados. Vamos utilizar uma biblioteca padrão do Python, a open.

A open é capaz de abrir arquivos e nós podemos manipulá-los. Digitamos with open, que é a função que queremos usar. Com o open(), dentro do seu contexto, desejamos ler um arquivo. Onde está esse arquivo?

Na nossa variável path_json. O primeiro parâmetro que passamos é onde está esse arquivo. Já o segundo parâmetro é o modo de abertura desse arquivo. Estamos interessados em ler, não desejamos escrever nesse arquivo nem fazer transformações nele, apenas ler. Portanto, podemos colocar entre aspas, r de read (leitura).

Desejamos ler esse arquivo. Como vamos trabalhar esse arquivo? Qual é a variável que representará esse arquivo aqui para nós? Vamos digitar as, que será o apelido dessa variável, e usar file. Toda vez que quisermos acessar esse arquivo aberto do path_json, ele estará na variável file.

Podemos inserir os dois pontos e teclar "enter". Dentro desse contexto, desse dado, no escopo do with, podemos manipular esse file. Como podemos ler esse file? Vamos fazer o file, e ele tem algumas funções disponíveis.

A que estamos procurando é read (ler). Desejamos ler, portanto, digitamos read, as funções em Python sempre são em inglês, e estamos interessado em ler a linha. Para isso, usamos o readline.

Abrimos e fechamos parênteses. E essa função lerá esses dados para nós. Mas o que estamos fazendo com esses dados? Queremos ler esses dados e fazer o que com eles? Queremos exibi-los na tela. Portanto, digitamos print, e dentro do print passamos o file.readline.

with open(path_json, 'r') as file:
    print (file.readline())

Pressionamos "shift + enter" e ele realiza a leitura dos nossos dados.

O retorno abaixo foi parcialmente transcrito. Para conferi-lo na íntegra, execute o código na sua máquina.

{"Nome do Produto":"Blush em p\u00f3", "Categoria do Produto":"Eletrodom\u00e9s…

Notamos que é um JSON, pois temos as chaves, o nome da coluna aqui, temos o nome do produto e o que é esse produto, seguido de vírgula. Outra categoria, a categoria do produto, seria outra coluna.

Conclusão e Próximos Passos

Conseguimos ler, mas essa estrutura que o Python está usando para exibir esses dados para nós não está ideal. É nisso que precisamos focar agora, em como efetivamente ler e representar esses dados numa estrutura que seja possível manipular e entender muito bem o que representam.

Esse é o próximo passo que quero dar com você, então, vamos lá!

Sobre o curso Pipeline de dados: combinando Python e orientação a objeto

O curso Pipeline de dados: combinando Python e orientação a objeto possui 213 minutos de vídeos, em um total de 75 atividades. Gostou? Conheça nossos outros cursos de Engenharia de Dados em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Desenvolvimento do projeto
• Extraindo os dados
• Transformando os dados
• Salvando os dados
• Criando funções
• Criando classe