Matplotlib kołczan

Wykres kołerzy przedstawia składniki prędkości jako strzałki zawierające parametry kierunkowe u i v na zmiennych dwuwymiarowych x i y. Aby użyć metody matplotlib w metodzie matplotlib. Wykresy drwin ilustrują wyjście elektryczne w inżynierii elektrycznej i wykazują zmiany ciśnienia w inżynierii mechanicznej.

W tym artykule omówimy metody tworzenia wykresów kołczania w Python.

Narysuj wykres kołysania o jednej strzałce:

Na tym etapie stworzymy wykres kołerzy, który ma jedną strzałkę i będziemy obserwować działanie Matplotlib.topór.Funkcja quiver ().

importować matplotlib.Pyplot as Plt
importować Numpy jako NP
x = 2
y = 2
u = 3
v = 3
Ryc, ax = plt.wątki (figSize = (5, 5))
topór.kołczan (x, y, u, v)
topór.set_title („DZIAŁKA”)
plt.pokazywać()

Aby utworzyć wykresy kołczanów, musimy uzyskać wymagane biblioteki: Matplotlib i Numpy. Aby stworzyć strzałkę, deklarujemy niektóre zmienne i podajemy im losowe wartości. Te zmienne pokazują pozycję i kierunek strzałki. Ponadto tworzymy obiekt, który pokazuje rozmiar figury.

Nazywamy funkcję quiver (). Ta funkcja zawiera cztery parametry. Parametry „x” i „y” pokazują punkty początkowe rysowanej strzałki. Dyrektywy strzałek są pokazane przez parametry „u” i „v.' Na dodatek do tego; Nazywamy zestaw.title () funkcja, która pokazuje etykietę fabuły kołpaka. Ostatecznie możemy wyświetlić wykres kołerzy za pomocą PLT.show () funkcja.

Ten wykres ma jedną strzałkę kołczaka w wyjściu, która rozpoczyna się od „x '= 2 i„ y ”= 2. Przy „u” = 3 i „v” = 3, kierunek narysowanej strzałki jest w górę i po prawej stronie.

Narysuj wykres kołysania o dwóch strzałach:

Teraz musimy wstawić kolejną strzałkę na wykres. Możemy to osiągnąć, podając dwa początkowe punkty strzałek i dwie dyrektywy strzałek.

importować matplotlib.Pyplot as Plt
importować Numpy jako NP
Ryc, ax = plt.wątki ()
x = [1, 1]
y = [1, 1]
u = [2, 2]
v = [2, -2]
topór.kołczan (x, y, u, v,
Skala = 8)
topór.oś ([ -5, 5, -5, 5])
plt.pokazywać()

Po zintegrowaniu bibliotek matplotlib.Pyplot jako PLT i Numpy jako NP, wywołujemy funkcję PLT.Funkcje podwplotów () w celu utworzenia wykresu. Następnie deklarujemy dwie tablice zawierające początkowe punkty strzałek. Tymczasem przechowujemy te tablice w zmiennych „x” i „y”.

Podobnie deklarujemy dwie pozostałe tablice, które utrzymują kierunek strzał i przypisuje je do zmiennych „u” i „v”. Nazywamy siekierę.quiver () funkcja teraz. W powyższym kodzie ta funkcja ma 4 parametry, w tym pozycję początkową strzałek i kierunek strzałek. Ale w tym scenariuszu dodatkowy parametr „skala” jest dostarczany do AX.Funkcja quiver (). Ten parametr służy do dostosowania wymiaru strzałek.

Zmniejszając wartość argumentu „skali”, możemy narysować dużą strzałkę. Możemy dostosować punkty początkowe i zakończenia strzałek, określając granice topora.Funkcja osi (). Podajemy parametry, aby pierwszy parametr pokazał minimalną wartość „x”; Drugi parametr pokazuje maksymalną wartość „x”; Trzeci parametr pokazuje minimalną wartość „y”, a ostatni parametr pokazuje maksymalną wartość „y”.

Teraz wykres jest wyświetlany za pomocą PLT.show () funkcja.

Na tym wykresie otrzymujemy dwie strzałki. Jedna strzałka ma pozycję wyjściową (1, 1), wskazując we właściwym kierunku w górę. Podobnie druga strzałka ma pozycję początkową (1, 1), a także wskazuje we właściwym kierunku w dół.

Narysuj wykres kołerzy za pomocą siatki siatki:

Kolejny program pokazuje, jak pokazać wykres kołeczki za pomocą siatki siatki:

importować matplotlib.Pyplot as Plt
importować Numpy jako NP
x = np.Arange (0, 2.4, 0.3)
y = np.Arange (0, 2.4, 0.3)
X, y = np.Meshgrid (x, y)
u = np.cos (x)*y
V = NP.grzech (y)*y
Ryc, ax = plt.wątki (figSize = (12, 10))
topór.kołczan (x, y, u, v)
topór.Xaxis.set_ticks ([])
topór.Yaxis.set_ticks ([])
topór.Oś ([-0.2, 2.2 -0.2, 2.2])
topór.set_asect („równy”)
plt.pokazywać()

Na początku programu importujemy dwa pakiety, Matplotlib.Pyplot jako PLT i Numpy jako NP. Tutaj tworzymy pozycję początkową za pomocą biblioteki Numpy. Deklarujemy odpowiednio dwie tablice i przypisujemy te tablice do zmiennej.

Teraz nazywamy funkcję MeshGrid () biblioteki Numpy. Ta funkcja zawiera dwa parametry. Teraz tworzymy dwie nowe zmienne. Te zmienne przechowują punkty, które pokazują kierunek strzałek. Musimy utworzyć wykres za pomocą PLT.funkcja wątku (). Możemy dostosować rozmiar wykresu za pomocą tej funkcji.

Tymczasem nakładamy topór.Metoda quiver (). I ta metoda zawiera cztery argumenty, w tym punkty początkowe strzałki i punkty kierunku strzałek. Deklarujemy dwie funkcje AX.oś.set_ticks ([]) i ax.Yaxis.set_ticks ([]), który eliminuje znaki kleszcza ze osi x i osi y.

Możemy to zrobić za pomocą topora.oś(). Tutaj modyfikujemy limity osi. W końcu przed wyświetleniem wykresu definiujemy topór.funkcja set_aspect (). Ta funkcja określa współczynnik perspektywy wykresu.

W takim przypadku otrzymujemy ten typ wykresu za pomocą metody siatki siatki siatki. Ten wykres pokazuje wykres kołerzy z wieloma strzałkami.

Określ wykres koloru do kołczaka:

Topór biblioteki matplotlib.Funkcja quiver () zawiera dodatkowy kolor parametrów, który określa odcień strzałki. Kontury parametru koloru kołczaka muszą być takie same jak pomiary lokalizacji i elementów kierunkowych.

importować matplotlib.Pyplot as Plt
importować Numpy jako NP
Ryc, (ax1, ax2) = plt.wątki (1, 2, rysunek = (10, 5))
x = np.Arange (0, 2.0, 0.4)
y = np.Arange (0, 2.0, 0.4)
X, y = np.Meshgrid (x, y)
u = np.cos (x)*y
V = NP.grzech (y)*y
n = -4
kolor = NP.sqrt (((v-n)/2)*2 + ((u-n)/2)*2)
ax1.kołczan (x, y, u, v, kolor, alfa = 1.0)
ax1.Xaxis.set_ticks ([])
ax1.Yaxis.set_ticks ([])
ax1.Oś ([-0.2, 2.3, -0.2, 2.3])
ax1.set_asect („równy”)
ax1.set_title („Pierwszy wykres”)
x = np.Arange (-2, 2.2, 0.2)
y = np.Arange (-2, 2.2, 0.2)
X, y = np.Meshgrid (x, y)
Z = x * np.exp (-x ** 2 -y ** 2)
dx, dy = np.gradient (z)
n = -4
kolor = NP.sqrt (((dx-n)/2)*2 + ((dy-n)/2)*2)
ax2.kołczan (x, y, dx, dy, kolor)
ax2.Xaxis.set_ticks ([])
ax2.Yaxis.set_ticks ([])
ax2.set_asect („równy”)
ax2.set_title („drugi wykres”)
plt.cicik_layout ()
plt.pokazywać()

Przedstawiamy matplotlib.Pyplot jako PLT i Numpy jako biblioteki NP. W następnym kroku zdefiniujemy wątki i dostosować rozmiar wykresu. Aby narysować pierwszy wątek poniżej, tworzymy strzałki za pomocą pakietu Numpy. Początkowe pozycje i kierunki strzałek są zdefiniowane dla strzałek pierwszego wątku.

Ponadto ustawiamy kolor strzał, wywołując funkcję. Tworzymy wykres, stosując funkcję quiver (). Tutaj przypisaliśmy kolor fabuły. Określiliśmy tytuł pierwszego wątku, wywołując funkcję set_title ().

Teraz chodźmy po drugie wątek. Aby utworzyć strzałki dla drugiego wątku, określamy początkowe pozycje i punkt dla kierunków strzałek. Tworzymy gradient między obiema wątkami. Definiujemy kolor drugiego wątku. Tworzymy wątek poniżej funkcji quiver (). Decydujemy o kolorze strzał drugiego wątku.

W końcu pokazujemy wykres, wywołując PLT.Metoda show ().

Wniosek:

W tym artykule wykorzystaliśmy Matplotlib i Python do stworzenia różnych nowych wykresów kołczaków. Pakiet Pyplot Matplotlib zawiera wykresy kołczanów. Punkty pozycyjne x i y oraz kierunki strzałek to parametry topora.Funkcja quiver (). Metoda MeshGrid () w Numpy może generować takie moduły pozycyjne. Ponadto wprowadziliśmy dodatkowy odcień na wykresach kołysania, wywołując AX.Funkcja quiver () z nowym kolorem parametru.'