Data Science Python 2

Manipulando Dados em PostgreSQL com Python

Alguém aí está curioso para saber como vamos finalizar a nossa trilogia API com Python, o céu é o limite. Então vamos lá, após consumir os dados da API, realizar o processamento paralelo com Python para otimizar o tempo, então temos o seguinte problema, onde vamos guardar os dados da API? Sendo assim o dados ao cubo vai mostrar para vocês como persistir os dados em um banco de dados relacional, o PostgreSQL, utilizando a linguagem Python.

Para isso conheceremos a biblioteca Psycopg2, com ela é possível trabalhar com Python e PostgreSQL. E então, vamos para prática e ver toda essa teoria acontecendo.

Bancos de Dados Relacionais e PostgreSQL

Os bancos de dados relacionais, já vimos em outro post (Linguagem SQL e os Bancos de Dados Relacionais) e temos a seguinte definição:

“Falando apenas dos bancos relacionais, são dados estruturados em linhas e colunas. O armazenamento é feito através de tabelas com relacionamentos entre si. Essa estrutura é formalizada pelos termos: relação (tabela), tupla (linhas) e atributo (coluna).”

E o PostgreSQL é um sistema gerenciador de banco de dados (SGDB) de código aberto. Como o PostgreSQL, existem muitos outros SGBD, seja também de código aberto ou proprietário, então para nossa prática utilizaremos o PostgreSQL, mas antes precisamos ver como se comunicar com ele através do Python.

A Biblioteca Psycopg2

Esse pacote, faz a comunicação do Python com banco de dados PostgreSQL. Dessa forma é possível realizar operações no banco de dados via scripts Python. Estas funcionalidades facilitam e muito a manipulação de dados na linguagem Python e os bancos de dados PostgreSQL. A biblioteca pode ser instalada utilizando o comando abaixo:

pip install psycopg2

Agora já sabemos as informações básicas para iniciar a parte prática, onde persistiremos os dados no banco PostgreSQL utilizando a linguagem Python através do pacote psycopg2.

Manipulando Dados em PostgreSQL com o D[3]

Iniciamos, importando as bibliotecas necessárias para o desenvolvimento do nosso notebook.

import requests
import json
import pandas as pd
import psycopg2

As bibliotecas requests e json vão auxiliar na extração dos dados da API. O pacote pandas vai realizar a estruturação de dados. E a biblioteca psycopg2 vai fazer a comunicação com o PostgreSQL.

Vamos relembrar a requisição dos dados na API, utilizando a função request do pacote requests, passando o método (GET), a url (https://dadosabertos.camara.leg.br/api/v2/deputados). Com o resultado da requisição utilizaremos a função loads da biblioteca json para obter os dados em um formato de dicionário. 

# Requisição dos dados dos Deputados
url        = 'https://dadosabertos.camara.leg.br/api/v2/deputados'
parametros = {}
resposta   = requests.request("GET", url, params=parametros)
objetos    = json.loads(resposta.text)
dados      = objetos['dados']

Faremos a estruturação dos dados, utilizaremos a função DataFrame do pandas

df = pd.DataFrame(dados)

Em seguida deixaremos todas as colunas com o formato de string, através da função apply do pandas.

for col in df.columns:
  df[col] = df[col].apply(str)

Agora que já temos os dados da API, podemos começar a se comunicar com o PostgreSQL.

Conexão do Python com o PostgreSQL

Primeiro, criamos uma função para a conexão com o banco de dados, chamaremos de conecta_db. Para isso, utilizamos a função connect do pacote psycopg2, informamos o host, database, user e password.

# Função para criar conexão no banco
def conecta_db():
  con = psycopg2.connect(host='localhost', 
                         database='db_deputados',
                         user='postgres', 
                         password='postgres')
  return con

Chamamos a função que tem a conexão com o banco de dados do PostgreSQL.

Dropando e Criando Tabela no PostgreSQL

Em seguida, estruturamos a função criar_db que cria a tabela no banco de dados. Aqui utilizaremos as funções cursor, para abrir uma sessão para o usuário, a execute que roda o sql no banco, o commit finaliza a transação e a close finaliza a conexão com o banco. Todas essas funções do pacote psycopg2.

# Função para criar tabela no banco
def criar_db(sql):
  con = conecta_db()
  cur = con.cursor()
  cur.execute(sql)
  con.commit()
  con.close()

Agora, chamamos a função que criamos acima, informando o comando SQL para executar no banco. Primeiro deletamos a tabela do banco caso ela exista e em seguida usamos a mesma função criar_db para criar a tabela de deputados.

# Dropando a tabela caso ela já exista
sql = 'DROP TABLE IF EXISTS public.deputados'
criar_db(sql)
# Criando a tabela dos deputados
sql = '''CREATE TABLE public.deputados 
      ( id            character varying(10), 
        uri           character varying(100), 
        nome          character varying(500), 
        siglaPartido  character varying(50), 
        uriPartido    character varying(200), 
        siglaUf       character varying(10), 
        idLegislatura character varying(10), 
        urlFoto       character varying(100), 
        email         character varying(100) 
      )'''
criar_db(sql)

Com a tabela criada, podemos começar a inserir os dados.

Inserindo Dados no PostgreSQL

A gravação dos dados no banco, envolve criar a função inserir_db. Aqui conectamos ao banco com nossa função conecta_db, depois abriremos uma sessão com o cursor. Utilizaremos o try e except para verificar a ocorrência de erros na inserção. Caso a função execute não apresente erro, realizamos o commit para finalizar a transação. Já em caso de erro usamos o rollback para manter a integridade do banco e exibimos o erro. Por fim, aplicamos a função close para encerrar a conexão.

# Função para inserir dados no banco
def inserir_db(sql):
    con = conecta_db()
    cur = con.cursor()
    try:
        cur.execute(sql)
        con.commit()
    except (Exception, psycopg2.DatabaseError) as error:
        print("Error: %s" % error)
        con.rollback()
        cur.close()
        return 1
    cur.close()

Vamos montar um loop com for, para inserir cada linha do DataFrame. Passamos no SQL as colunas do banco e as colunas do DataFrame relacionadas. Em cada iteração do loop usamos a função inserir_db para inserir o registro.

# Inserindo cada registro do DataFrame
for i in df.index:
    sql = """
    INSERT into public.deputados (id,uri,nome,siglaPartido,uriPartido,siglaUf,idLegislatura,urlFoto,email) 
    values('%s','%s','%s','%s','%s','%s','%s','%s','%s');
    """ % (df['id'][i], df['uri'][i], df['nome'][i], df['siglaPartido'][i], df['uriPartido'][i], df['siglaUf'][i], df['idLegislatura'][i], df['urlFoto'][i], df['email'][i])
    inserir_db(sql)
 
Error: syntax error at or near "Angelo"
LINE 3: ...s.camara.leg.br/api/v2/deputados/141439','Chico D'Angelo','P...

Apresentou o erro em apenas um registro, deixei para exemplificar nossa função. Aproveita e comenta como você corrigiu esse erro?

Agora para finalizar faremos uma consulta no banco de dados PostgreSQL.

Consultando Dados no PostgreSQL

A função consultar_db, irá retornar os registros da consulta SQL que passaremos. Aqui vamos mais uma vez, conectar ao banco com nossa função conecta_db, depois abrimos uma sessão com o cursor. Em seguida aplicamos o execute para rodar o SQL e o fetchall vai retornar os dados e então usamos um loop for para colocar os dados em uma lista. Para finalizar, encerramos a conexão com o close.

# Função para consultas no banco
def consultar_db(sql):
  con = conecta_db()
  cur = con.cursor()
  cur.execute(sql)
  recset = cur.fetchall()
  registros = []
  for rec in recset:
    registros.append(rec)
  con.close()
  return registros

Faremos um simples select na tabela de deputados.

# Realizando a consulta no PostegreSQL
reg = consulta_db('select * from public.deputados')

Com os dados na variável reg, vamos transformar em um DataFrame, passando a variável reg e o nome das colunas dos dados.

# Tranformando os dados da consulta no PostegreSQL em DataFrame
df_bd = pd.DataFrame(reg, columns=['id','uri','nome','siglaPartido','uriPartido','siglaUf','idLegislatura','urlFoto','email'])
df_bd.head()

A função head exibirá os primeiros registros da consulta.

Persistir os dados em um banco de dados, ou apenas consultar para fazer uma análise, são tarefas muito comuns no trabalho dos profissionais de dados.

Conclusões

Enfim, chegamos ao último artigo  da nossa trilogia API com Python, o céu é o limite. O objetivo foi mostrar como persistir dados com Python em um banco PostgreSQL, depois de uma ingestão de dados de uma API.

O código completo você pode conferir no GitHub do Dados ao Cubo. Vimos como fazer a ingestão de dados de uma API, como realizar processamento paralelo com Python e fechamos persistindo esses dados em um banco relacional. 

Espero que tenha curtido nosso conteúdo sobre API, se gostou compartilhe para fortalecer a comunidade de dados aqui no Brasil. Não esqueça também de compartilhar seu feedback conosco, um grande abraço e até a próxima.

Conteúdos ao Cubo

Por fim, deixo algumas sugestões de conteúdos que você pode encontrar no Dados ao Cubo, sempre falando sobre o mundo dos dados.

Gostou? Compartilhe!

Você pode gostar:

2 Comments

  • Reply
    Everson
    16 de julho de 2021

    Parabéns pelo tutorial. Aprendi bastante.

Comentários:

%d blogueiros gostam disto: