Data Warehouse com PostgreSQL em Python para cientistas de dados

Conteúdo

Esta postagem foi lançada como parte do Data Science Blogathon

Introdução

Armazem de dados generalize e misture dados em um espaço multidimensional. A construção ou estrutura de um data warehouse envolve a limpeza de dados, integração e transformação de dados, e pode ser visto como um “etapa de pré-processamento importante para mineração de dados”.

Ao mesmo tempo, armazéns de dados fornecem processamento analítico online (chamado OLAP) ferramentas para análise interativa de dados multidimensionais de granularidade variável, facilitando a mineração e generalização de dados eficazes. Existem muitas outras funções de mineração de dados, como uma associação,
classificação, previsão e clustering, que pode ser integrado com operações OLAP para conduzir a extração de conhecimento interativo.

É por isso que o data warehouse se tornou uma importante plataforma escalonada para análise de dados e OLAP.. O data warehouse irá fornecer uma plataforma construtiva para mineração de dados. Por isso, armazenamento de dados e OLAP formam uma etapa essencial no procedimento de descoberta de conhecimento (KDD). Esta é a visão geral essencial para entender o procedimento geral de mineração de dados e descoberta de conhecimento.

Agora vamos entender o conceito básico de data warehouse.

Conceito básico de data warehouse:

O armazenamento de dados fornece arquiteturas e ferramentas para os profissionais de negócios organizarem, compreender e usar esses dados de forma sistemática para tomar decisões estratégicas. Os sistemas de armazenamento de dados são ferramentas benéficas no mundo competitivo e em rápida evolução de hoje.. Desde os últimos anos, muitas empresas e setores gastaram muitos milhões de dólares construindo armazéns de dados para toda a empresa.

“Então, O que exatamente é um data warehouse?” Em termos gerais, Um data warehouse se refere a um repositório de dados que é mantido separadamente dos bancos de dados operacionais de uma organização. Armazéns de dados permitem a integração de uma variedade de sistemas de aplicativos. As quatro palavras-chave (focado no assunto, integrado, variável no tempo e não volátil) distinguir data warehouses de outros sistemas de armazenamento de dados, O que
sistemas de banco de dados relacionaisRDBMS), sistemas de processamento de transações e outros sistemas de arquivos.

Existem três chaves para implementar um data warehouse:

– servidor

– Borda

– Indexando

Vamos analisar todos esses pontos em detalhes: –

1) Servidor:

Postgre SQL

“Postgre SQL” é um sistema de base de dados Relacional de código aberto (RDMS). Mesmo sendo um sistema de administração de banco de dados estruturado (DBMS), também armazena dados não estruturados. Mais importante ainda, o Postgre SQL GUI torna muito fácil entregar e gerenciar bancos de dados na montagem..

Antes de continuar, você deve baixar e instalar o Postgres usando o link PostgreSQL.

Depois que a instalação for concluída, pode começar sessão no servidor executando o aplicativo que abrirá um portal em seu navegador PGADMIN.

Existe um banco de dados padrão rotulado como Postgre, Apesar disto, você pode criar seu próprio banco de dados clicando com o botão direito do mouse no “Bases de dados " menu e selecione “Crio” para criar um novo banco de dados.

2) Implementação Python

Agora que criamos nosso servidor e banco de dados, você deve primeiro instalar o pacote chamado “sqlalchemy ” para ser usado para se conectar ao banco de dados via Python. Além disso, você pode baixar e instalar este pacote usando o seguinte comando no prompt do Anaconda como-

pip install sqlalchemy

Vamos instalar e importar outras bibliotecas obrigatórias no script Python da seguinte maneira:

from sqlalchemy import create_engine
import psycopg2
import pandas as pd
import streamlit as st

Agora, precisamos determinar uma conexão entre o nosso “records_db banco de dados e criar uma nova tabela onde podemos armazenar nossos registros. Ao mesmo tempo, precisamos criar outra conexão com o “datasets_db ” banco de dados onde podemos armazenar nossos conjuntos de dados.

p_engine = create_engine("pós-anot²://<nome do usuário>:<senha>@localhost:5432/records_db")
p_engine_dataset = create_engine("pós-anot²://<nome do usuário>:<senha>@localhost:5432/datasets_db")
p_engine.execute("CRIAR REGISTROS DE TABELA SE NÃO EXISTIR (texto do nome CHAVE PRIMÁRIA, texto detalhes[])")

Como conhecemos a convenção de nomeação de postegre, nomes de tabela deve começar com sublinhados (_) ou letras ("para, b, c " e não números), não deve conter hífens (-) e têm menos de 64 personagens. Considere nossa “registros” Tabela, vamos criar um “Nome” campo com um “texto” tipo de dados declarado como CHAVE PRIMÁRIA e um Detalhes campo como texto[](Treinamento) que é a notação Pós-Grau para uma matriz unidimensional. Ao mesmo tempo, se você quiser armazenar suas credenciais de banco de dados com segurança, salve-os em um arquivo de configuração e invoque-os como parametros em seu código de acordo com seus requisitos.

Por isso, vamos criar as cinco funções a seguir que são para leitura, escrever, melhoria, listar nossos dados para / do nosso banco de dados. Vamos a ver:-

def write_record(nome,Detalhes,p_engine):
    p_engine.execute("INSERÇÃO EM registros (nome,Detalhes) VALORES ('%s','%s')" % (nome,Detalhes))

def read_record(campo,nome,p_engine):
    resultado = p_engine.execute("SELECIONE %s DE registros onde nome="%s"" % (campo,nome))
    resultado de retorno.primeiro()[0]
    
def update_record(campo,nome,new_value,p_engine):
    p_engine.execute("REGISTROS DE ATUALIZAÇÃO SET %s="%s" ONDE nome="%s"" % (campo,new_value,nome))

def write_dataset(nome,conjunto de dados,p_engine):
    dataset.to_sql('%s' % (nome),p_engine,index = False,if_exists="substituir",tamanho de pedaço=1000)

def read_dataset(nome,p_engine):
    Experimente:
        conjunto de dados = pd.read_sql_table(nome,p_engine)
    exceto:
        conjunto de dados = pd. DataFrame([])
    return dataset

def list_datasets(p_engine):
    conjuntos de dados = p_engine.execute("SELECT table_name FROM information_schema.tables WHERE table_schema ="público" ORDER BY table_name;")
    return datasets.fetchall()

3) Painel de instrumentos:

Streamlit

“Streamlit” é uma estrutura da web Python pura que nos permite desenvolver e implementar interfaces de usuário (UI) e aplicativos em tempo real. Aqui, estamos usando streamlit para renderizar o painel para interagir com o banco de dados.

No código mostrado abaixo, estamos usando diferentes entradas de texto para inserir os valores em nossos registros, arrays e nomes para nossos conjuntos de dados. A seguir, usamos funções do Streamlit para visualizar interativamente nosso conjunto de dados como um gráfico e também como um quadro de dados.

st.title('Painel')
column_1, column_2 = st.beta_columns(2)

com column_1:
    st.header('Salvar registros')
    name = st.text_input('Por favor, insira o nome')
    details = st.text_input('Por favor, insira seus detalhes (separados por vírgula ",")')
    detalhes = ('{%s}' % (Detalhes))
    se st.button('Salvar registro no banco de dados'):
        write_record(nome,Detalhes,p_engine)
        st.info('Nome: **%s ** e detalhes: **%s ** salvo no banco de dados ' % (nome,Detalhes[1:-1]))

    st.header('Atualizar registros')
    field = st.selectbox('Selecione o campo para atualizar',('nome','detalhes'))
    name_key = st.text_input('Por favor, insira o nome do registro a ser atualizado')    
    se campo == 'nome':
        updated_name = st.text_input('Por favor, insira seu nome atualizado')
        se st.button('Atualizar registros'):
            update_record(campo,name_key,updated_name,p_engine)
            st.info('Nome atualizado para **% s ** no registro **% s **' % (updated_name,name_key))                
    campo elif == 'detalhes':
        updated_details = st.text_input('Por favor, insira os detalhes atualizados (separados por vírgula)')
        updated_details = ('{%s}' % (update_details))  
        se st.button('Atualizar registros'):
            update_record(campo,name_key,update_details,p_engine)
            st.info('Detalhes atualizados para **% s ** no registro **% s **' % (update_details[1:-1],name_key))
            
    st.header('Ler registros')
    record_to_read = st.text_input('Por favor, insira o nome do registro para ler')
    se st.button('Procurar'):
        read_name = read_record('nome',record_to_read,p_engine)
        read_details = read_record('detalhes',record_to_read,p_engine)
        st.info('O nome do registro é **% s **, os detalhes do registro são **% s ** ' % (read_name,str(read_details)[1:-1]))

com coluna_2:
    st.header('Salvar conjuntos de dados')
    dataset = st.file_uploader('Envie o conjunto de dados')
    se o conjunto de dados não for Nenhum:
        dataset = pd.read_csv(conjunto de dados)
        dataset_name = st.text_input('Por favor, insira o nome para o conjunto de dados')
        se st.button('Salvar conjunto de dados no banco de dados'):
            write_dataset('%s' % (dataset_name),conjunto de dados,p_engine_dataset)
            st.info('**% s ** salvo no banco de dados' % (dataset_name))

    Experimente:
        read_title = st.empty()
        dataset_to_read = st.selectbox('Selecione o conjunto de dados para ler',([x[0] para x em list_datasets(p_engine_dataset)]))
        read_title.header('Ler conjuntos de dados')
        se st.button('Ler conjunto de dados'):
            df = read_dataset(dataset_to_read,p_engine_dataset)
            st.subheader('Gráfico')
            st.line_chart(df['valor'])
            st.subheader('Quadro de dados')
            st.write(df)    
    exceto:
        passar

Você pode executar seu painel em um navegador local da sua máquina, digitando os seguintes comandos em anaconda. Então, primeiro, você deve alterar seu diretório raiz para o local onde seu código-fonte foi salvo.

CDC:Utilizadores no caminho do seu diretório ...

Agora vamos executar o seguinte código para executar nosso aplicativo …

streamlit executar file_name.py

Resultado final

Para terminar, temos um quadro que pode ser usado para escrever, leitura, tokenizar, melhoria, carregue e veja nossos dados em tempo real. Podemos ver a beleza de nosso data warehouse que pode ser expandido para o usuário / host tem quantos dados você precisa dentro da mesma estrutura.

conclusão

Espero que tenha gostado da minha postagem. Compartilhe com os seus amigos, colegas. Obrigado!

A mídia mostrada nesta postagem não é propriedade da DataPeaker e é usada a critério do autor.

Assine a nossa newsletter

Nós não enviaremos SPAM para você. Nós odiamos isso tanto quanto você.