Carquois de matplotlib

Un tracé de carquois représente les composants de vitesse comme des flèches contenant des paramètres directionnels U et V aux variables bidimensionnelles x et y. Pour utiliser la méthode Quiver () dans MatplotLib, nous générerons un graphique de carquois. Les graphiques de carburant illustreraient la sortie électrique en génie électrique et démontreraient les variations de pression en génie mécanique.

Dans cet article, nous allons discuter des méthodes sur la façon de créer des graphiques de carburant dans Python.

Dessinez un tracé de carquois en ayant une flèche:

Dans cette étape, nous allons créer un tracé de carrière qui a une flèche et nous observerons le fonctionnement du matplotlib.hache.Fonction Quiver ().

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
x = 2
y = 2
u = 3
v = 3
Fig, ax = plt.sous-intrigues (FigSize = (5, 5))
hache.carquois (x, y, u, v)
hache.set_title ('tracé de carquier')
PLT.montrer()

Pour créer les parcelles de carquois, nous devons acquérir les bibliothèques requises: Matplotlib et Numpy. Pour créer la flèche, nous déclarons certaines variables et leur donnons des valeurs aléatoires. Ces variables montrent la position et la direction de la flèche. De plus, nous faisons un objet qui montre la taille de la figure.

Nous appelons la fonction Quiver (). Cette fonction contient quatre paramètres. Les paramètres 'x' et 'y' montrent les points de départ de la flèche dessinée. Les directives de la flèche sont montrées par les paramètres 'u' et 'v.' De plus; Nous appelons l'ensemble.Fonction Title (), qui montre l'étiquette du tracé de carquois. En fin de compte, nous pouvons afficher le tracé de carquois en utilisant le PLT.Fonction show ().

Ce graphique a une flèche de carquois dans la sortie qui commence au «x» = 2 et «y» = 2. À 'u' = 3 et 'v' = 3, la direction de la flèche dessinée est vers le haut et à droite.

Dessinez un tracé de carquois en ayant deux flèches:

Maintenant, nous devons insérer une autre flèche dans le graphique. Nous pouvons y parvenir en fournissant deux points initiaux de la flèche et deux directives des flèches.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
Fig, ax = plt.sous-intrigues ()
x = [1, 1]
y = [1, 1]
u = [2, 2]
v = [2, -2]
hache.tremblant (x, y, u, v,
échelle = 8)
hache.axe ([- 5, 5, -5, 5])
PLT.montrer()

Après avoir intégré les bibliothèques Matplotlib.Pypllot comme plt et numpy que np, nous appelons la fonction plt.Fonctions sous-tracés () pour créer le graphique. Ensuite, nous déclarons deux tableaux qui contiennent les points initiaux des flèches. En attendant, nous stockons ces tableaux en variables «x» et «y».

De même, nous déclarons les deux autres tableaux qui maintiennent la direction des flèches et les assignons aux variables «u» et «v». Nous appelons la hache.Fonction Quiver () maintenant. Dans le code ci-dessus, cette fonction a 4 paramètres, y compris la position de départ des flèches et la direction des flèches. Mais dans ce scénario, une «échelle» de paramètre supplémentaire est fournie à la hache.Fonction Quiver (). Ce paramètre est utilisé pour ajuster la dimension des flèches.

En diminuant la valeur de l'argument «échelle», nous pouvons dessiner une grande flèche. Nous pouvons ajuster les points initiaux et de terminaison des flèches en définissant les limites à la hache.Fonction Axis (). Nous fournissons les paramètres afin que le premier paramètre montre la valeur minimale de «x»; Le deuxième paramètre montre la valeur maximale de «x»; Le troisième paramètre montre la valeur minimale de «y», et le dernier paramètre montre la valeur maximale de «y».

Maintenant, le graphique est affiché en utilisant le PLT.Fonction show ().

Nous obtenons deux flèches dans ce graphique. Une flèche a une position de départ (1, 1), pointant dans la bonne direction vers le haut. De même, l'autre flèche a une position de départ (1, 1), et elle pointe également dans la bonne direction vers le bas.

Dessinez le tracé de carquois en utilisant la grille en filet:

Le programme ultérieur montre comment montrer une parcelle de carquois à l'aide d'une grille en maille:

Importer Matplotlib.pypllot comme plt
Importer Numpy comme 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.péché (y) * y
Fig, ax = plt.sous-intrigues (FigSize = (12, 10))
hache.carquois (x, y, u, v)
hache.xaxis.set_ticks ([])
hache.yaxis.set_ticks ([])
hache.axe ([- 0.2, 2.2 -0.2, 2.2])
hache.set_aspect («égal»)
PLT.montrer()

Au début du programme, nous importons deux packages, Matplotlib.pypllot comme plt et numpy que np. Ici, nous créons la position initiale en utilisant la bibliothèque Numpy. Nous déclarons deux tableaux et attribuons ces tableaux à la variable, respectivement.

Maintenant, nous appelons la fonction MeshGrid () de la bibliothèque Numpy. Cette fonction contient deux paramètres. Maintenant, nous faisons deux nouvelles variables. Ces variables stockent les points qui montrent la direction des flèches. Nous devons créer un tracé en utilisant le PLT.Fonction sous-intrigue. Nous pouvons ajuster la taille du tracé avec cette fonction.

En attendant, nous appliquons la hache.Méthode Quiver (). Et cette méthode contient quatre arguments, y compris les points de position de départ des flèches et les points de direction des flèches. Nous déclarons deux fonctions Axe.axe.set_ticks ([]) et hache.yaxis.set_ticks ([]) qui élimine les panneaux de tick de l'axe x et de l'axe y.

Nous pouvons le faire en utilisant une hache.axe(). Ici, nous modifions les limites de l'axe. En fin de compte, avant d'afficher le graphique, nous définissons la hache.Set_aspect () Fonction. Cette fonction détermine le rapport de perspective de l'intrigue.

Dans ce cas, nous obtenons ce type de graphique en utilisant la méthode de la grille de maillage. Ce graphique montre un tracé de carquois ayant plusieurs flèches.

Spécifiez le tracé de la couleur pour trembler:

La hache de la bibliothèque Matplotlib.La fonction Quiver () contient une couleur de paramètre supplémentaire qui définit la teinte de la flèche. Les contours du paramètre de couleur de carburant doivent être les mêmes que les mesures de l'emplacement et des éléments directionnels.

Importer Matplotlib.pypllot comme plt
Importer Numpy comme NP
Fig, (ax1, ax2) = plt.sous-tracés (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.péché (y) * y
n = -4
color = np.sqrt (((v-n) / 2) * 2 + ((u-n) / 2) * 2)
ax1.tremblant (x, y, u, v, couleur, alpha = 1.0)
ax1.xaxis.set_ticks ([])
ax1.yaxis.set_ticks ([])
ax1.axe ([- 0.2, 2.3, -0.2, 2.3])
ax1.set_aspect («égal»)
ax1.set_title ('premier tracé')
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
color = np.sqrt (((dx-n) / 2) * 2 + ((dy-n) / 2) * 2)
ax2.carquois (x, y, dx, dy, couleur)
ax2.xaxis.set_ticks ([])
ax2.yaxis.set_ticks ([])
ax2.set_aspect («égal»)
ax2.set_title ('deuxième tracé')
PLT.serré_layout ()
PLT.montrer()

Nous présentons le matplotlib.Pypllot as PLT et Numpy que les bibliothèques NP. À l'étape suivante, nous allons définir des sous-intrigues et ajuster la taille du graphique. Pour dessiner la première sous-intrigue, nous créons des flèches à l'aide du package Numpy. Les positions initiales et les directions des flèches sont définies pour les flèches de la première sous-intrigue.

De plus, nous définissons la couleur des flèches en appelant la fonction. Nous créons le graphique en appliquant la fonction Quiver (). Ici, nous avons attribué la couleur de l'intrigue. Nous avons spécifié le titre de la première sous-intrigue en appelant la fonction set_title ().

Maintenant allons pour la deuxième intrigue. Pour créer des flèches pour la deuxième sous-intrigue, nous spécifions les positions initiales et le point pour les directions des flèches. Nous créons un dégradé entre les deux sous-intrigues. Nous définissons la couleur de la deuxième intrigue. Nous créons la sous-intrigue en utilisant la fonction Quiver (). Nous décidons de la couleur des flèches de la deuxième sous-intrigue.

En fin de compte, nous montrons le graphique en appelant le PLT.Méthode Show ().

Conclusion:

Nous avons utilisé Matplotlib et Python pour créer une variété de nouveaux graphiques de carquois dans cet article. Le package Pyplot de Matplotlib comprend des graphiques carburants. Les points de position de X et Y et les directions des flèches sont les paramètres de la hache.Fonction Quiver (). La méthode MeshGrid () dans Numpy peut générer de tels modules de position. De plus, nous avons introduit une teinte supplémentaire dans des graphiques carquois en appelant la hache.Fonction Quiver () avec une nouvelle couleur de paramètre.'