Data Warehouse con PostgreSQL in Python per Data Scientist

Condividere su Facebook
Condividere su twitter
Condividere su linkato
Condividere su telegramma
Condividere su WhatsApp

Contenuti

Questo post è stato pubblicato come parte del Blogathon sulla scienza dei dati

introduzione

Data warehouse generalizzare e mescolare i dati in uno spazio multidimensionale. La costruzione o la struttura di un data warehouse comporta la pulizia dei dati, integrazione e trasformazione dei dati, e può essere visto come un “fase di pre-elaborazione importante per il data mining”.

Allo stesso tempo, i data warehouse forniscono elaborazione analitica online (chiamato OLAP) strumenti per l'analisi interattiva di dati multidimensionali di varia granularità, facilitare un'efficace estrazione e generalizzazione dei dati. Ci sono molte altre funzioni di data mining, come associazione,
classificazione, previsione e clustering, che può essere integrato con le operazioni OLAP per guidare l'estrazione interattiva della conoscenza.

Ecco perché il data warehouse è diventato un'importante piattaforma scalabile per l'analisi dei dati e l'OLAP.. Il data warehouse fornirà una piattaforma costruttiva per il data mining. Perché, data warehousing e OLAP costituiscono un passaggio essenziale nella procedura di knowledge discovery (KDD). Questa è la panoramica essenziale per comprendere la procedura generale di data mining e knowledge discovery.

Ora capiamo il concetto base di data warehouse.

Concetto di base di data warehouse:

Il data warehousing fornisce architetture e strumenti per organizzare i professionisti aziendali, comprendere e utilizzare questi dati in modo sistematico per prendere decisioni strategiche. I sistemi di data warehousing sono strumenti utili nel mondo competitivo e in rapida evoluzione di oggi.. Dagli ultimi anni, molte aziende e industrie hanno speso molti milioni di dollari per costruire data warehouse a livello aziendale.

“Quindi, Che cos'è esattamente un data warehouse?” In termini generali, Un data warehouse si riferisce a un repository di dati che viene gestito separatamente dai database operativi di un'organizzazione. I data warehouse consentono l'integrazione di una gamma di sistemi applicativi. Le quattro parole chiave (incentrato sull'argomento, integrato, variabile nel tempo e non volatile) distinguere i data warehouse da altri sistemi di archiviazione dati, Che cosa
sistemi di database relazionaliRDBMS), sistemi di elaborazione delle transazioni e altri file system.

Ci sono tre chiavi per implementare un data warehouse:

– server

– Tavola

– Indicizzazione

Analizziamo tutti questi punti in dettaglio: –

1) server:

Postgre SQL

“Postgre SQL” è un sistema di database relazionale open source (RDMS). Anche se è un sistema di amministrazione di database strutturato (DBMS), memorizza anche dati non strutturati. Ancora più importante, la GUI di Postgre SQL semplifica la consegna e la gestione dei database sul montaggio..

prima di continuare, devi scaricare e installare Postgres usando il link PostgreSQL.

Al termine dell'installazione, puoi accedere al server eseguendo l'applicazione che aprirà un portale nel tuo browser pgadmin.

C'è un database predefinito etichettato come Postgre, nonostante questo, puoi creare il tuo database facendo clic con il tasto destro del mouse su “Banche dati " menu e poi selezionare “Creare” per creare un nuovo database.

2) Implementazione Python

Ora che abbiamo creato il nostro server e database, devi prima installare il pacchetto chiamato “sqlalchemy ” da utilizzare per connettersi al database tramite Python. È inoltre possibile scaricare e installare questo pacchetto utilizzando il seguente comando al prompt di Anaconda, ad esempio-

pip install sqlalchemy

Installiamo e quindi importiamo altre librerie indispensabili nello script Python il prima possibile:

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

Ora, abbiamo bisogno di determinare una connessione tra il nostro “records_db " database e creare una nuova tabella in cui possiamo memorizzare i nostri record. Allo stesso tempo, abbiamo bisogno di creare un'altra connessione con il “datasets_db ” database in cui possiamo archiviare i nostri set di dati.

p_engine = create_engine("postgresql://<nome utente>:<parola d'ordine>@localhost:5432/records_db")
p_engine_dataset = create_engine("postgresql://<nome utente>:<parola d'ordine>@localhost:5432/datasets_db")
p_engine.execute("CREA TABELLA SE NON ESISTE record (nome testo CHIAVE PRIMARIA, testo dei dettagli[])")

Come sappiamo la convenzione di denominazione post-laurea, I nomi delle tabelle devono iniziare con caratteri di sottolineatura (_) o testi ("a, B, c" e non numeri), non deve contenere trattini (-) e hanno meno di 64 caratteri. Considera il nostro “record” tavolo, creeremo un “Nome” con un campo “testo” tipo di dati dichiarato come CHIAVE PRIMARIA e un Dettagli campo come testo[](addestramento) che è la notazione di Postgres per una matrice unidimensionale. Allo stesso tempo, Se si desidera archiviare le credenziali del database in modo sicuro, Salvarli in un file di configurazione, quindi richiamarli come parametri nel codice in base alle proprie esigenze.

Perché, Creiamo le seguenti cinque funzioni per la lettura, scrivere, aggiornamento, elencare i nostri dati verso / dal nostro database. Vedremo:-

def write_record(nome,Dettagli,p_engine):
    p_engine.execute("INSERISCI NEI record (nome,Dettagli) VALORI ('%s','%s')" % (nome,Dettagli))

def read_record(campo,nome,p_engine):
    risultato = p_engine.execute("SELECT %s FROM records WHERE name="%S"" % (campo,nome))
    restituisci risultato.first()[0]
    
def update_record(campo,nome,new_value,p_engine):
    p_engine.execute("UPDATE record SET %s="%S" DOVE nome="%S"" % (campo,new_value,nome))

def write_dataset(nome,set di dati,p_engine):
    dataset.to_sql('%s' % (nome),p_engine,indice=Falso,if_exists="sostituire",chunksize=1000)

def read_dataset(nome,p_engine):
    Tentativo:
        dataset = pd.read_sql_table(nome,p_engine)
    tranne:
        dataset = pd. DataFrame([])
    return dataset

def list_datasets(p_engine):
    dataset = p_engine.execute("SELEZIONA table_name DA information_schema.tables DOVE table_schema="pubblico" ORDINA PER table_name;")
    restituire datasets.fetchall()

3) Cruscotto:

Streamlit

“Streamlit” è un framework web Python puro che ci permette di sviluppare e implementare interfacce utente (interfaccia utente) e applicazioni in tempo reale. Qui stiamo usando streamlit per eseguire il rendering della dashboard per interagire con il database.

Nel codice mostrato di seguito, Utilizziamo diverse voci di testo per inserire i valori nei nostri record, array e nomi per i nostri set di dati. Prossimo, usiamo le funzioni Streamlit per visualizzare in modo interattivo il nostro set di dati come grafico e anche come frame di dati.

st.titolo('Pannello di controllo')
colonna_1, column_2 = st.beta_columns(2)

con colonna_1:
    st.header('Salva record')
    nome = st.text_input('Inserire il nome')
    dettagli = st.text_input('Inserisci i tuoi dati (separati da virgola ",")')
    dettagli = ('{%S}' % (Dettagli))
    se st.button('Salva record nel database'):
        write_record(nome,Dettagli,p_engine)
        st.info('Nome: **%mer** e dettagli: **%s** salvato nel database' % (nome,Dettagli[1:-1]))

    st.header("Aggiorna record")
    campo = st.selectbox('Seleziona il campo da aggiornare',('nome','particolari'))
    nome_chiave = st.text_input('Inserire il nome del record da aggiornare')    
    if campo == 'nome':
        nome_aggiornato = st.text_input("Inserisci il tuo nome aggiornato")
        se st.button("Aggiorna record"):
            update_record(campo,nome_chiave,nome_aggiornato,p_engine)
            st.info('Nome aggiornato a **%s** nel record **%s**' % (nome_aggiornato,nome_chiave))                
    elif campo == 'dettagli':
        update_details = st.text_input('Si prega di inserire i dettagli aggiornati (separati da virgola)')
        dettagli_aggiornati = ('{%S}' % (dettagli_aggiornati))  
        se st.button("Aggiorna record"):
            update_record(campo,nome_chiave,dettagli_aggiornati,p_engine)
            st.info('Dettagli aggiornati a **%s** nel record **%s**' % (dettagli_aggiornati[1:-1],nome_chiave))
            
    st.header("Leggi record")
    record_to_read = st.text_input('Inserire il nome del record da leggere')
    se st.button('Ricerca'):
        read_name = read_record('nome',record_to_read,p_engine)
        read_details = read_record('particolari',record_to_read,p_engine)
        st.info('Il nome del record è **%s**, i dettagli del record sono **%s**' % (read_name,str(leggi_dettagli)[1:-1]))

con colonna_2:
    st.header("Salva set di dati")
    dataset = st.file_uploader("Carica il set di dati")
    se il set di dati non è Nessuno:
        set di dati = pd.read_csv(set di dati)
        dataset_name = st.text_input("Inserisci il nome per il set di dati")
        se st.button('Salva set di dati nel database'):
            write_dataset('%s' % (nome_set di dati),set di dati,p_engine_dataset)
            st.info('**%s** salvato nel database' % (nome_set di dati))

    Tentativo:
        read_title = st.empty()
        dataset_to_read = st.selectbox('Seleziona il set di dati da leggere',([X[0] per x in list_datasets(p_engine_dataset)]))
        read_title.header("Leggi set di dati")
        se st.button("Leggi set di dati"):
            df = read_dataset(dataset_to_read,p_engine_dataset)
            st.sottotitolo('Grafico')
            st.line_chart(df['valore'])
            st.sottotitolo('Frame dati')
            st.write(df)    
    tranne:
        passaggio

Puoi eseguire il tuo pannello in un browser locale dalla tua macchina, digitando i seguenti comandi in avviso anaconda. Quindi, primo, dovresti cambiare la tua directory principale nel luogo in cui è stato salvato il tuo codice sorgente.

Centro per la prevenzione e il controllo delle malattie:Utentiil percorso della directory...

Ora eseguiremo il seguente codice per eseguire la nostra applicazione …

esecuzione streamlit nome_file.py

Punteggio finale

Finire, abbiamo una lavagna che può essere usata per scrivere, leggere, tokenizzare, aggiornamento, caricare e visualizzare i nostri dati in tempo reale. Possiamo vedere la bellezza del nostro data warehouse che può essere ampliato per l'utente / l'host ha tutti i dati di cui hai bisogno all'interno della stessa struttura.

conclusione

Spero che il mio post ti sia piaciuto. condividi con i tuoi amici, colleghi. Grazie!

Il supporto mostrato in questo post non è di proprietà di DataPeaker e viene utilizzato a discrezione dell'autore.

Iscriviti alla nostra Newsletter

Non ti invieremo posta SPAM. Lo odiamo quanto te.