app = sprint.Sprint(__name__, external_stylesheets=(dbc.themes.BOOTSTRAP))


app.format = dbc.Container((
   dbc.Row((
       dbc.Col((
           html.H1(" Superior Monetary Dashboard", className="text-center mb-4"),
           html.P(f"Interactive dashboard with {len(df)} information factors throughout {len(stock_names)} shares",
                  className="text-center text-muted"),
           html.Hr()
       ))
   )),
  
   dbc.Row((
       dbc.Col((
           dbc.Card((
               dbc.CardBody((
                   html.H5(" Dashboard Controls", className="card-title"),
                  
                   html.Label("Choose Shares:", className="fw-bold mt-3"),
                   dcc.Dropdown(
                       id='stock-dropdown',
                       choices=({'label': f'{inventory} ({base_prices(inventory)})', 'worth': inventory}
                               for inventory in stock_names),
                       worth=('AAPL', 'GOOGL'), 
                       multi=True,
                       placeholder="Select shares to research..."
                   ),
                  
                   html.Label("Date Vary:", className="fw-bold mt-3"),
                   dcc.DatePickerRange(
                       id='date-picker-range',
                       start_date="2023-06-01",
                       end_date="2024-06-01",
                       display_format="YYYY-MM-DD",
                       fashion={'width': '100%'}
                   ),
                  
                   html.Label("Chart Type:", className="fw-bold mt-3"),
                   dcc.RadioItems(
                       id='chart-type',
                       choices=(
                           {'label': ' Line Chart', 'worth': 'line'},
                           {'label': ' Space Chart', 'worth': 'space'},
                           {'label': ' Scatter Plot', 'worth': 'scatter'}
                       ),
                       worth="line",
                       labelStyle={'show': 'block', 'margin': '5px'}
                   ),
                  
                   dbc.Guidelines(
                       id='show-ma',
                       choices=({'label': ' Present Shifting Common', 'worth': 'present'}),
                       worth=(),
                       fashion={'margin': '10px 0'}
                   ),
               ))
           ), className="h-100")
       ), width=3),
      
       dbc.Col((
           dbc.Card((
               dbc.CardHeader(" Inventory Value Evaluation"),
               dbc.CardBody((
                   dcc.Graph(id='main-chart', fashion={'top': '450px'})
               ))
           ))
       ), width=9)
   ), className="mb-4"),
  
   dbc.Row((
       dbc.Col((
           dbc.Card((
               dbc.CardBody((
                   html.H4(id="avg-price", className="text-primary mb-0"),
                   html.Small("Common Value", className="text-muted")
               ))
           ))
       ), width=3),
       dbc.Col((
           dbc.Card((
               dbc.CardBody((
                   html.H4(id="total-volume", className="text-success mb-0"),
                   html.Small("Complete Quantity", className="text-muted")
               ))
           ))
       ), width=3),
       dbc.Col((
           dbc.Card((
               dbc.CardBody((
                   html.H4(id="price-range", className="text-info mb-0"),
                   html.Small("Value Vary", className="text-muted")
               ))
           ))
       ), width=3),
       dbc.Col((
           dbc.Card((
               dbc.CardBody((
                   html.H4(id="data-points", className="text-warning mb-0"),
                   html.Small("Information Factors", className="text-muted")
               ))
           ))
       ), width=3)
   ), className="mb-4"),
  
   dbc.Row((
       dbc.Col((
           dbc.Card((
               dbc.CardHeader(" Buying and selling Quantity"),
               dbc.CardBody((
                   dcc.Graph(id='volume-chart', fashion={'top': '300px'})
               ))
           ))
       ), width=6),
       dbc.Col((
           dbc.Card((
               dbc.CardHeader(" Returns Distribution"),
               dbc.CardBody((
                   dcc.Graph(id='returns-chart', fashion={'top': '300px'})
               ))
           ))
       ), width=6)
   ), className="mb-4"),
  
   dbc.Row((
       dbc.Col((
           dbc.Card((
               dbc.CardHeader(" Newest Inventory Information"),
               dbc.CardBody((
                   dash_table.DataTable(
                       id='data-table',
                       columns=(
                           {'title': 'Inventory', 'id': 'Inventory'},
                           {'title': 'Date', 'id': 'Date'},
                           {'title': 'Value ($)', 'id': 'Value', 'kind': 'numeric',
                            'format': {'specifier': '.2f'}},
                           {'title': 'Quantity', 'id': 'Quantity', 'kind': 'numeric',
                            'format': {'specifier': ',.0f'}},
                           {'title': 'Every day Return (%)', 'id': 'Returns', 'kind': 'numeric',
                            'format': {'specifier': '.2%'}}
                       ),
                       style_cell={'textAlign': 'middle', 'fontSize': '14px', 'padding': '10px'},
                       style_header={'backgroundColor': 'rgb(230, 230, 230)', 'fontWeight': 'daring'},
                       style_data_conditional=(
                           {
                               'if': {'filter_query': '{Returns} > 0'},
                               'backgroundColor': '#d4edda'
                           },
                           {
                               'if': {'filter_query': '{Returns} < 0'},
                               'backgroundColor': '#f8d7da'
                           }
                       ),
                       page_size=15,
                       sort_action="native",
                       filter_action="native"
                   )
               ))
           ))
       ))
   ))
), fluid=True)

Bild von Editor | Chatgpt

# Einführung

Daten sind die wichtigste Ressource eines Unternehmens, und Einblicke aus Daten könnten den Unterschied zwischen Gewinn und Misserfolg ausmachen. Rohdaten sind jedoch schwer zu verstehen, daher visualisieren wir sie in Dashboards, sodass nichttechnische Menschen sich besser navigieren können.

Das Erstellen eines Armaturenbretts ist nicht einfach, insbesondere bei der Arbeit mit JSON -Daten. Glücklicherweise können viele Python -Bibliotheken kombiniert werden, um ein hilfreiches Software zu erstellen.

In diesem Artikel lernen wir, wie Sie ein Dashboard mit Streamlit und Plotly entwickeln, um Duckdb -Abfragen zu Daten aus einer JSON -Datei zu visualisieren.

Neugierig? Lassen Sie uns darauf eingehen.

# Dashboard -Entwicklung

Lassen Sie uns vor der Entwicklung unseres Dashboard ein wenig über die Instruments lernen, die wir verwenden werden.

Zunächst ist JSON oder JavaScript-Objektnotation ein textbasiertes Format zum Speichern und Übertragen von Daten mithilfe von Schlüsselwertpaaren und -Arrays. Es ist ein häufig verwendetes Format für APIs und Datenaustausch zwischen Systemen.

Nächste, Duckdb ist ein Open-Supply-RDBMS (Relational Database Administration System) für analytische Workloads. Es handelt sich um eine SQL-Datenbank (On-line Analytical Processing) in Course of, die direkt im Python-Prozess ausgeführt wird, ohne dass ein separater Server verwaltet werden muss. Es ist auch für die schnelle Ausführung optimiert, best für die Datenanalyse mit großen Datensätzen.

Straffung wird oft für die Dashboardentwicklung verwendet. Es ist ein Open-Supply-Framework für die Entwicklung interaktiver Daten-Webanwendungen mithilfe von Python. Um das Dashboard zu entwickeln, müssen wir HTML, CSS oder JavaScript nicht verstehen.

Wir werden auch verwenden Pandaseine leistungsstarke Bibliothek für Datenmanipulation und -analyse in Python.

Schließlich, Handlung ist eine Open-Supply-Bibliothek zur Entwicklung interaktiver Diagramme und Diagramme. Es kann in das Dashboard -Entwicklungsbibliotheken wie Streamlit integriert werden.

Das ist die grundlegende Erklärung der Instruments, die wir verwenden werden. Beginnen wir mit der Entwicklung unseres JSON -Dashboards. Wir werden die folgende Struktur verwenden. Versuchen Sie additionally, sie wie folgt zu erstellen.

JSON_Dashboard/
├── information/
│   └── pattern.json
├── app.py
└── necessities.txt

Füllen wir als nächstes die Dateien mit allen erforderlichen Informationen aus. Lassen Sie uns zunächst unsere JSON -Beispieldaten wie die folgenden haben. Sie können immer Ihre eigenen Daten verwenden, aber hier ist ein Beispiel, das Sie verwenden können.

(
  {"id": 1, "class": "Electronics", "area": "North", "gross sales": 100, "revenue": 23.5, "date": "2024-01-15"},
  {"id": 2, "class": "Furnishings", "area": "South", "gross sales": 150, "revenue": 45.0, "date": "2024-01-18"},
  {"id": 3, "class": "Electronics", "area": "East", "gross sales": 70, "revenue": 12.3, "date": "2024-01-20"},
  {"id": 4, "class": "Clothes", "area": "West", "gross sales": 220, "revenue": 67.8, "date": "2024-01-25"},
  {"id": 5, "class": "Furnishings", "area": "North", "gross sales": 130, "revenue": 38.0, "date": "2024-02-01"},
  {"id": 6, "class": "Clothes", "area": "South", "gross sales": 180, "revenue": 55.2, "date": "2024-02-05"},
  {"id": 7, "class": "Electronics", "area": "West", "gross sales": 90, "revenue": 19.8, "date": "2024-02-10"},
  {"id": 8, "class": "Furnishings", "area": "East", "gross sales": 160, "revenue": 47.1, "date": "2024-02-12"},
  {"id": 9, "class": "Clothes", "area": "North", "gross sales": 200, "revenue": 62.5, "date": "2024-02-15"},
  {"id": 10, "class": "Electronics", "area": "South", "gross sales": 110, "revenue": 30.0, "date": "2024-02-20"}
)

Als nächstes werden wir die füllen necessities.txt Datei mit den Bibliotheken, die wir für unsere Dashboard -Entwicklung verwenden.

streamlit
duckdb
pandas
plotly

Führen Sie dann den folgenden Code aus, um die erforderlichen Bibliotheken zu installieren. Es wird empfohlen, eine virtuelle Umgebung bei der Einrichtung der Umgebung zu nutzen.

pip set up -r necessities.txt

Sobald alles fertig ist, werden wir unser Dashboard entwickeln. Wir werden den Anwendungscode schrittweise untersuchen, damit Sie der Logik befolgen können.

Beginnen wir zunächst die erforderlichen Bibliotheken für unser Dashboard importieren.

import streamlit as st
import duckdb
import pandas as pd
import plotly.specific as px

Als nächstes werden wir die Verbindung einrichten, die wir brauchen, um sich zu duckdb zu machen.

@st.cache_resource
def get_conn():
    return duckdb.join()

Der obige Code wird die Duckdb -Verbindung zwischengespeichert, sodass das Streamlit -Dashboard bei der Wiederholung des Dashboards nicht wieder verbunden werden muss, was eine Leistungsverzögerung vermeidet.

Anschließend bereiten wir den Code vor, um die JSON -Daten mit dem folgenden Code zu lesen.

@st.cache_data
def load_data(path):
    df = pd.read_json(path, convert_dates=("date"))
    return df

Im obigen Code transformieren wir die JSON -Datei in ein Pandas DataFrame und zwischen den Daten zwischenstrahlen, damit wir sie nicht erneut lesen müssen, wenn sich der Filter ändert.

Nachdem das Laden und die Verbindung der Daten fertig sind, stellen wir eine Verbindung zu Duckdb her, um die JSON -Daten zu speichern. Sie können jederzeit den Datenort und den Tabellennamen ändern.

conn = get_conn()
df_full = load_data("information/pattern.json")
conn.execute("CREATE OR REPLACE TABLE gross sales AS SELECT * FROM df_full")

Im obigen Code registrieren wir die DataFrame als SQL -Tabelle benannt gross sales Inside Duckdb. Die Tabelle wird in jedem Wiederholungsverkauf aus dem Speicher aktualisiert, da wir keine Persistenz in einem separaten Skript einrichten.

Das ist alles für das Backend; Bereiten wir das stromlitische Dashboard vor. Bereiten wir zunächst den Dashboard -Titel und die Seitenleistenfilter vor.

st.title("From JSON to Dashboard: DuckDB SQL Visualizer")

st.sidebar.header("Filter Choices")
class = st.sidebar.multiselect("Choose Class:", df_full('class').distinctive())
area = st.sidebar.multiselect("Choose Area:", df_full('area').distinctive())
date_range = st.sidebar.date_input("Choose Date Vary:", (df_full('date').min(), df_full('date').max()))

Die obige Seitenleiste wird zu einem dynamischen Filter für die geladenen Daten, bei denen wir die SQL -Abfrage basierend auf diesen Filtern ändern können.

Wir erstellen dann die SQL -Abfrage gemäß den Filtern mit dem folgenden Code.

question = "SELECT * FROM gross sales WHERE TRUE"
if class:
    question += f" AND class IN {tuple(class)}"
if area:
    question += f" AND area IN {tuple(area)}"
question += f" AND date BETWEEN '{date_range(0)}' AND '{date_range(1)}'"

Die obige Abfrage ist dynamisch auf der Grundlage der Auswahl des Benutzers erstellt. Wir beginnen mit einem WHERE TRUE Bedingung zur Vereinfachung der Anhänge zusätzliche Filter mit AND.

Mit der Abfragegenerierung werden wir die Abfrage und die resultierenden Daten mit dem folgenden Code zeigen.

st.subheader("Generated SQL Question")
st.code(question, language="sql")

df = conn.execute(question).df()
st.subheader(f"Question Outcomes: {len(df)} rows")
st.dataframe(df)

Der obige Code zeigt die SQL -Abfrage zum Abrufen von Daten aus Duckdb und konvertiert das Ergebnis in ein Pandas DataFrame zum Anzeigen der gefilterten Tabelle.

Zuletzt werden wir die Plotly -Visualisierungen anhand der gefilterten Daten vorbereiten.

if not df.empty:
    col1, col2 = st.columns(2)

    with col1:
        st.markdown("### Scatter Plot: Gross sales vs Revenue by Area")
        scatter_fig = px.scatter(df, x="gross sales", y="revenue", colour="area", hover_data=("class", "date"))
        st.plotly_chart(scatter_fig, use_container_width=True)

    with col2:
        st.markdown("### Bar Chart: Whole Gross sales by Class")
        bar_fig = px.bar(df.groupby("class", as_index=False)("gross sales").sum(), x="class", y="gross sales", text_auto=True)
        st.plotly_chart(bar_fig, use_container_width=True)

    st.markdown("### Line Chart: Each day Gross sales Development")
    line_fig = px.line(df.groupby("date", as_index=False)("gross sales").sum(), x="date", y="gross sales")
    st.plotly_chart(line_fig, use_container_width=True)
else:
    st.warning("No information discovered for the chosen filters.")

Im obigen Code erstellen wir drei verschiedene Diagramme: ein Streudiagramm, ein Balkendiagramm und ein Zeilendiagramm. Sie können den Diagrammtyp jederzeit entsprechend Ihren Anforderungen wechseln.

Mit all dem Code werden wir den folgenden Befehl ausführen, um unser Streamlit -Dashboard zu starten.

Sie können jetzt auf das Dashboard zugreifen, das wie das Bild unten aussieht.

Die Diagramme sehen wie das Bild unten aus.

Da die Visualisierungen Plotly verwenden, können Sie sie interaktiv navigieren, wie in der folgenden Zeilenkarte gezeigt.

Das ist alles, was Sie wissen müssen. Sie können dem Dashboard immer mehr Komplexität verleihen und es sogar in Ihrem Unternehmen einsetzen.

# Abschluss

Daten sind die wertvollste Ressource, die ein Unternehmen haben kann, und die Visualisierung in einem Dashboard ist eine Möglichkeit für Geschäftsleute, Einblicke zu gewinnen. In diesem Artikel haben wir gelernt, wie man ein einfaches Dashboard mit Strom und Handlung entwickelt und gleichzeitig eine Verbindung zu Daten aus einer in Duckdb gespeicherten JSON -Datei herstellt.

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.

Bild von Autor | Chatgpt

Einführung

Das Erstellen interaktiver webbasierter Daten-Dashboards in Python ist einfacher als je zuvor, wenn Sie die Stärken von kombinieren StraffungAnwesend PandasUnd Handlung. Diese drei Bibliotheken arbeiten nahtlos zusammen, um statische Datensätze in reaktionsschnelle, visuell ansprechende Anwendungen umzuwandeln – alle, ohne einen Hintergrund in der Webentwicklung zu benötigen.

Es gibt jedoch einen wichtigen architektonischen Unterschied zu verstehen, bevor wir beginnen. Im Gegensatz zu Bibliotheken wie Matplotlib oder Seeborn, die direkt in Jupyter -Notebooks arbeiten, erstellt Streamlit eigenständige Webanwendungen, die aus der Befehlszeile ausgeführt werden müssen. Sie schreiben Ihren Code in eine textbasierte IDE wie VS-Code, speichern Sie ihn als a .Py -Dateiund führen Sie es mit streamlit run Filename.py. Diese Verschiebung von der Pocket book-Umgebung zur skriptbasierten Entwicklung eröffnet neue Möglichkeiten zum Teilen und Bereitstellen Ihrer Datenanwendungen.

In diesem praktischen Tutorial lernen Sie, wie Sie ein komplettes Verkaufs-Dashboard aufbauen können zwei klare Schritte. Wir beginnen mit der Kernfunktionalität mit nur Streamlit und Pandas und verbessern dann das Dashboard mit interaktiven Visualisierungen mithilfe von Plotly.

Aufstellen

Installieren Sie die erforderlichen Pakete:

pip set up streamlit pandas plotly

Erstellen Sie einen neuen Ordner für Ihr Projekt und öffnen Sie ihn in VS -Code (oder Ihrem bevorzugten Texteditor).

Schritt 1: Stromverschluss + Pandas Dashboard

Beginnen wir damit, ein funktionales Dashboard mit nur Stromversorgung und Pandas zu erstellen. Dies zeigt, wie streamlit interaktive Internet -Schnittstellen erstellt und wie Pandas die Datenfilterung umgeht.

Erstellen Sie eine Datei aufgerufen STEP1_Dashboard_Basic.py:

import streamlit as st
import pandas as pd
import numpy as np

# Web page config
st.set_page_config(page_title="Primary Gross sales Dashboard", structure="broad")

# Generate pattern information
np.random.seed(42)
df = pd.DataFrame({
    'Date': pd.date_range('2024-01-01', intervals=100),
    'Gross sales': np.random.randint(500, 2000, dimension=100),
    'Area': np.random.alternative(('North', 'South', 'East', 'West'), dimension=100),
    'Product': np.random.alternative(('Product A', 'Product B', 'Product C'), dimension=100)
})

# Sidebar filters
st.sidebar.title('Filters')
areas = st.sidebar.multiselect('Choose Area', df('Area').distinctive(), default=df('Area').distinctive())
merchandise = st.sidebar.multiselect('Choose Product', df('Product').distinctive(), default=df('Product').distinctive())

# Filter information
filtered_df = df((df('Area').isin(areas)) & (df('Product').isin(merchandise)))

# Show metrics
col1, col2, col3 = st.columns(3)
col1.metric("Whole Gross sales", f"${filtered_df('Gross sales').sum():,}")
col2.metric("Common Gross sales", f"${filtered_df('Gross sales').imply():.0f}")
col3.metric("Information", len(filtered_df))

# Show filtered information
st.subheader("Filtered Information")
st.dataframe(filtered_df)

Lassen Sie uns die hier verwendeten wichtigen Stromversorgungsmethoden aufschlüsseln:

• St.Set_Page_Config () Konfiguriert den Registerkarte und Format des Browsers
• St.SideBar Erstellt das linke Navigationspanel für Filter
• St. Multiselect () Generiert Dropdown -Menüs für Benutzerauswahl
• St.Columns () Erstellt nebeneinander Layoutabschnitte
• St.Metric () Zeigt große Zahlen mit Etiketten an
• St.Dataframe () Rendert interaktive Datentabellen

Diese Methoden verarbeiten automatisch Benutzerinteraktionen und lösen App -Updates, wenn sich die Auswahl ändert.

Führen Sie dies von Ihrem Terminal aus (oder integriertes Terminal des VS -Codes) aus:

streamlit run step1_dashboard_basic.py

Ihr Browser wird sich öffnen http: // localhost: 8501 Zeigen Sie ein interaktives Dashboard.

Versuchen Sie, die Filter in der Seitenleiste zu ändern – beobachten Sie, wie die Metriken und die Datentabelle automatisch aktualisieren! Dies zeigt die reaktive Natur von stromloses Kombination mit den Datenmanipulationsfunktionen von Pandas.

Schritt 2: Fügen Sie Plotly für interaktive Visualisierungen hinzu

Lassen Sie uns nun unser Dashboard verbessern, indem wir die interaktiven Diagramme von Plotly hinzufügen. Dies zeigt, wie alle drei Bibliotheken nahtlos zusammenarbeiten. Erstellen wir eine neue Datei und rufen Sie sie an STEP2_Dashboard_Plotly.py:

import streamlit as st
import pandas as pd
import plotly.categorical as px
import numpy as np

# Web page config
st.set_page_config(page_title="Gross sales Dashboard with Plotly", structure="broad")

# Generate information
np.random.seed(42)
df = pd.DataFrame({
    'Date': pd.date_range('2024-01-01', intervals=100),
    'Gross sales': np.random.randint(500, 2000, dimension=100),
    'Area': np.random.alternative(('North', 'South', 'East', 'West'), dimension=100),
    'Product': np.random.alternative(('Product A', 'Product B', 'Product C'), dimension=100)
})

# Sidebar filters
st.sidebar.title('Filters')
areas = st.sidebar.multiselect('Choose Area', df('Area').distinctive(), default=df('Area').distinctive())
merchandise = st.sidebar.multiselect('Choose Product', df('Product').distinctive(), default=df('Product').distinctive())

# Filter information
filtered_df = df((df('Area').isin(areas)) & (df('Product').isin(merchandise)))

# Metrics
col1, col2, col3 = st.columns(3)
col1.metric("Whole Gross sales", f"${filtered_df('Gross sales').sum():,}")
col2.metric("Common Gross sales", f"${filtered_df('Gross sales').imply():.0f}")
col3.metric("Information", len(filtered_df))

# Charts
col1, col2 = st.columns(2)

with col1:
    fig_line = px.line(filtered_df, x='Date', y='Gross sales', shade="Area", title="Gross sales Over Time")
    st.plotly_chart(fig_line, use_container_width=True)

with col2:
    region_sales = filtered_df.groupby('Area')('Gross sales').sum().reset_index()
    fig_bar = px.bar(region_sales, x='Area', y='Gross sales', title="Whole Gross sales by Area")
    st.plotly_chart(fig_bar, use_container_width=True)

# Information desk
st.subheader("Filtered Information")
st.dataframe(filtered_df)

Führen Sie dies von Ihrem Terminal aus (oder integriertes Terminal des VS -Codes) aus:

streamlit run step2_dashboard_plotly.py

Jetzt haben Sie ein komplettes interaktives Dashboard!

Die Diagramme für Handlung sind vollständig interaktiv – Sie können über Datenpunkte schweben, bestimmte Zeiträume vergrößern und sogar auf Legendelemente klicken, um Datenreihen anzuzeigen/auszublenden.

Wie die drei Bibliotheken zusammenarbeiten

Diese Kombination ist leistungsstark, weil jede Bibliothek das umgeht, was sie am besten kann:

Pandas verwaltet alle Datenvorgänge:

• Erstellen und Laden von Datensätzen
• Filterungsdaten basierend auf Benutzerauswahlen
• Daten für Visualisierungen aggregieren
• Umgang mit Datenumwandlungen

Straffung Bietet die Webschnittstelle:

• Erstellt interaktive Widgets (Multiselect, Sliders usw.)
• Weitere die gesamte App erneut, wenn Benutzer mit Widgets interagieren
• Behandelt das reaktive Programmiermodell
• Verwaltet das Format mit Spalten und Containern

Handlung erstellt reichhaltige, interaktive Visualisierungen:

• Diagramme, die Benutzer schweben, zoomen und erkunden können
• Professionelle Diagramme mit minimalem Code
• Automatische Integration in die Reaktivität von Streamlit

Schlüsselentwicklungsworkflow

Der Entwicklungsprozess folgt einem einfachen Muster. Schreiben Sie zunächst Ihren Code in VS -Code oder einem Texteditor und speichern Sie ihn als .Py -Datei. Führen Sie als nächstes die Anwendung von Ihrem Terminal aus streamlit run Filename.pywas Ihr Dashboard in einem Browser öffnet http: // localhost: 8501. Während Sie Ihren Code bearbeiten und speichern, erkennt Streamlit automatisch Änderungen und bietet die Anwendung an. Sobald Sie mit Ihrem Dashboard zufrieden sind, können Sie es über die streamlit Group Cloud bereitstellen, um sie mit anderen zu teilen.

Nächste Schritte

Probieren Sie diese Verbesserungen aus:

Fügen Sie echte Daten hinzu:

# Substitute pattern information with CSV add
uploaded_file = st.sidebar.file_uploader("Add CSV", kind="csv")
if uploaded_file:
    df = pd.read_csv(uploaded_file)

Beachten Sie, dass echte Datensätze die für Ihre Datenstruktur spezifischen Vorverarbeitungsschritte erfordern. Sie müssen Spaltennamen anpassen, fehlende Werte verarbeiten und die Filteroptionen so ändern, dass sie Ihren tatsächlichen Datenfeldern entsprechen. Der Beispielcode enthält eine Vorlage, aber jeder Datensatz hat einzigartige Anforderungen für die Reinigung und Vorbereitung.

Weitere Diagrammtypen:

# Pie chart for product distribution
fig_pie = px.pie(filtered_df, values="Gross sales", names="Product", title="Gross sales by Product")
st.plotly_chart(fig_pie)

Sie können eine Ganze nutzen Galerie von Plotlys Grafikfunktionen.

Bereitstellen Ihres Dashboards

Sobald Ihr Dashboard lokal funktioniert, ist es unkompliziert, es mit anderen durch die streamlite Group -Cloud zu teilen. Drücken Sie zunächst Ihren Code in ein öffentliches Github -Repository und stellen Sie sicher, dass a einbezogen werden Anforderungen.txt Dateiauflistung Ihrer Abhängigkeiten (streamlit, pandas, plotly). Dann besuchen Sie https://streamlit.io/cloudMelden Sie sich mit Ihrem Github -Konto an und wählen Sie Ihr Repository aus. Streamlit erstellt und bereitstellt Ihre App automatisch und bereitet eine öffentliche URL bereit, auf die jeder zugreifen kann. Die kostenlose Stufe unterstützt mehrere Apps und behandelt angemessene Verkehrsladungen, wodurch es perfekt ist, um Dashboards mit Kollegen zu teilen oder Ihre Arbeit in einem Portfolio zu präsentieren.

Abschluss

Die Kombination von Stromlit, Pandas und Plotly verwandelt die Datenanalyse aus statischen Berichten in interaktive Webanwendungen. Mit nur zwei Python -Dateien und einer Handvoll Methoden haben Sie ein komplettes Dashboard erstellt, das teure Enterprise Intelligence -Instruments enthält.

Dieses Tutorial zeigt eine signifikante Verschiebung, wie Datenwissenschaftler ihre Arbeit teilen können. Anstatt statische Diagramme zu senden oder Kollegen zu verpflichten, Jupyter -Notizbücher auszuführen, können Sie jetzt Webanwendungen erstellen, die jeder über einen Browser verwenden kann. Der Übergang von der Pocket book-basierten Analyse zu skriptbasierten Anwendungen eröffnet Datenfachleuten neue Möglichkeiten, ihre Erkenntnisse zugänglicher und wirkungsvoller zu gestalten.

Überlegen Sie, wie interaktive Dashboards mit diesen Instruments mit diesen Instruments fortgesetzt werden können. Die gleichen Prinzipien, die Sie hier gelernt haben, skalieren Sie, um echte Datensätze, komplexe Berechnungen und ausgefeilte Visualisierungen zu verarbeiten. Unabhängig davon, ob Sie Government Dashboards, explorative Datenwerkzeuge oder Kundenanwendungen erstellen, bietet diese Drei-Bibliothek-Kombination eine solide Grundlage für professionelle Datenanwendungen.

Vinod wurde in Indien geboren und ist in Japan aufgewachsen. Er bringt eine globale Perspektive in die Bildung von Datenwissenschaft und maschinellem Lernen. Er überbrückt die Lücke zwischen aufstrebenden KI -Technologien und der praktischen Umsetzung für Berufstätige. Vinod konzentriert sich darauf, zugängliche Lernwege für komplexe Themen wie Agenten -KI, Leistungsoptimierung und KI -Engineering zu erstellen. Er konzentriert sich auf praktische Implementierungen für maschinelles Lernen und Mentoring der nächsten Era von Datenfachleuten durch Reside -Sitzungen und personalisierte Anleitung.

Gibt es etwas frustrierenderes, als ein leistungsstarkes Datenmodell zu erstellen, aber dann kann es sein, es zu einem Werkzeug zu verwandeln, um das gewünschte Ergebnis zu erzielen? Datenwissenschaft Hat noch nie potenziell geknüpft, ist aber auch nie kurz in der Komplexität. Sie können Algorithmen verfeinern, die auf kuratierten Datensätzen glänzen, aber dennoch der Hürde, sich von Prototypen und Notizbüchern zu Produktions -Apps zu bewegen. Dieser letzte Schritt, der oft als „letzte Meile“ bezeichnet wird, betrifft 80% der Datenwissenschaftsergebnisse und erfordert Lösungen, die Datenteams nicht überlasten.

Seit seiner Gründung im Jahr 2013 ist Plotly ein beliebtes Thema in Richtung Information Science (TDS), wo Mitwirkende haben Veröffentlichte über 100 Anleitungen in den Werkzeugen von Plotly. Diese stetige Ausgabe zeigt, wie viel die Information Science Neighborhood -Werte, die Code, Visualisierungen und interaktive Dashboards zusammenführen.

Der Chief Product Officer von Plotlys, Chris Parmer, hat immer die Idee eingesetzt, dass Analysten in der Lage sein sollten, „interaktive Apps zu spinnen, ohne ganze Internet -Frameworks zu ringen“. Diese Imaginative and prescient macht jetzt Plotlys neueste Veröffentlichung von Sprint Enterpriseso gestaltet, dass der Sprung vom Modell zu Daten-Apps von Produktionsqualität vereinfacht wird.

Die neuesten Innovationen von Plotly spiegeln eine Verschiebung der Datenwissenschaft auf zugängliche, produktionsbereite Instruments wider, mit denen Groups Einblicke in umsetzbare Lösungen machen können.

In diesem Artikel wird drei wichtige Fragen angesprochen:

• Was macht die letzte Meile in der Datenwissenschaft so herausfordernd?
• Welche Engpässe machen traditionelle Datenworkflows langsam und ineffizient?
• Und wie können Sie die KI -Funktionen von Plotly zum Erstellen, Teilen und Bereitstellen anwenden? Interaktive Daten -Apps Schneller?

Konfrontation mit dem letzten Meilenproblem

Die „letzte Meile“ in der Datenwissenschaft kann anstrengend sein. Möglicherweise verbringen Sie Monate damit, Modelle zu perfektionieren, nur um festzustellen, dass niemand außerhalb Ihres Analyse -Groups die Outputs vollständig versteht. Statische Notizbücher oder Advert-hoc-Skripte bieten selten die Interaktivität an, die Entscheidungsträger benötigen.

Einige Groups halten sich mit einem schnellen Proof of Idea mit einem Jupyter -Notizbuch oder einem einzelnen Skript zufrieden, in der Hoffnung, den Wert schnell anzuzeigen. Viele aktualisieren es nie, es sei denn, ein Unternehmen investiert in teure Infrastruktur. Kleinere Gruppen haben möglicherweise nicht die Zeit oder Ressourcen, um Prototypen in Instruments umzuwandeln, die die täglichen Entscheidungen beeinflussen.

In großen Unternehmen können Sicherheitsprotokolle, rollenbasierter Zugriff und kontinuierliche Bereitstellung zu mehr Komplexität führen. Diese Schichten können Sie in Rollen bringen, die der Entwicklung der Vollstapel sehr ähnlich aussehen, um Ihre Erkenntnisse den Stakeholdern vorzustellen. Die Verzögerungen stapeln sich, insbesondere wenn hochrangige Führungskräfte Stay -Szenarien testen möchten, müssen jedoch auf Codeänderungen warten, um neue Metriken zu sehen.

Die Groups müssen über isolierte Notizbücher und manuelle Workflows hinausgehen, um automatisierte, interaktive Instruments zu übernehmen, die Einblicke schneller in die Tat umsetzen. Plotly adressiert diesen Bedarf durch KI in Sprint einbetten.
Plotly Sprint ist ein Open -Supply -Python -Framework zum Erstellen interaktiver Webanwendungen für Analysen. Es vereinfacht den Prozess des Erstellens webbasierter Schnittstellen für die Datenanalyse und Präsentation, ohne umfangreiche Webentwicklungswissen zu erfordern.

Plotly Sprint Enterprise erweitert und erweitert das Open-Supply-Rahmen, um die Erstellung hoch entwickelter Produktionsanwendungen für die operative Entscheidungsfindung zu ermöglichen. Plotly Sprint Enterprise bietet Entwicklungsfunktionen sowie Plattform- und Sicherheitsfunktionen, die Unternehmen benötigen, z. B. KI, App Galerie, DevOps, Sicherheitsintegration, Caching und vieles mehr.

Die neueste Veröffentlichung von Sprint Enterprise automatisiert sich wiederholende Aufgaben, generiert Python -Code für Datenvisualisierungen und Apps und beschleunigt die Entwicklung in Plotly App Studio. Diese Verbesserungen befassen sich, sich auf die Verfeinerung von Modellen zu konzentrieren, Erkenntnisse zu verbessern und Apps zu liefern, die den Geschäftsanforderungen entsprechen.

Inside Sprint Enterprise: KI -Chat, Datenforscher und mehr

Plotlys neueste Veröffentlichung von Sprint Enterprise Stellt KI vorne und in der Mitte. Die Funktion „Plotly AI“ enthält eine Chat-Schnittstelle, die Ihre einfachen englischen Aufforderungen wie „Erstellen Sie ein Verkaufsprognose-Dashboard mithilfe unserer monatlichen SQL-Daten“ in den funktionalen Python-Code. Als erweiterter Benutzer können Sie diesen Code mit benutzerdefinierter Logik verfeinern. Wenn Sie weniger technisch sind, können Sie jetzt Prototypen erstellen, die einst spezielle Hilfe benötigt.

Parmer erklärtAnwesend

„Durch die Integration von Superior AI direkt in das Sprint strengen wir den gesamten Entwicklungsprozess. Sie können mit einer Idee oder einem Datensatz beginnen und sehen, dass eine funktionale Internet -App schneller als je zuvor erscheint.“

Sprint Enterprise führt außerdem einen Daten -Explorer -Modus ein, mit dem Sie Diagramme generieren, Filter anwenden und Parameter ändern können, ohne Code zu schreiben. Für Datenwissenschaftler, die einen direkten Code -Workflow bevorzugen, bietet es Flexibilität, automatisch generierte Komponenten zu verfeinern. Das Replace geht weiter mit integrierten SQL -Autorenzellen und einer einfacheren Einbettung von Apps und senkt den Abstand vom Konzept zur Produktion ab.

Die Benutzererfahrung macht in der neuesten Model von Sprint Enterprise über App Studio, eine GUI-basierte Umgebung zum Erstellen und Raffinieren von Sprint-Apps, einen großen Schritt weiter. Da das Großsprachmodell (LLM) Ihre Eingabeaufforderungen in den Python -Code umwandelt, ist dieser Code innerhalb der Schnittstelle vollständig sichtbar und bearbeitet. Es wird nie blockiert, den generierten Code direkt zu ändern oder auszuweiten, wodurch Sie die Flexibilität geben, jeden Aspekt Ihrer App zu optimieren.

Diese Mischung aus AI-unterstützten Entwicklung und zugänglichem Design bedeutet, dass Daten-Apps keine separaten Groups oder komplexen Frameworks mehr erfordern. Wie Parmer es ausdrückt:

Welches Sprint Enterprise bedeutet für Ihre Datenprojekte

Wenn Sie bereits einen etablierten Workflow haben, fragen Sie sich möglicherweise, warum diese Launch des Sprint Enterprise von Bedeutung ist. Selbst die genauesten Modelle können floppen, wenn Entscheidungsträger nicht mit den Ergebnissen interagieren können. Mit der neuen Veröffentlichung können Sie den Aufwand von Erstellung von Daten -Apps reduzieren und Erkenntnisse schneller liefern durch:

• Erstellen Sie reichere Visualisierungen, um tiefere Erkenntnisse mit interaktiven Diagrammen und Dashboards zu präsentieren, die sich an Ihre Datengeschichte anpassen. Sie können sehen, wie CIBC Quantitative Options Group Gebrauchtes Sprint Enterprise, um Analysten und Handelsschülern zu helfen, die auf ihre Bedürfnisse zugeschnittene Produktionsgrad-Apps zu entwickeln.
• Verwenden des neuen GUI-basierten App-Studio, um Daten-Apps zu erstellen, zu ändern und zu erweitern, ohne Code zu schreiben, und gleichzeitig auf Python zugreifen, um die vollständige Kontrolle zu erhalten. Das Experimententeam von Intuit verfolgte diesen Ansatz, um Instruments zu erstellen, die jetzt von mehr als 500 Mitarbeitern verwendet wurden, und reduzierte die Laufzeiten von Experiment um über 70 Prozent.
• Verwalten Sie komplexe Datensätze zuversichtlich, indem das Sprint Enterprise in Instruments wie Datenbanken integriert wird, um die Leistung als Datenskala aufrechtzuerhalten. S & P International Übernahm diesen Ansatz, um die Zeit zu verkürzen, die für die Einführung von Datenprodukten von Kunden von neun Monaten auf nur zwei benötigt wird.
• Hinzufügen von Sicherheit und Steuerung mit integrierten Sicherheitsfunktionen, Versionensteuerung und rollenbasiertem Zugriff auf den Schutz Ihrer Daten-Apps beim Wachstum. CIBC stützte sich auf diese Funktionen, um Anwendungen für Groups in verschiedenen Regionen einzusetzen, ohne die Sicherheit zu beeinträchtigen.

Wenn Sie sich in einem MLOPS -Staff befinden, ist es möglicherweise einfacher, Datenumwandlungen und Benutzerberechtigungen zusammenzuschließen. Dies ist bei Finanz-, Gesundheits- und Lieferkettenanalysen nicht verhandelbar, bei denen rechtzeitige Entscheidungen auf Stay-Daten beruhen. Durch die Reduzierung der für die Verwaltung von Pipelines erforderlichen manuellen Anstrengungen können Sie mehr Zeit mit dem Raffinieren von Modellen verbringen und Erkenntnisse schneller liefern.

Mit dem offenen und erweiterbaren Ansatz von Plotlys sind Sie nicht an Lieferanten-spezifische Algorithmen eingeschlossen. Stattdessen können Sie jedes Python-basierte ML-Modell- oder Analyse-Workflow direkt innerhalb des Dashs einbetten. Dieses Design hat sich als wertvoll erwiesen Datenbankwobei das Staff eine Beobachtbarkeitsanwendung zur Überwachung der Infrastrukturnutzung und der Kosten mithilfe von Plotly -Sprint aufbaute.

Groups bei Muschel und Bloomberg Außerdem übernahm Plotly Sprint Enterprise für Anwendungsfälle, die Datengovernance, Visualisierungen mit hoher Dichte, thematische Investitionen und vieles mehr umfassen-allmählich hervor, wie diese Funktionen Daten, AI und BI in einer Einzelbenutzererfahrung verbinden.

Additionally, was kommt als nächstes?

AI ändert sich, wie Datenanwendungen erstellt werden, Datenprodukte geliefert werden und Erkenntnisse geteilt werden. Plotly sitzt an der Kreuzung von App -Entwicklung, Datengeschichtenerzählen und Unternehmensbedürfnissen. Um zu sehen, wie Plotly diese Verschiebung anspricht, Sehen Sie sich das Begin -Webinar an Und bleiben Sie auf dem Laufenden für ein bevorstehendes eBook, das bewährte Strategien zum Aufbau intelligenter Daten -Apps mit KI abschließt.

Das Einbetten von KI in Sprint automatisiert Teile des Entwicklungsprozesses und erleichtert Daten-Apps für nichttechnische Groups. Die technischen Fähigkeiten und die nachdenkliche Planung bleiben jedoch der Schlüssel zum Aufbau zuverlässiger, praktischer Lösungen. Die Welt der Daten hat sich über verstreute Notizbücher und kurzlebige Prototypen hinausgezogen. Der Fokus liegt nun auf produktionsbereiten Lösungen, die sinnvolle Entscheidungen leiten. Da die KI rasch expandiert, die Kluft zwischen „Experimentelle Analyse“ Und „BetriebsentscheidungKann sich endlich einschränken – etwas, auf das viele von Ihnen gewartet haben.

Über unseren Sponsor
Plotly ist ein führender Anbieter von Open-Supply-Graphing-Bibliotheken und Analytics-Lösungen für Unternehmensqualität. Das Flaggschiff-Produkt Sprint Enterprise ermöglicht es Unternehmen, skalierbare und interaktive Daten-Apps zu erstellen, die die wirkungsvolle Entscheidungsfindung vorantreiben. Erfahren Sie mehr bei http://www.plotly.com.

Einfache Methoden zum Ersetzen von überfüllten Balkendiagrammen durch klare, leserfreundliche Bilder.

Die Statue kann in Weimar gefunden werden – parken Sie ein der Ilm (aber Shakespeare spricht offensichtlich nicht)

Willkommen im neunten Beitrag in meiner Serie „Plotly with Code“! Wenn Sie den ersten verpasst haben, können Sie ihn im Hyperlink unten überprüfen oder meine durchsuchen „Ein Beitrag, um sie alle zu regieren“ Um die gesamte Serie oder andere Themen zu verfolgen, über die ich zuvor geschrieben habe.

Eine kurze Zusammenfassung, warum ich diese Serie schreibe

Mein Go-to-Instrument zum Erstellen von Visualisierungen ist plottisch. Es ist unglaublich intuitiv, von Schichten von Spuren bis hin zu Interaktivität. Während sich Plotly bei der Funktionalität auszeichnet, wird sie jedoch nicht mit einer „Datenjournalismus“ -Schabrate ausgestattet, die polierte Diagramme direkt außerhalb der Field bietet.

Hier kommt diese Serie ins Spiel-ich werde teilen, wie man Plotlys Diagramme in schlanke, professionelle Charts umwandelt, die…

Und es wird nicht immer einfach von der höchsten zur niedrigsten Reihenfolge sortiert

10 Min. Lektüre

·

Vor 14 Stunden

Willkommen zum fünften Beitrag meiner „Plotly with Code“-Reihe! Wenn Sie den ersten Beitrag verpasst haben, können Sie ihn über den unten stehenden Hyperlink nachlesen oder meinen „Ein Beitrag, um sie alle zu beherrschen“ durchstöbern, um der gesamten Serie oder anderen Themen, über die ich zuvor geschrieben habe, zu folgen.

Eine kurze Zusammenfassung, warum ich diese Serie schreibe

Mein bevorzugtes Software zum Erstellen von Visualisierungen ist Plotly. Es ist unglaublich intuitiv, von der Schichtung von Spuren bis hin zum Hinzufügen von Interaktivität. Obwohl Plotly sich durch seine Funktionalität auszeichnet, verfügt es nicht über eine „Datenjournalismus“-Vorlage, die direkt nach dem Auspacken ausgefeilte Diagramme bietet.

Ein Balkendiagramm ist nicht immer die beste Lösung.

Datenvisualisierung spielt eine entscheidende Rolle dabei, wie Geschichten erzählt und verstanden werden. Ich struggle schon immer fasziniert von den eleganten, kommentierten Diagrammen, die im Datenjournalismus verwendet werden – diesen Visualisierungen, die komplexe Ideen sofort und für jedermann verständlich vermitteln können.

Ich struggle es auch tief inspiriert von Quellen wie dem Buch von Cole Nussbaumer Knaflic, Storytelling mit Daten (1), das wesentliche Greatest Practices für die Erstellung klarer, wirkungsvoller Visualisierungen bereitstellt und dabei einen minimalistischen Ansatz betont, der unnötige Elemente entfernt. Ihr Ansatz besteht darin, sich auf das Wesentliche zu konzentrieren und sicherzustellen, dass die Geschichte der Daten ohne Ablenkungen durchscheint.

Dann ist da noch AddTwoDigital, eine Digitalagentur, die sich mit Knowledge Storytelling beschäftigt. Sie haben eine Reihe von Blogbeiträgen zu Greatest Practices für die Datenvisualisierung als Open-Supply-Lösung veröffentlicht (2) und präsentiert alles von einfachen Balkendiagrammen bis hin zu komplexeren, umwerfenden Infografiken. Ihr Inhalt ist eine Fundgrube an Inspiration, und aus ihren Beispielen lässt sich immer etwas Neues lernen, das nicht in typischen Datenvisualisierungsbüchern enthalten ist.

Erstellen Sie interaktive Kalender mit Heatmaps mit Plotly

Plotly ist eine der umfassendsten Python-Bibliotheken zum Erstellen von Visualisierungen. Diese Bibliothek bietet viele vordefinierte Visualisierungen, die für die meisten Datenanalysen nützlich sind. Diese Visualisierungen sind hochgradig anpassbar, sodass wir bei der Visualisierung unserer Erkenntnisse kreativer sein und sogar neue Visualisierungen implementieren können.

In diesem Artikel erklären wir Schritt für Schritt, wie Sie mit Plotly einen Kalender erstellen, in dem alle Feiertage in Barcelona für 2024 visualisiert werden können. Der Kalender ist interaktiv und bietet durch Hover-Overs Informationen zu den verschiedenen Feiertagen in der Stadt. Wie der Artikel zeigt, verfügt Plotly zwar nicht über eine integrierte Visualisierung zum Erstellen von Kalendern, aber ausgehend von einer Heatmap und etwas Fantasie lässt sich diese Artwork der Visualisierung problemlos implementieren.

Kalender in Plotly ermöglichen mehr Anpassungsmöglichkeiten als solche, die mit vordefinierten Instruments erstellt werden. Darüber hinaus besteht einer der Hauptvorteile darin, dass sie in Jupyter-Notebooks integriert werden können, um beispielsweise zeitliche Analysen innerhalb dieser Notebooks durchzuführen. Darüber hinaus können Hover-Overs entsprechend den Anforderungen unserer Analyse angepasst werden. Ein weiterer großer Vorteil im Vergleich zu vordefinierten Instruments ist, dass Plotly völlig kostenlos ist…

Einführung

Radardiagramme, auch Spinnendiagramme oder Sterndiagramme genannt, bieten eine besondere Methode zur Visualisierung multivariater Daten. Im Gegensatz zu herkömmlichen kartesischen Diagrammen, bei denen die Achsen linear angeordnet sind, sind die Achsen bei Radardiagrammen radial um einen Mittelpunkt angeordnet. Diese kreisförmige Anordnung erleichtert den gleichzeitigen Vergleich mehrerer quantitativer Variablen über verschiedene Kategorien oder Dimensionen hinweg, wodurch Radardiagramme sehr nützlich sind, um Muster und Beziehungen innerhalb komplexer Datensätze aufzudecken.

Überblick

• Verstehen Sie das grundlegende Konzept und die Struktur von Radardiagrammen.
• Erlernen Sie die Erstellung von Radardiagrammen mit Plotly in Python.
• Erlernen Sie erweiterte Anpassungstechniken zur Verbesserung der Radardiagrammvisualisierungen.
• Entwickeln Sie Fähigkeiten, um Radardiagramme für vergleichende Analysen effektiv zu interpretieren.
• Erkunden Sie die Anwendung von Radardiagrammen in verschiedenen Kontexten wie Leistungsbewertung und Produktvergleich.

Verwenden von Plotly für Radardiagramme

Plotly Categorical bietet eine einfache Schnittstelle zum Erstellen von Radardiagrammen in Python. Es nutzt die Funktion „px.line_polar“, um Datenpunkte um die Kreisachsen herum zu zeichnen, was eine einfache Anpassung und Interaktivität ermöglicht.

import plotly.specific as px
import pandas as pd
# Instance knowledge
df = pd.DataFrame(dict(
   r=(3, 4, 2, 5, 4), 
   theta=('Class 1', 'Class 2', 'Class 3', 'Class 4', 'Class 5')
))
# Making a radar chart with Plotly Categorical
fig = px.line_polar(df, r="r", theta="theta", line_close=True)
fig.update_traces(fill="toself")  # Fill space inside traces
fig.present()

Radardiagramme verbessern

Um Radardiagrammen mehr Tiefe zu verleihen, ermöglicht Plotly Anpassungen wie ausgefüllte Bereiche (`fill=’toself’`), um die eingeschlossenen Bereiche zwischen Datenpunkten hervorzuheben. Diese Funktion trägt zur visuellen Klarheit bei und betont die relativen Stärken oder Werte verschiedener Variablen.

Lesen Sie auch: Ein umfassender Leitfaden zur Datenvisualisierung in Python

Erweiterte Radardiagramme mit mehreren Spuren

Für vergleichende Analysen ermöglicht die Funktion „go.Scatterpolar“ von Plotly die Erstellung von Radardiagrammen mit mehreren Spuren. Jede Spur stellt einen bestimmten Datensatz oder eine bestimmte Kategorie dar und ermöglicht so einen direkten Vergleich von Variablen wie Kosten, Stabilität und Integration über verschiedene Produkte oder Szenarien hinweg.

import plotly.graph_objects as go
classes = ('Category1', 'Category2', 'Category3',
             'Category4', 'Category5')
fig = go.Determine()
# Including traces for various merchandise
fig.add_trace(go.Scatterpolar(
   r=(1, 5, 2, 2, 3),
   theta=classes,
   fill="toself",
   title="Product A"
))

fig.add_trace(go.Scatterpolar(
   r=(4, 3, 2.5, 1, 2),
   theta=classes,
   fill="toself",
   title="Product B"
))
fig.update_layout(
   polar=dict(
       radialaxis=dict(
           seen=True,
           vary=(0, 5)  # Regulate vary primarily based on knowledge
       )
   ),
   showlegend=True
)

fig.present()

Abschluss

Radardiagramme sind ein wichtiges Software zur Visualisierung komplexer Daten über mehrere Variablen hinweg. Sie eignen sich hervorragend zum Vergleichen von Produkteigenschaften, Bewerten von Leistungsmetriken und Untersuchen von Umfragefeedback in verschiedenen Dimensionen. Sie bieten einen strukturierten Rahmen, der den gleichzeitigen Vergleich verschiedener Dimensionen ermöglicht. Egal, ob Sie Produkteigenschaften untersuchen, Leistungsmetriken bewerten oder Umfrageantworten analysieren, Radardiagramme bieten eine prägnante Möglichkeit, komplexe Informationen darzustellen.

Meistern Sie Python für Knowledge Science mit unserem Einführung in Python Programm!

Häufig gestellte Fragen