Entrepôt de données avec PostgreSQL en Python pour les scientifiques des données

Cet article a été publié dans le cadre de la Blogathon sur la science des données

introduction

Entrepôt de données généraliser et mélanger des données dans un espace multidimensionnel. La construction ou la structuration d'un entrepôt de données implique le nettoyage des données, intégration de données et transformation de données, et peut être vu comme un “étape de pré-traitement importante pour l'exploration de données”.

En même temps, les entrepôts de données fournissent un traitement analytique en ligne (appelé OLAP) outils d'analyse interactive de données multidimensionnelles de diverses granularités, qui facilite une généralisation efficace et l'exploration de données. Il existe de nombreuses autres fonctions d'exploration de données, en tant qu'association,
classification, prédiction et regroupement, qui peut être intégré aux opérations OLAP pour piloter l'extraction interactive des connaissances.

C'est pourquoi l'entrepôt de données est devenu une plate-forme évolutive importante pour l'analyse de données et OLAP.. L'entrepôt de données fournira une plate-forme constructive pour l'exploration de données. Pour cela, l'entreposage de données et OLAP constituent une étape essentielle dans la procédure de découverte des connaissances (KDD). C'est l'aperçu qui est essentiel pour comprendre la procédure générale d'exploration de données et de découverte de connaissances.

Comprenons maintenant le concept de base de l'entrepôt de données.

Concept de base d'entrepôt de données:

L'entreposage de données offre des architectures et des outils permettant aux professionnels de s'organiser, comprendre et utiliser systématiquement ces données pour prendre des décisions stratégiques. Les systèmes de stockage de données sont des outils utiles dans le monde compétitif et en évolution rapide d'aujourd'hui.. depuis les dernières années, de nombreuses entreprises et industries ont dépensé plusieurs millions de dollars pour construire des entrepôts de données à l'échelle de l'entreprise.

“Ensuite, qu'est-ce qu'un entrepôt de données exactement?” En termes générales, un entrepôt de données fait référence à un référentiel de données qui est maintenu séparément des bases de données opérationnelles d'une organisation. Les entrepôts de données permettent l'intégration d'une gamme de systèmes d'application. les quatre mots clés (concentré sur le sujet, intégré, temps variable et non volatile) distinguer les entrepôts de données des autres systèmes de stockage de données, Quoi
systèmes de bases de données relationnellesSGBDR), systèmes de traitement des transactions et autres systèmes de fichiers.

Il y a trois clés pour mettre en place un entrepôt de données:

– serveur

– Conseil

– Indexage

Analysons tous ces points en détail: –

1) Serveur:

PostgreSQL

“PostgreSQL” est un système de base de données relationnelle open source (SGD). Même s'il s'agit d'un système de gestion de base de données structuré (SGBD), stocke également des données non structurées. Plus important encore, l'interface utilisateur graphique de Postgre SQL facilite la livraison et la gestion des bases de données sur le montage..

avant de continuer, vous devez télécharger et installer Postgres en utilisant le lien PostgreSQL.

Une fois l'installation terminée, vous pouvez vous connecter au serveur en exécutant l'application qui ouvrira un portail dans votre navigateur pgadmin.

Il existe une base de données par défaut étiquetée comme Postgre, malgré cela, vous pouvez créer votre propre base de données en faisant un clic droit sur le “Base de données " menu puis sélectionnez “Créer” pour créer une nouvelle base de données.

2) Implémentation Python

Maintenant que nous avons créé notre serveur et notre base de données, vous devez d'abord installer le package appelé “sqlalchimie ” qui servira à se connecter à la base de données via Python. De plus, vous pouvez télécharger et installer ce package en utilisant la commande suivante à l'invite Anaconda comme-

pip installer sqlalchemy

Installons puis importons d'autres bibliothèques indispensables dans le script python comme suit:

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

À présent, nous devons déterminer un lien entre notre “records_db » et créer une nouvelle table où nous pouvons stocker nos enregistrements. En même temps, nous devons créer un autre lien avec le “datasets_db ” base de données où nous pouvons stocker nos ensembles de données.

p_engine = create_engine("postgresql://<nom d’utilisateur>:<le mot de passe>@localhost:5432/records_db")
p_engine_dataset = create_engine("postgresql://<nom d’utilisateur>:<le mot de passe>@localhost:5432/datasets_db")
p_engine.execute("CRÉER DES ENREGISTREMENTS DE TABLE S’IL N’EXISTE PAS (nom texte CLÉ PRIMAIRE, texte de détails[])")

Comme nous le savons la convention de nommage postegre, les noms de table doivent commencer par des traits de soulignement (_) ou paroles (« à, b, c » y no números), ne doit pas contenir de traits d’union (-) et ont moins de 64 personnages. Considérez notre “enregistrements” tableau, nous allons créer un “nom” champ avec un champ “texte” type de données déclaré comme CLÉ PRIMAIRE et un Détails champ en tant que texte[](entraînement) qui est la notation Postgres pour une matrice unidimensionnelle. En même temps, si vous souhaitez stocker vos informations d’identification de base de données en toute sécurité, enregistrez-les dans un fichier de configuration, puis appelez-les en tant que paramètres dans votre code en fonction de vos besoins.

Pour cela, créons les cinq fonctions suivantes qui sont destinées à la lecture, Écrire, mettre à jour, répertorier nos données vers / de notre base de données. Nous allons voir:-

def write_record(Nom,Détails,p_engine):
    p_engine.execute("INSÉRER DANS les enregistrements (Nom,Détails) VALEURS ('%s','%s')" % (Nom,Détails))

def read_record(champ,Nom,p_engine):
    résultat = p_engine.execute("SELECT %s FROM enregistrements WHERE name="%s"" % (champ,Nom))
    return result.first (en anglais)()[0]
    
def update_record(champ,Nom,nouvelle valeur,p_engine):
    p_engine.execute("ENREGISTREMENTS UPDATE SET %s="%s" OÙ nom="%s"" % (champ,nouvelle valeur,Nom))

def write_dataset(Nom,base de données,p_engine):
    dataset.to_sql('%s' % (Nom),p_engine,index=Faux,if_exists="remplacer",chunksize=1000)

def read_dataset(Nom,p_engine):
    essayer:
        jeu de données = pd.read_sql_table(Nom,p_engine)
    sauf:
        jeu de données =. DataFrame([])
    return dataset

def list_datasets(p_engine):
    jeux de données = p_engine.execute("SELECT nom_table FROM information_schema.tables WHERE table_schema="Publique" ORDRE PAR nom_table;")
    renvoyer des ensembles de données.fetchall()

3) Tableau de bord:

Streamlit

“Streamlit” est un framework Web pur Python qui nous permet de développer et d'implémenter des interfaces utilisateur (Interface utilisateur) et applications en temps réel. Ici, nous utilisons streamlit pour rendre le tableau de bord afin d'interagir avec la base de données.

Dans le code ci-dessous, nous utilisons différentes entrées de texte pour insérer les valeurs dans nos registres, tableaux et noms pour nos ensembles de données. Ensuite, nous utilisons les fonctions de Streamlit pour visualiser de manière interactive notre ensemble de données sous forme de graphique et également sous forme de trame de données.

st.titre('Tableau de bord')
colonne_1, column_2 = st.beta_columns(2)

avec colonne_1:
    st.header('Enregistrer les enregistrements')
    nom = st.text_input('Veuillez entrer le nom')
    détails = st.text_input('Veuillez entrer vos coordonnées (séparés par une virgule ",")')
    détails = ('{%s}' % (Détails))
    si st.bouton('Enregistrer l'enregistrement dans la base de données'):
        enregistrement_écriture(Nom,Détails,p_engine)
        st.info('Nom: **%sexe et détails: **%s ** enregistré dans la base de données ' % (Nom,Détails[1:-1]))

    st.header('Mettre à jour les enregistrements')
    champ = st.selectbox('Veuillez sélectionner le champ à mettre à jour',('Nom','des détails'))
    name_key = st.text_input('Veuillez saisir le nom de l'enregistrement à mettre à jour')    
    si champ == 'nom':
        nom_mis à jour = st.text_input('Veuillez entrer votre nom mis à jour')
        si st.bouton('Mettre à jour les enregistrements'):
            update_record(champ,nom_clé,nom_mis à jour,p_engine)
            st.info('Nom mis à jour à **%s** dans l'enregistrement **%s**' % (nom_mis à jour,nom_clé))                
    champ elif == 'détails':
        détails_mis à jour = st.text_input('Veuillez entrer les détails mis à jour (séparés par une virgule)')
        détails_mis à jour = ('{%s}' % (détails_mis à jour))  
        si st.bouton('Mettre à jour les enregistrements'):
            update_record(champ,nom_clé,détails_mis à jour,p_engine)
            st.info('Détails mis à jour sur **%s** dans l'enregistrement **%s**' % (détails_mis à jour[1:-1],nom_clé))
            
    st.header('Lire les enregistrements')
    record_to_read = st.text_input('Veuillez saisir le nom de l'enregistrement à lire')
    si st.bouton('Rechercher'):
        read_name = read_record('Nom',record_to_read,p_engine)
        read_details = read_record('des détails',record_to_read,p_engine)
        st.info('Le nom de l'enregistrement est **%s**, les détails de l'enregistrement sont **%s**' % (read_name,str(read_details)[1:-1]))

avec colonne_2:
    st.header('Enregistrer les jeux de données')
    jeu de données = st.file_uploader("Veuillez télécharger l'ensemble de données")
    si l'ensemble de données n'est pas Aucun:
        ensemble de données = pd.read_csv(base de données)
        dataset_name = st.text_input('Veuillez saisir le nom du jeu de données')
        si st.bouton('Enregistrer le jeu de données dans la base de données'):
            write_dataset('%s' % (nom_ensemble_données),base de données,p_engine_dataset)
            st.info('**%s** enregistré dans la base de données' % (nom_ensemble_données))

    essayer:
        read_title = st.vide()
        dataset_to_read = st.selectbox('Veuillez sélectionner le jeu de données à lire',([X[0] pour x dans list_datasets(p_engine_dataset)]))
        read_title.header("Lire les jeux de données")
        si st.bouton('Lire l'ensemble de données'):
            df = read_dataset(jeu_de_données_à_lire,p_engine_dataset)
            st.subheader('Graphique')
            st.line_chart(df['valeur'])
            st.subheader('Trame de données')
            st.écrire(df)    
    sauf:
        passe

Vous pouvez exécuter votre panneau dans un navigateur local à partir de votre machine, en tapant les commandes suivantes dans avertissement anaconda. Ensuite, premier, vous devez changer votre répertoire racine à l'endroit où votre code source a été enregistré.

CDC:Utilisateursvotre chemin de répertoire...

Nous allons maintenant exécuter le code suivant pour exécuter notre application …

streamlit exécuter file_name.py

Résultat final

Pour terminer, nous avons un tableau qui peut être utilisé pour écrire, lis, tokenizar, mettre à jour, charger et visualiser nos données en temps réel. Nous pouvons voir la beauté de notre magasin de données qui peut être étendu afin que l'utilisateur / l'hôte a autant de données qu'il en a besoin dans la même structure.