Olá, pessoal!
Após o comparativo entre Python e R, seguiremos nossos estudos de data science usando justamente Python. Neste artigo, abordaremos técnicas de importação de dados a partir de três formatos bastante populares.
É importante observar que muito embora Python ofereça simplicidade no tratamento dos principais formatos open data e também de muitos formatos proprietários, a importação de dados é para data science o início da codificação de nossos projetos. É essencial que você não menospreze essa etapa e inicie seu trabalho da forma mais otimizada possível.
Ao participar de projetos que utilizem pesquisas em fontes de dados abertas, comuns ao ambiente data science, vamos nos deparar com diversos formatos de fonte de informação. É razoável pensar que um projeto de ciência de dados via de regra nos obrigará a reunir uma miscelânea de fontes de dados de diferentes padrões em datasets estruturados e organizados. Felizmente, Python simplifica bastante esse trabalho ao oferecer bibliotecas e pacotes para tratamento facilitado de todos os principais formatos open data com os quais iremos nos deparar em nossos trabalhos.
Trataremos, nesta abordagem, dos seguintes padrões:
- Extensible Markup Language (XML)
- JavaScript Object Notation (JSON)
- Comma-Separated Values (CSV)
Esta lista não reflete, por óbvio, a totalidade dos formatos com os quais vamos nos deparar na prática. Trataremos em artigos vindouros acerca de dados estruturados em RDF (um padrão recomendado pelo W3C e muito defendido por Tim Berners-Lee), Excel, PDF, HTML, TXT, HTML e até mesmo informações extraídas a partir de determinados formatos de imagens. No entanto, XML, JSON e CSV representam um considerável volume de informações disponíveis para estruturarmos nossos datasets. É raro um projeto de data science não contemplar ao menos um destes três formatos.
Observaremos, neste artigo, a incrível facilidade e semelhança sintática presente nos scripts Python que tratam estes três padrões. Vamos lá!
Arquivos XML
O padrão XML foi, por muito tempo, dominante na Web quando pensávamos em serialização de dados. Com o tempo, novos padrões foram surgindo (o melhor exemplo disto talvez seja o próprio JSON, que veremos em seguida), e as discussões acerca de performance, facilidade de leitura e visualização de informações e rapidez de implementação foram ganhando maiores proporções.
Fato indiscutível é que o XML segue sendo um padrão forte no mercado. É bastante útil quando lidamos com bases de dados pequenas, médias e em atividades em que não podemos nos preocupar com uma retaguarda SQL bem estruturada.
Quando tratamos de parsing XML com Python, a primeira pergunta que temos que fazer é: qual biblioteca usaremos? Existem algumas boas opções. Vejamos:
- dom.* – Implementa W3C DOM API. Se trabalhar com o DOM API é uma exigência do seu projeto, essa é uma boa escolha. DOM (Document Object Model) é um padrão recomendado pelo W3C para implementações onde todo o arquivo é processado em memória e armazenado em uma estrutura hierárquica para representar os recursos de um documento XML. O pacote xml.dom possui muitas variações para questões como performance e facilidade de implementação.
- sax.* – Implementa SAX API (Simple API for XML). SAX permite que seja realizado um parsing sem a necessidade de implementação de um laço. A API permite que, durante a varredura do arquivo, eventos relevantes para nossa aplicação possam ser interceptados e tratados como quisermos. Isto é útil quando temos documentos XML grandes e/ou temos limitações de memória, pois o arquivo é lido a partir do disco e jamais armazenado integralmente em memória.
- parser.expat – Implementa uma API de baixo nível baseada em C. O algoritmo de parsing é semelhante a SAX. Por ser uma API baseada em C, possui melhor performance que SAX, ainda que sua implementação seja ligeiramente mais trabalhosa.
- etree.ElementTree – É a biblioteca que apresenta melhor custo x benefício no comparativo com as demais opções. Na comparação com DOM, ElementTree tem melhor performance e é mais simples para ser implementada. Comparada ao SAX, possui capacidade de parsing com leitura do arquivo em disco sem armazenamento integral em memória. Possui performance semelhante, porém com maior facilidade de implementação.
Vamos usar ElementTree para nosso primeiro hands-on de importação de dados. Sejamos o seguinte arquivo XML:
<campeonato> <equipe id="1"> <nome>Gremio</nome> <posicao>01</posicao> <descricao> Equipe de Porto Alegre </descricao> </equipe> <equipe id="2"> <nome>Real Madrid</nome> <posicao>02</posicao> <descricao> Equipe de Madrid </descricao> </equipe> <equipe id="3"> <nome>Barcelona</nome> <posicao>03</posicao> <descricao> Equipe de Barcelona </descricao> </equipe> </campeonato>
Vamos aplicar um parsing básico no arquivo usando ElementTree:
from xml.etree import ElementTree as et
# lemos o XML em disco
conteudo = et.parse("campeonato.xml")
# usamos .findall para retornar a lista de equipes
lista_equipes = conteudo.findall("equipe")
# contamos quantos registros temos em nosso arquivo
print("Equipes: ",len(lista_equipes))
# montamos o for para listar as equipes
for item in lista_equipes:
print("Nome: ",item.find("nome").text)
print("Posicao: ",item.find("posicao").text)
print("Descricao: ",item.find("descricao").text)
Usando et.fromstring(conteudo_xml) ao invés de et.parse(arquivo.xml) podemos ler o conteúdo XML sem leitura de arquivo em disco. Em alguns casos, essa abordagem pode ser mais interessante.
A implementação acima deve retornar:
('Equipes: ', 3)
('Nome: ', 'Gremio')
('Posicao: ', '01')
('Descricao: ', '\n\t\t\tEquipe de Porto Alegre\n\t\t')
('Nome: ', 'Real Madrid')
('Posicao: ', '02')
('Descricao: ', '\n\t\t\tEquipe de Madrid\n\t\t')
('Nome: ', 'Barcelona')
('Posicao: ', '03')
('Descricao: ', '\n\t\t\tEquipe de Barcelona\n\t\t')
Como podemos observar, o ElementTree transforma o parsing XML com Python em algo extremamente simples.
Arquivos JSON
JSON é um padrão de intercomunicação de dados de simples leitura e compreensão para máquinas e humanos. Possui uma sintaxe bastante familiar para quem tem experiência em Java, JavaScript, C, C++, C#, Perl e, claro, Python.
Vamos aplicar, como no XML, um parsing no arquivo .json e analisar as diferenças entre ambas as implementações. Sejamos o seguinte arquivo .json:
[
{
"id": 1,
"nome":"Gremio",
"posicao":01,
"descricao":"Equipe de Porto Alegre"
},
{
"id": 2,
"nome":"Real Madrid",
"posicao":02,
"descricao":"Equipe de Madri"
}
{
"id": 3,
"nome":"Barcelona",
"posicao":03,
"descricao":"Equipe de Barcelona"
}
]
Para processá-lo, aplicaremos o seguinte script:
import json
# lemos o JSON em disco
conteudo = open('campeonato.json').read()
lista_equipes = json.loads(conteudo)
# montamos o for para listar as equipes
for item in lista_equipes:
print item
Podemos aplicar algumas variações simples nesta implementação. Em casos práticos, muitas vezes é interessante receber os dados JSON como string, ao invés de processar o arquivo inteiro. Logo, teríamos:
conteudo = '[{"id": 1,"nome":"Gremio","posicao":30,"descricao":"Equipe de Porto Alegre"},{"id": 2,"nome":"Real Madrid","posicao":30,"descricao":"Equipe de Madri"}]'
lista_equipes = json.loads(conteudo)
Ambas as implementações nos retornam:
{u'posicao': 30, u'id': 1, u'descricao': u'Equipe de Porto Alegre', u'nome': u'Gremio'}
{u'posicao': 30, u'id': 2, u'descricao': u'Equipe de Madri', u'nome': u'Real Madrid'}
u, neste caso, informa que o retorno é Unicode. Quando utilizarmos de fato a string, o caracter será ignorado.
Observamos novamente muita facilidade na implementação e uma estrutura semelhante ao parsing XML. Em termos comparativos, podemos considerar que JSON é mais human readable que XML. Essa é a principal razão para seu crescimento quantitativo na oferta de open data.
Arquivos CSV
Arquivos CSV são largamente usados em tarefas de data mining por serem comumente oriundos de exportação de planilhas e bancos de dados relacionais. São arquivos-texto com algum separador de dados, sendo a vírgula o mais comum deles.
Assim como os formatos XML e JSON, Python trata o parsing CSV de forma bastante simples e prática.
Sejamos nossa base de equipes, usamos nos formatos XML e JSON:
id;nome;posicao;descricao 1;Gremio;01;Equipe de Porto Alegre 2;Real Madrid;02;Equipe de Madri 3;Barcelona;03;Equipe de Barcelona
Vamos aplicar um parsing nesta base de exemplo da seguinte forma:
import csv
# lemos o arquivo CSV em disco
conteudo = open('campeonato.csv','rb')
lista_equipes = csv.reader(conteudo)
# montamos o for para listar as equipes
for item in conteudo:
print item
O script acima retorna:
1;Gremio;01;Equipe de Porto Alegre 2;Real Madrid;02;Equipe de Madri 3;Barcelona;03;Equipe de Barcelona
Conclusão
XML, JSON e CSV constituem o trio mais comum de formatos de fontes de dados tanto em ambiente aberto, como a Web, quanto em ambientes corporativos. CSV e XML são formatos comuns de resultados de exportação de bases de dados relacionais, sendo que CSV é também comum como formato alternativo de planilhas de dados. Em um projeto data science, você certamente irá se deparar com esses formatos. JSON, pela facilidade de leitura e montagem e pela semelhança visual perceptível na sintaxe em relação à linguagens de programação populares, também tem ganhado muito espaço como fonte de dados aberta.
Conseguimos demonstrar implementações de parsing para o mesmo dataset de origem com número de linhas de código em cada script Python virtualmente idêntico. Você pode, inclusive, estruturar uma aplicação de modo que ela teste o padrão do input da informação e, de acordo com este formato, oferecer um tratamento dinâmico ao parsing dos dados. Pode-se observar, pela estrutura dos scripts anteriores, que essa abordagem é bastante simples de ser implementada e é extremamente útil em ambiente de produção.
Agora que temos um bom entendimento sobre parsing de fontes de dados, seguiremos nossos estudos sobre datas science com algoritmos de análise preditiva, certamente um dos pontos mais fascinantes desta incrível ciência.
Até mais !
De 0 a 10, o quanto você recomendaria este artigo para um amigo?