So zeichnen Sie 3D-Grafiken mit Python und Plotly

Das Open-Source-Community-Team China machte seine erste Live-Übertragung und erzählte im Namen des Teilens die Geschichte hinter der Open-Source-Community China.“

Dieser Artikel wurde von der Huawei Cloud Community „ Plotly Drawing 3D Graphics “ von Lemony Hug geteilt.

Im Bereich der Datenvisualisierung sind 3D-Grafiken ein leistungsstarkes Werkzeug zur Darstellung komplexer Zusammenhänge und Strukturen zwischen Daten. Die Python-Sprache verfügt über eine umfangreiche Datenvisualisierungsbibliothek, darunter Plotly, ein beliebtes Tool, das die Funktion zum Zeichnen hochwertiger dreidimensionaler Grafiken bietet. In diesem Artikel wird erläutert, wie Sie mit Python und Plotly verschiedene Arten von 3D-Grafiken zeichnen, und es werden Codebeispiele gegeben.

Vorbereitung

Stellen Sie zunächst sicher, dass Sie die Plotly-Bibliothek installiert haben. Sie können den Befehl pip verwenden, um Folgendes zu installieren:

pip plotly installieren

Als Nächstes verwenden wir plotly.graph_objectsdie Module von Plotly, um 3D-Grafiken zu erstellen. Wir werden numpydie Bibliothek auch verwenden, um einige Beispieldaten zu generieren.

importiere plotly.graph_objects als go
numpy als np importieren

Zeichnen Sie ein Streudiagramm

Zuerst zeichnen wir ein einfaches Streudiagramm. Angenommen, wir haben einige dreidimensionale Daten in x_data, y_dataund gespeichert z_data.

# Beispieldaten generieren
np.random.seed(42)
n_points = 100
x_data = np.random.rand(n_points)
y_data = np.random.rand(n_points)
z_data = np.random.rand(n_points)

#Erstellen Sie ein Streudiagramm
fig = go.Figure(data=[go.Scatter3d(x=x_data, y=y_data, z=z_data, mode='markers')])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='3D-Streudiagramm')
fig.show()

Der obige Code generiert ein einfaches dreidimensionales Streudiagramm, das die Verteilung zufällig generierter Datenpunkte im dreidimensionalen Raum zeigt.

Zeichnen Sie ein Oberflächendiagramm

Als nächstes zeichnen wir ein Oberflächendiagramm. Angenommen, wir haben eine Funktion f(x, y)und möchten ihre Oberfläche dreidimensional visualisieren.

# Funktion definieren
def f(x,y):
    Rückgabe np.sin(x) * np.cos(y)

# Rasterdaten generieren
x_grid = np.linspace(0, 2*np.pi, 50)
y_grid = np.linspace(0, 2*np.pi, 50)
x_grid, y_grid = np.meshgrid(x_grid, y_grid)
z_grid = f(x_grid, y_grid)

#Oberflächendiagramm erstellen
fig = go.Figure(data=[go.Surface(z=z_grid, x=x_grid, y=y_grid)])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='3D-Oberflächendiagramm')
fig.show()

Der obige Code generiert ein 3D-Oberflächendiagramm, das die Oberfläche der Funktion zeigt.

Zeichnen Sie Drahtgitter

Abschließend zeichnen wir ein Drahtmodell, das die Kontinuität der Daten zeigt.

# Wireframe-Daten generieren
Theta = np.linspace(-4*np.pi, 4*np.pi, 100)
z_line = np.linspace(-2, 2, 100)
x_line = z_line * np.sin(theta)
y_line = z_line * np.cos(theta)

#Drahtmodell erstellen
fig = go.Figure(data=[go.Scatter3d(x=x_line, y=y_line, z=z_line, mode='lines')])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='3D Wireframe Plot')
fig.show()

Der obige Code generiert eine 3D-Grafik, die das Drahtmodell zeigt.

Anhand der obigen Beispiele haben wir gezeigt, wie man mit Python und Plotly verschiedene Arten dreidimensionaler Grafiken zeichnet. Sie können diese Grafiken weiter an Ihre Bedürfnisse anpassen und die umfangreicheren Funktionen der Plotly-Bibliothek erkunden. Viel Spaß beim Plotten!

Zeichnen Sie ein 3D-Balkendiagramm

Zusätzlich zu Streudiagrammen, Oberflächendiagrammen und Drahtgitterdiagrammen können wir auch 3D-Balkendiagramme zeichnen, um Unterschiede und Beziehungen zwischen Daten darzustellen.

# Beispieldaten generieren
Kategorien = ['A', 'B', 'C', 'D']
Werte = np.random.randint(1, 10, size=(len(Kategorien), len(Kategorien)))
x_bar, y_bar = np.meshgrid(np.arange(len(categories)), np.arange(len(categories)))
x_bar = x_bar.flatten()
y_bar = y_bar.flatten()
z_bar = np.zeros_like(x_bar)

#Legen Sie die Höhe des Balkendiagramms fest
bar_heights = Werte.flatten()

#Erstellen Sie ein 3D-Balkendiagramm
fig = go.Figure(data=[go.Bar3d(x=x_bar, y=y_bar, z=z_bar, dx=1, dy=1, dz=bar_heights)])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='3D-Balkendiagramm')
fig.show()

Der obige Code generiert ein dreidimensionales Balkendiagramm, das die Beziehung zwischen verschiedenen Kategorien und Werten zeigt.

Benutzerdefinierter Grafikstil

Plotly bietet zahlreiche Anpassungsoptionen zum Anpassen von Stil, Layout und Erscheinungsbild von Grafiken. Sie können die Farbe, den Linientyp, die Beschriftung und andere Eigenschaften der Grafiken nach Bedarf ändern, um bestimmte Visualisierungsanforderungen zu erfüllen.

# Benutzerdefinierter Grafikstil
fig.update_traces(marker=dict(color='rgb(255, 127, 14)', size=10),
                  selector=dict(mode='markers'))
fig.update_layout(scene=dict(xaxis=dict(backgroundcolor="rgb(200, 200, 230)",
                                       Gridcolor="weiß",
                                       showbackground=True,
                                       zerolinecolor="white"),
                             yaxis=dict(backgroundcolor="rgb(230, 200,230)",
                                       Gridcolor="weiß",
                                       showbackground=True,
                                       zerolinecolor="white"),
                             zaxis=dict(backgroundcolor="rgb(230, 230,200)",
                                       Gridcolor="weiß",
                                       showbackground=True,
                                       zerolinecolor="white")),
                  title='Angepasstes 3D-Streudiagramm')
fig.show()

Interaktive 3D-Grafiken

Plotly unterstützt auch die Erstellung interaktiver dreidimensionaler Grafiken, sodass Benutzer Daten durch Mausinteraktion erkunden können. Hier ist ein Beispiel für ein interaktives Streudiagramm:

# Erstellen Sie ein interaktives Streudiagramm
fig = go.Figure(data=[go.Scatter3d(x=x_data, y=y_data, z=z_data, mode='markers')])
fig.update_layout(scene=dict(xaxis_title='X', yaxis_title='Y', zaxis_title='Z'),
                  title='Interaktives 3D-Streudiagramm')
fig.show()

Indem Benutzer mit der Maus über die Datenpunkte fahren, können sie den spezifischen numerischen Wert jedes Datenpunkts anzeigen, um ein tieferes Verständnis der Daten zu erlangen.

Grafiken exportieren

Sobald Sie eine 3D-Grafik erstellt haben, mit der Sie zufrieden sind, können Sie sie zur einfachen Weitergabe und Präsentation als statisches Bild oder interaktive HTML-Datei exportieren. Plotly bietet eine praktische Exportfunktion, mit der Sie Grafiken einfach in lokalen Dateien speichern können.

#Grafiken als statische Bilder exportieren
fig.write_image("3d_plot.png")

# Grafiken als interaktive HTML-Dateien exportieren
fig.write_html("3d_plot.html")

Entdecken Sie weitere Funktionen

Zusätzlich zu den in diesem Artikel vorgestellten Funktionen bietet Plotly auch viele andere leistungsstarke Funktionen wie Animation, Sprites, Kamerasteuerung usw., um Ihre dreidimensionalen Grafiken weiter zu verbessern und anzupassen. Sie können mehr über diese Funktionen erfahren und sie auf Ihre Projekte anwenden, indem Sie die offizielle Dokumentation konsultieren oder auf Online-Tutorials verweisen.

Zusammenfassen

In diesem Artikel haben wir gelernt, wie man mit Python und der Plotly-Bibliothek verschiedene Arten dreidimensionaler Grafiken zeichnet, darunter Streudiagramme, Oberflächendiagramme, Drahtgitterdiagramme und Balkendiagramme. Wir lernten die grundlegenden Schritte und Codebeispiele kennen, die zum Zeichnen jedes Diagrammtyps erforderlich sind, und erkundeten, wie man Diagrammstile anpasst, interaktive Diagramme erstellt und Diagramme als statische Bilder oder interaktive HTML-Dateien exportiert. Mit diesen Techniken und Funktionen können wir auf einfache Weise attraktive und nützliche 3D-Grafiken im Bereich der Datenvisualisierung erstellen, um Daten besser zu verstehen und zu analysieren. Ob in der wissenschaftlichen Forschung, bei technischen Anwendungen oder bei der Datenanalyse: 3D-Grafiken sind leistungsstarke Werkzeuge, die uns helfen, Muster und Beziehungen zwischen Daten zu entdecken und Forschungsergebnisse und Erkenntnisse zu präsentieren. Durch die kontinuierliche Erforschung und Anwendung der Funktionen der Python- und Plotly-Bibliotheken können wir die Effektivität und Effizienz der Datenvisualisierung weiter verbessern und so unserer Arbeit und unseren Projekten mehr Wert und Erfolge verleihen.

Klicken Sie hier, um zu folgen und so schnell wie möglich mehr über die neuen Technologien von Huawei Cloud zu erfahren~