Seeborn 3D -Grundstück

Wir können verschiedene Muster von 3D-Graphen mit der Konfiguration der dreidimensionalen Koordinaten zeichnen. Eines der Merkmale, die uns daran hindern, die Diagramme dynamisch zu sehen, ist das 3D -Diagramm. Wir brauchen es, wenn wir die immersive Grafik verwenden. Wir können die erforderlichen Bibliotheken importieren, die einige Funktionen zum Erstellen der dreidimensionalen Graphen enthalten. Da es im Seeborn-Modul keine eingebaute Funktionalität zum Zeichnen der 3D-Graphen gibt, ist es das Matplotlib-Plugin, das sich darauf annimmt, die tatsächlichen Arbeiten in den dreidimensionalen Graphen zu erledigen. Daher können wir Seeborn verwenden, um die 3D -Grafik anzupassen. Wir werden untersuchen, wie in diesem Tutorial zahlreiche verschiedene dreidimensionale Grafiken zeichnen.

Beispiel 1

Eine Gruppe von Streudiagrammen, die mit den Dreikombinationen gebildet wurden. Die Funktion plot3d () und die scatter3d () -Methode werden wie die häufigeren 2D -Diagramme verwendet, um diese zu zeichnen. In diesem Fall zeichnen wir eine hyperbolische Helix mit verschiedenen Stellen in der Nähe der Linie.

Numph als NP importieren
Matplotlib importieren.Pyplot als PLT
Importieren Sie Seeborn als SNS
Abb = PLT.Figur()
ax = plt.Achsen (Projektion = '3D')
Zline = NP.Linspace (0, 20, 2000)
xline = np.Sünde (Zline)
yline = np.cos (Zline)
Axt.Plot3d (Xline, Yline, Zline, 'Gray')
Zdata = 15 * np.willkürlich.zufällig (200)
xdata = np.Sünde (Zdata) + 0.1 * np.willkürlich.Randn (200)
ydata = np.cos (Zdata) + 0.1 * np.willkürlich.Randn (200)
Axt.Scatter3d (xdata, ydata, zdata, c = zdata, cmap = 'blues');
PLT.zeigen()

Hier importieren wir die erforderlichen Header -Dateien. Numpy Modul wird als NP, Matplotlib eingeführt.Pyplot wird als PLT eingeführt und Seeborn wird als SNS eingeführt. Im nächsten Schritt nennen wir die Funktion Abbildung (), um die Abbildung zu zeichnen. Diese Funktion gehört zu Matplotlib.Pyplot -Bibliothek. Jetzt verwenden wir die Funktion axes (), um den Wert der Projektion anzugeben.

Hier möchten wir ein dreidimensionales Diagramm erstellen, also haben wir einen 3D-Wert gegeben. Lassen Sie uns die Daten für eine 3D -Linie definieren. Wir deklarieren die drei verschiedenen Variablen und weisen sie den Werten für alle drei Achsen zu. Zunächst setzen wir die Werte für den Abstand für die Z-Achse, sodass wir die Funktion der Linienspace () des Numpy-Pakets anwenden. Mit Hilfe des Wertes des Z-Achsenabstands geben wir die Werte des Abstands für andere Achsen x und y an.

Um nun ein 3D -Diagramm zu zeichnen, verwenden wir die Funktion von Diagramm3d (). Hier liefern wir den Abstand aller Achsen und die Farbe des Hintergrunds des 3D -Diagramms als Argument der Funktion. Darüber hinaus setzen wir die Daten für die 3D -Streupunkte. Wir rufen die Randn () -Funktion der Numpy -Bibliothek separat für alle drei Achsen auf. Auf diese Weise erhalten wir die Punkte, aus denen wir das Streudiagramm zeichnen.

Um das Streudiagramm mit diesen Punkten zu zeichnen, verwenden wir die Scatter3D () -Methode. Diese Funktion enthält mehrere Parameter, die Daten von X, Y und Z-Achse sowie den Wert von „CMAP“ enthalten. Der Wert des Parameters „CMAP“ zeigt die Farbe der im 3D -Diagramm gezeichneten Linie. Die Methode show () wird aufgerufen, um die Karte zu veranschaulichen.

Beispiel 2

Alle für die Contour3D () -Methode erforderlichen Daten müssen sich im Zustand einer 2D -Gitterknoten sowie der Z -Daten an jedem Punkt befinden. Eine 3D -Konturgrafik einer periodischen Funktion ist in der folgenden Abbildung dargestellt:

Numph als NP importieren
Matplotlib importieren.Pyplot als PLT
Importieren Sie Seeborn als SNS
def f (x, y):
Return NP.Sünde (NP.SQRT (x ** 4 + y ** 4))
x = np.Linspace (-4, 4, 25)
y = np.Linspace (-4, 4, 25)
X, y = np.Meshgrid (x, y)
Z = f (x, y)
Abb = PLT.Figur()
ax = plt.Achsen (Projektion = '3D')
Axt.contour3d (x, y, z, 40, cmap = 'binär')
Axt.set_xlabel ('x')
Axt.set_ylabel ('y')
Axt.set_zlabel ('z')
PLT.zeigen()

Zu Beginn des Programms integrieren wir die Bibliotheken Numpy als NP, Matplotlib.Pyplot als PLT und Seeborn als SNS. Jetzt definieren wir eine f () -Funktion mit zwei Parametern, die den Wert mit der SQRT () -Methode der Numpy -Bibliothek verwenden. Wir geben die Abstandswerte für beide Achsen x und y mit Hilfe von Linspace an ().Diese Methode hängt mit dem Numpy -Framework zusammen.

In der nächsten Zeile haben wir die Funktion meshgrid () angewendet, um ein Netzraster im 3D -Graphen zu erstellen. Diese Funktion hält den Wert des Leitungsabstands von X- und Y -Achsen als Parameter. Hier verwenden wir die Funktion von figure () von Matplotlib.Pyplot -Bibliothek, um die Figur zu erstellen. Um das Projektionsniveau zu definieren, verwenden wir die Achsen () -Methode (). Wir müssen eine dreidimensionale Karte konstruieren, daher bieten wir einen 3D-Wert für die Funktion. Wir wenden jetzt die Contour3D () -Methode an.

Als Parameter der Funktion geben wir ihm den Abstand aller Achsen und den Schatten des 3D -Diagramms. Als nächstes geben wir die Bildunterschriften aller drei Achsen an, sodass die Methode set_label () für alle Achsen aufgerufen wird. Um das Diagramm zu demonstrieren, wird die Funktion show () verwendet.

Beispiel 3

In diesem Fall erstellen wir ein Oberflächendiagramm im dreidimensionalen Diagramm mithilfe der Methode Plot_surface ().

Importieren Sie Seeborn als SB
Matplotlib importieren.Pyplot als Handlung
Numph als NP importieren
Def func_z (x, y):
return50 - (x ** 2 + y ** 2)
sb.set_style ('WhiteGrid')
N = 50
X_val = np.Linspace (-5, 5, n)
Y_val = np.Linspace (-5, 5, n)
X1, y1 = np.meshgrid (x_val, y_val)
Z1 = func_z (x1, y1)
Achsen = Diagramm.Achsen (Projektion = '3D')
Äxte.plot_surface (x1, y1, z1)
Parzelle.zeigen()

Zunächst integrieren wir die Module SeaBorn, Matplotlib.Pyplot und NP. Wir definieren die Funktion für die Z-Achse und diese Funktion wird mit der x- und y-Achse versehen. Diese Funktion gibt den Wert der Z-Achse zurück. In der nächsten Phase verwenden wir die Methode set_style (), um das Layout des Diagramms anzupassen. Wir setzen seinen Wert auf WhiteGrid.

Jetzt deklarieren wir eine Variable und weisen ihr einen Wert zu. Die Linspace () -Methode wird aufgerufen, um den Abstand der x- und y-Achse anzuzeigen. Wir zeichnen das Meshgrid zur Z-Achse, also verwenden wir die Meshgrid () -Methode. Diese Funktion stammt aus dem Numpy -Paket. Wir nennen die Funktion für die Werte der Z-Achse. Für das 3D -Diagramm ist es obligatorisch, den Projektionswert anzugeben. Dafür verwenden wir die Funktion axes ().

Um das Oberflächendiagramm zu zeichnen, wird die Funktion Plot_surface () ausgeführt. Diese Funktion enthält den Wert aller drei Achsen. Bevor Sie den Code beenden.

Beispiel 4

Hier verwenden wir die Wireframe () -Methode, um den Wireframe im 3D -Diagramm zu zeichnen.

Numph als NP importieren
Matplotlib importieren.Pyplot als PLT
Importieren Sie Seeborn als SNS
Abb = PLT.Figur()
ax = plt.Achsen (Projektion = '3D')
Zline = NP.Linspace (0, 20, 2000)
xline = np.Sünde (Zline)
yline = np.cos (Zline)
Axt.Plot3d (Xline, Yline, Zline, 'Gray')
Zdata = 15 * np.willkürlich.zufällig (200)
xdata = np.Sünde (Zdata) + 0.1 * np.willkürlich.Randn (200)
ydata = np.cos (Zdata) + 0.1 * np.willkürlich.Randn (200)
Axt.Scatter3d (xdata, ydata, zdata, c = zdata, cmap = 'blues')
PLT.zeigen()

Nach der Einführung der wesentlichen Frameworks identifizieren wir die Z-Achse-Funktion, die mit den X- und Y-Achsen verfügbar ist. Der Z-Achsewert wird durch diesen Prozess erhalten. Wir verwenden die Funktion set style (), um das Design des Diagramms im nächsten Schritt zu ändern. Sein Wert ist an die WhiteGrid konfiguriert. Wir initialisieren jetzt eine Variable n und geben ihr einen Wert.

Um den Abstand zwischen den X- und Y -Achsen anzugeben, wird die Linspace () -Technik angewendet. Wir verwenden die Meshgrid () -Funktion, weil wir das Meshgrid zur Z-Achse darstellen wollen. Dies ist eine Technik des Numpy -Toolkits. Die Komponente für den Z-Achse-Wert wird berücksichtigt. Der Projektionswert muss für die 3D -Visualisierung angegeben werden. Wir verwenden die Achsen () -Methode dafür. Die Methode von Wireframe () wird angewendet, um das WireFrame -Diagramm zu erstellen. Der Wert aller drei Achsen wird in diese Methode integriert. Wir verwenden die Funktion show (), um die gesamte Grafik am Ende anzuzeigen.

Abschluss

In diesem Abschnitt sind wir den ganzen Weg durch verschiedene Ansätze gegangen. Wir haben auch gelernt, wie man die 3D-Konturkarten zeichnet, wie man den Drahtmodell auf dem dreidimensionalen Diagramm zeichnet und wie man ein Oberflächendiagramm auf den 3D-Diagramme erstellt. Es gibt kein integriertes dreidimensionales Merkmal im Seeborn-Rahmen.