Erstellen von Slick -Daten -Dashboards mit Python, Taipy & Google Sheets

Bild von Autor | Ideogramm

# Einführung

Daten sind zu einer wichtigen Ressource für jedes Unternehmen geworden, da sie Unternehmen für Unternehmen wertvolle Erkenntnisse erhalten, insbesondere bei Entscheidungen. Ohne Daten stützen sich Entscheidungen ausschließlich auf Instinkt und Glück, was nicht der effektivste Ansatz ist.

Viele Rohdaten sind jedoch schwer zu verstehen. Es bietet keine direkten Einblicke und erfordert eine weitere Verarbeitung. Aus diesem Grund verlassen sich viele Menschen darauf, Daten -Dashboards zu verwenden, um die Rohdaten zusammenzufassen, zu visualisieren und zu navigieren. Durch die Entwicklung eines eleganten Armaturenbretts können wir nicht-technische Benutzer eine einfache Möglichkeit bieten, einfach Einblicke aus Daten zu erhalten.

Aus diesem Grund wird in diesem Artikel untersucht, wie ein schlankes Daten Dashboard erstellt wird PythonAnwesend TaipieUnd Google -Blätter.

Lass uns darauf eingehen.

# Entwicklung eines Slick -Daten -Dashboards

Wir werden das Tutorial beginnen, indem wir alle erforderlichen Anmeldeinformationen für den Zugriff auf Google Sheets über Python vorbereiten. Erstellen Sie zunächst ein Google -Konto und navigieren Sie zur Google Cloud Console. Navigieren Sie dann zu APIS & Companies> Bibliothek, in der Sie die Google Sheets API und die Google Drive -API aktivieren müssen.

Kehren Sie nach der Aktivierung der APIs zu APIs & Dienste> Anmeldeinformationen zurück und navigieren Sie, um Anmeldeinformationen> Servicekonto zu erstellen. Befolgen Sie die Anweisungen und weisen Sie die Rolle wie Herausgeber oder Besitzer zu, damit wir Google Sheets lesen und schreiben können. Wählen Sie das gerade erstellte Servicekonto aus und navigieren Sie dann zu Schlüssel> Style hinzufügen> Neue Style erstellen. Wählen Sie JSON und laden Sie die herunter credentials.json Datei. Speichern Sie es irgendwo und öffnen Sie die Datei; Kopieren Sie dann den E -Mail -Wert unter client_email.

Für den Datensatz werden wir die verwenden Herzdatensatz aus Kaggle als Beispiel. Speichern Sie die Datei in Google Drive und öffnen Sie sie als Google Sheets. Gehen Sie in der Google Sheets -Datei zur Datei> Teilen Sie Freigabe und fügen Sie die gerade kopierte E -Mail hinzu. Kopieren Sie die URL zuletzt für die Google Sheets -Datei, da wir später über die URL auf die Daten zugreifen werden.

Öffnen Sie Ihre Lieblings -IDE und dann werden wir unser Projekt wie folgt strukturieren:

taipy_gsheet/
│
├── config/
│   └── credentials.json         
├── app.py                   
└── necessities.txt

Erstellen Sie alle erforderlichen Dateien und dann werden wir unser Dashboard entwickeln. Wir werden Taipy für das Anwendungsrahmen verwenden. Pandas Für Datenmanipulation, GSPREET Und OAuth2Client für die Interaktion mit der Google Sheets -API und Handlung zum Erstellen von Visualisierungen. Im necessities.txt Datei, fügen Sie die folgenden Pakete hinzu:

taipy
pandas
gspread
oauth2client
plotly

Dies sind die notwendigen Bibliotheken für unser Tutorial, und wir werden sie in unserer Umgebung installieren. Vergessen Sie nicht, eine virtuelle Umgebung zu nutzen, um zu verhindern, dass Sie Ihre Hauptumgebung brechen. Wir werden auch Python 3.12 verwenden; Zum Zeitpunkt, in dem dieser Artikel geschrieben wurde, ist dies die Python -Model, die derzeit für die obigen Bibliotheken funktioniert.

Installieren Sie die Bibliotheken mit dem folgenden Befehl:

pip set up -r necessities.txt

Wenn die Set up erfolgreich ist, werden wir unsere Bewerbung vorbereiten. In app.pyWir erstellen den Code, um unser Dashboard einzurichten.

Zunächst werden wir alle notwendigen Bibliotheken importieren, die wir für die Entwicklung der Anwendung verwenden werden.

import pandas as pd
import gspread
import plotly.specific as px
import taipy as tp
from taipy import Config
from taipy.gui import Gui
import taipy.gui.builder as tgb

Als nächstes laden wir die Daten von Google Sheets mit dem folgenden Code. Ändern die SHEET_URL Wert mit Ihrer tatsächlichen Daten -URL. Darüber hinaus werden wir die Daten vorbereiten, um sicherzustellen, dass sie intestine funktionieren.

SHEET_URL = "https://docs.google.com/spreadsheets/d/1Z4S3hnV3710OJi4yu5IG0ZB5w0q4pmNPKeYy8BTyM8A/"
consumer = gspread.service_account(filename="config/credentials.json")
df_raw = pd.DataFrame(consumer.open_by_url(SHEET_URL).get_worksheet(0).get_all_records())
df_raw("intercourse") = pd.to_numeric(df_raw("intercourse"), errors="coerce").fillna(0).astype(int)
df_raw("sex_label") = df_raw("intercourse").map({0: "Feminine", 1: "Male"})

Dann werden wir das Dashboard mit vorbereiten Taipie. Taipy ist eine Open-Supply-Bibliothek für datengesteuerte Anwendungen, die sowohl Entrance-Finish- als auch Again-Finish-Entwicklung abdeckt. Verwenden wir die Bibliothek, um das Daten Dashboard mit den grundlegenden Funktionen zu erstellen, die wir mit Taipy verwenden können.

In dem folgenden Code entwickeln wir ein Szenario, das eine Pipeline ist, die der Benutzer für die Analyse der Analyse ausführen kann. Es ist im Wesentlichen ein Rahmen für das Experimentieren mit verschiedenen Parametern, die wir an die Pipeline übergeben können. Hier ist beispielsweise, wie wir ein Szenario für das Durchschnittsalter mit der Eingabe des Geschlechtsfilters vorbereiten.

def compute_avg_age(filtered_df: pd.DataFrame, gender_filter: str) -> float:
    information = (
        filtered_df
        if gender_filter == "All"
        else filtered_df(filtered_df("sex_label") == gender_filter)
    )
    return spherical(information("age").imply(), 1) if not information.empty else 0

filtered_df_cfg = Config.configure_data_node("filtered_df")
gender_filter_cfg = Config.configure_data_node("gender_filter")
avg_age_cfg = Config.configure_data_node("avg_age")

task_cfg = Config.configure_task(
    "compute_avg_age", compute_avg_age, (filtered_df_cfg, gender_filter_cfg), avg_age_cfg
)
scenario_cfg = Config.configure_scenario("cardiac_scenario", (task_cfg))
Config.export("config.toml")

Wir werden das Szenario später noch einmal besuchen, aber lassen Sie uns die Auswahl der Geschlechter selbst und seinen Standardzustand vorbereiten.

gender_lov = ("All", "Male", "Feminine")
gender_selected = "All"
filtered_df = df_raw.copy()
pie_fig = px.pie()
box_fig = px.field()
avg_age = 0

Als nächstes erstellen wir die Funktionen, die unsere Variablen und Datenvisualisierungen aktualisieren, wenn ein Benutzer mit dem Dashboard interagiert, z. B. durch Auswahl eines Geschlechts oder ein Senden eines Szenarios.

def update_dash(state):
    subset = (
        df_raw if state.gender_selected == "All"
        else df_raw(df_raw("sex_label") == state.gender_selected)
    )
    state.filtered_df = subset
    state.avg_age = spherical(subset("age").imply(), 1) if not subset.empty else 0

    state.pie_fig = px.pie(
        subset.groupby("sex_label")("goal").rely().reset_index(title="rely"),
        names="sex_label", values="rely",
        title=f"Goal Rely -- {state.gender_selected}"
    )
    state.box_fig = px.field(subset, x="sex_label", y="chol", title="Ldl cholesterol by Gender")

def save_scenario(state):
    state.state of affairs.filtered_df.write(state.filtered_df)
    state.state of affairs.gender_filter.write(state.gender_selected)
    state.refresh("state of affairs")
    tp.gui.notify(state, "s", "State of affairs saved -- undergo compute!")

Mit den Funktionen werden wir das Entrance-Finish-Dashboard mit einer einfachen Komposition mit dem folgenden Code vorbereiten:

with tgb.Web page() as web page:
    tgb.textual content("# Cardiac Arrest Dashboard")
    tgb.selector(worth="{gender_selected}", lov="{gender_lov}",
                 label="Choose Gender:", on_change=update_dash)

    with tgb.format(columns="1 1", hole="20px"):
        tgb.chart(determine="{pie_fig}")
        tgb.chart(determine="{box_fig}")

    tgb.textual content("### Common Age (Stay): {avg_age}")
    tgb.desk(information="{filtered_df}", pagination=True)

    tgb.textual content("---")
    tgb.textual content("## State of affairs Administration")
    tgb.scenario_selector("{state of affairs}")
    tgb.selector(label="State of affairs Gender:", lov="{gender_lov}",
                 worth="{gender_selected}", on_change=save_scenario)
    tgb.state of affairs("{state of affairs}")
    tgb.scenario_dag("{state of affairs}")
    tgb.textual content("**Avg Age (State of affairs):**")
    tgb.data_node("{state of affairs.avg_age}")
    tgb.desk(information="{filtered_df}", pagination=True)

Das Dashboard oben ist einfach, wird sich jedoch je nach Auswahl ändern, die wir treffen.

Zuletzt werden wir den Orchestrierungsprozess mit dem folgenden Code vorbereiten:

if __name__ == "__main__":
    tp.Orchestrator().run()
    state of affairs = tp.create_scenario(scenario_cfg)
    state of affairs.filtered_df.write(df_raw)
    state of affairs.gender_filter.write("All")
    Gui(web page).run(title="Cardiac Arrest Dashboard", dark_mode=True)

Sobald Sie den Code fertig haben, werden wir das Dashboard mit dem folgenden Befehl ausführen:

Automatisch wird das Dashboard in Ihrem Browser angezeigt. Beispielsweise finden Sie hier ein einfaches Herzstillstands -Dashboard mit den Visualisierungen und der Auswahl der Geschlechter.

Wenn Sie nach unten scrollen, wird die Szenario -Pipeline angezeigt. Sie können versuchen, das Geschlecht auszuwählen und das Szenario einzureichen, um die Unterschiede im Durchschnittsalter zu erkennen.

So können Sie ein Slick Knowledge Dashboard mit nur wenigen Komponenten erstellen. Erforschen Sie Taipy -Dokumentation Fügen Sie Visualisierungen und Funktionen hinzu, die für Ihre Dashboard -Anforderungen geeignet sind.

# Einpacken

Daten sind eine Ressource, die jedes Unternehmen benötigt, aber es ist schwieriger, Einblicke aus den Daten zu gewinnen, wenn es nicht visualisiert wird. In diesem Artikel haben wir ein elegantes Daten Dashboard mit Python, Taipy und Google Sheets erstellt. Wir haben gezeigt, wie man eine Verbindung zu Daten von Google Sheets herstellt und die Taipy -Bibliothek nutzt, um ein interaktives Dashboard zu erstellen.

Ich hoffe das hat geholfen!

Cornellius Yudha Wijaya ist ein Knowledge Science Assistant Supervisor und Datenautor. Während er in Vollzeit bei Allianz Indonesien arbeitet, liebt er es, Python- und Datentipps über soziale Medien und das Schreiben von Medien zu teilen. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.