Matplotlib Quiver

En dirrende plot skildrer hastighetskomponenter som piler som inneholder retningsparametere U og V ved de todimensjonale variablene x og y. For å bruke Quiver () -metoden i matplotlib, vil vi generere en dirrende graf. Quiver Charts ville illustrere elektrisk utgang i elektroteknikk og demonstrere trykkvariasjoner i maskinteknikk.

I denne artikkelen skal vi diskutere metodene for hvordan du lager dirrende grafer i Python.

Tegn Quiver Plot med en pil:

I dette trinnet skal vi lage en dirrende plot som har en pil, og vi vil observere arbeidsplotlibs arbeid.øks.Quiver () -funksjon.

Importer matplotlib.Pyplot som Plt
Importer numpy som NP
x = 2
y = 2
u = 3
v = 3
Fig, AX = PLT.delplotter (FigSize = (5, 5))
øks.Quiver (x, y, u, v)
øks.set_title ('Quiver plot')
plt.forestilling()

For å lage Quiver -plottene, må vi skaffe oss de nødvendige bibliotekene: matplotlib og numpy. For å lage pilen, erklærer vi noen variabler og gir dem tilfeldige verdier. Disse variablene viser pilens plassering og retning. Videre lager vi et objekt som viser størrelsen på figuren.

Vi kaller funksjonen Quiver (). Denne funksjonen inneholder fire parametere. Parametrene 'X' og 'Y' viser startpunktene til den trukket pilen. Arrows direktiver vises av parametrene 'U' og 'V.' I tillegg til denne; Vi ringer settet.Tittel () Funksjon, som viser etiketten til Quiver -plottet. Til slutt kan vi vise Quiver -plottet ved hjelp av PLT.show () funksjon.

Denne grafen har en dirrende pil i utgangen som starter på 'X' = 2 og 'Y' = 2. Ved 'U' = 3 og 'V' = 3 er retningen på den trukket pilen oppover og til høyre.

Tegn Quiver Plot med to piler:

Nå må vi sette inn en annen pil inn i grafen. Vi kan oppnå dette ved å gi to pilens innledende punkter og to direktiver av pilene.

Importer matplotlib.Pyplot som Plt
Importer numpy som NP
Fig, AX = PLT.underplott ()
x = [1, 1]
y = [1, 1]
u = [2, 2]
v = [2, -2]
øks.Quiver (x, y, u, v,
skala = 8)
øks.Axis ([ -5, 5, -5, 5])
plt.forestilling()

Etter å ha integrert bibliotekene matplotlib.Pyplot som PLT og Numpy som NP, vi kaller funksjonen PLT.Subplots () fungerer for å lage grafen. Da erklærer vi to matriser som inneholder pilens opprinnelige punkter. I mellomtiden lagrer vi disse matriser i 'x' og 'y' variabler.

Tilsvarende erklærer vi de to andre matriser som holder pilens retning og tildeler dem til 'U' og 'V' -variablene. Vi kaller øksen.Quiver () -funksjon nå. I koden ovenfor har denne funksjonen 4 parametere, inkludert startposisjonen til pilene og pilens retning. Men i dette scenariet er det gitt en ekstra parameter "skala" til øksen.Quiver () -funksjon. Denne parameteren brukes til å justere pilens dimensjon.

Ved å redusere verdien av "skala" -argumentet, kan vi tegne en stor pil. Vi kan justere pilens innledende og termineringspunkter ved å definere grensene for øksen.Axis () -funksjon. Vi gir parametrene slik at den første parameteren viser minimumsverdien på 'x'; Den andre parameteren viser den maksimale verdien av 'x'; Den tredje parameteren viser minimumsverdien på 'y', og den siste parameteren viser den maksimale verdien av 'y'.

Nå vises grafen ved å bruke PLT.show () funksjon.

Vi får to piler i denne grafen. En pil har en startposisjon (1, 1), og peker i riktig retning oppover. Tilsvarende har den andre pilen en startposisjon (1, 1), og den peker også i riktig retning nedover.

Tegn Quiver Plot ved bruk av nettnett:

Det påfølgende programmet demonstrerer hvordan du viser en dirrende plot ved hjelp av et nettnett:

Importer matplotlib.Pyplot som Plt
Importer numpy som 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.sin (y)*y
Fig, AX = PLT.delplott (FigSize = (12, 10))
øks.Quiver (x, y, u, v)
øks.xaxis.set_ticks ([])
øks.Yaxis.set_ticks ([])
øks.Axis ([-0.2, 2.2 -0.2, 2.2])
øks.set_aspect ('like')
plt.forestilling()

Ved programmets start importerer vi to pakker, matplotlib.pyplot som plt og numpy som np. Her oppretter vi startposisjonen ved å bruke Numpy Library. Vi erklærer to matriser og tildeler disse matriser til henholdsvis variabelen.

Nå kaller vi MeshGrid () -funksjonen til Numpy Library. Denne funksjonen inneholder to parametere. Nå lager vi to nye variabler. Disse variablene lagrer punktene som viser pilens retning. Vi må lage et plott ved hjelp av PLT.subplot () -funksjon. Vi kan justere størrelsen på plottet med denne funksjonen.

I mellomtiden bruker vi øksen.Quiver () -metode. Og denne metoden har fire argumenter, inkludert startposisjonspunktene for pilene og retningspunktene for pilene. Vi erklærer to funksjoner øks.akser.set_ticks ([]) og øks.Yaxis.set_ticks ([]) som eliminerer flåttskiltene fra x-aksen og y-aksen.

Vi kan gjøre dette ved å bruke en øks.akser(). Her endrer vi aksegrensene. Til slutt, før vi viser grafen, definerer vi øksen.set_aspect () funksjon. Denne funksjonen bestemmer plottets perspektivforhold.

I dette tilfellet får vi denne typen graf ved å bruke nettetettmetoden. Denne grafen viser en dirrende plott som har flere piler.

Spesifiser fargen for å dirre plott:

Matplotlib -bibliotekets øks.Quiver () -funksjonen inneholder en ekstra parameterfarge som definerer pilen til pilen. Konturene til Quiver Color Parameter må være de samme som målingene av plasseringen og retningselementene.

Importer matplotlib.Pyplot som Plt
Importer numpy som NP
fig, (ax1, ax2) = plt.Underplott (1, 2, FigSize = (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.sin (y)*y
n = -4
farge = np.SQRT (((V-N)/2)*2 + ((U-N)/2)*2)
AX1.Quiver (x, y, u, v, farge, alfa = 1.0)
AX1.xaxis.set_ticks ([])
AX1.Yaxis.set_ticks ([])
AX1.Axis ([-0.2, 2.3, -0.2, 2.3])
AX1.set_aspect ('like')
AX1.set_title ('første plot')
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
farge = np.SQRT (((dx-n)/2)*2 + ((dy-n)/2)*2)
AX2.Quiver (x, y, dx, dy, farge)
AX2.xaxis.set_ticks ([])
AX2.Yaxis.set_ticks ([])
AX2.set_aspect ('like')
AX2.set_title ('andre plot')
plt.tight_layout ()
plt.forestilling()

Vi introduserer matplotlib.Pyplot som PLT og Numpy som NP -biblioteker. I neste trinn skal vi definere delplott og justere størrelsen på grafen. For å tegne det første delplottet lager vi piler ved hjelp av Numpy -pakken. De første stillingene og retningene til pilene er definert for pilene til den første delplottet.

Videre setter vi fargen på pilene ved å kalle funksjonen. Vi lager grafen ved å bruke Quiver () -funksjonen. Her tildelte vi fargen på plottet. Vi spesifiserte tittelen på den første delplottet ved å ringe SET_TITLE () -funksjonen.

La oss nå gå for det andre delplottet. For å lage piler for det andre delplottet, spesifiserer vi startposisjonene og punktet for retninger av pilene. Vi lager en gradient mellom begge delplottene. Vi definerer fargen for det andre delplottet. Vi oppretter delplottet ved å bruke Quiver () -funksjonen. Vi bestemmer fargen på pilene til det andre delplottet.

Til slutt viser vi grafen ved å ringe PLT.Show () Metode.

Konklusjon:

Vi benyttet matplotlib og python for å lage en rekke nye dirrende grafer i denne artikkelen. Matplotlibs Pyplot -pakke inkluderer dirrende grafer. Posisjonspunktene til X og Y og pilens instruksjoner er parametrene for øksen.Quiver () -funksjon. MeshGrid () -metoden i Numpy kan generere slike posisjonsmoduler. Videre introduserte vi en ekstra fargetone i dirrende grafer ved å ringe øksen.Quiver () -funksjon med en ny parameterfarge.'