Mate de mate

Una gráfica de carcaj representa componentes de velocidad como flechas que contienen parámetros direccionales u y v en las variables bidimensionales x e y. Para usar el método quiver () en matplotlib, generaremos un gráfico de carcaj. Los gráficos temblores ilustrarían la salida eléctrica en la ingeniería eléctrica y demostrarían variaciones de presión en la ingeniería mecánica.

En este artículo, vamos a discutir los métodos de cómo crear gráficos temblores en Python.

Dibuja la trama de carcaj que tiene una flecha:

En este paso, vamos a crear una parcela de carcaj que tenga una flecha y observaremos el funcionamiento de Matplotlib.hacha.función quiver ().

Importar matplotlib.Pyplot como PLT
importar numpy como np
x = 2
y = 2
u = 3
V = 3
Fig, Ax = PLT.subtramas (figsize = (5, 5))
hacha.Quiver (X, Y, U, V)
hacha.set_title ('gráfico de quiver')
PLT.espectáculo()

Para crear los gráficos de carcaj, debemos adquirir las bibliotecas requeridas: matplotlib y numpy. Para crear la flecha, declaramos algunas variables y les damos valores aleatorios. Estas variables muestran la posición y la dirección de la flecha. Además, hacemos un objeto que muestra el tamaño de la figura.

Llamamos a la función Quiver (). Esta función contiene cuatro parámetros. Los parámetros 'x' y 'y' muestran los puntos de partida de la flecha dibujada. Las directivas de la flecha se muestran mediante los parámetros 'u' y 'v.' Además de esto; Llamamos al set.Función title (), que muestra la etiqueta de la trama Quiver. Al final, podemos mostrar la gráfica de carcaj usando el PLT.función show ().

Este gráfico tiene una flecha de carcaj en la salida que comienza en 'x' = 2 y 'y' = 2. En 'u' = 3 y 'v' = 3, la dirección de la flecha dibujada es hacia arriba y a la derecha.

Dibuja la trama de carcaj con dos flechas:

Ahora tenemos que insertar otra flecha en el gráfico. Podemos lograr esto proporcionando dos puntos iniciales de flecha y dos directivas de las flechas.

Importar matplotlib.Pyplot como PLT
importar numpy como np
Fig, Ax = PLT.subtramas ()
x = [1, 1]
y = [1, 1]
u = [2, 2]
V = [2, -2]
hacha.Quiver (X, Y, U, V,
escala = 8)
hacha.eje ([ -5, 5, -5, 5])
PLT.espectáculo()

Después de integrar las bibliotecas matplotlib.pyplot como plt y numpy como np, llamamos a la función plt.funciones de subtruces () para crear el gráfico. Luego declaramos dos matrices que contienen los puntos iniciales de las flechas. Mientras tanto, almacenamos estas matrices en variables 'x' e 'y'.

Del mismo modo, declaramos las otras dos matrices que sostienen la dirección de las flechas y las asignan a las variables 'U' y 'V'. Llamamos al hacha.función de quiver () ahora. En el código anterior, esta función tiene 4 parámetros, incluida la posición inicial de las flechas y la dirección de las flechas. Pero en este escenario, se proporciona una 'escala' de parámetros adicionales al hacha.función quiver (). Este parámetro se usa para ajustar la dimensión de las flechas.

Al disminuir el valor del argumento de 'escala', podemos dibujar una flecha grande. Podemos ajustar los puntos iniciales y de terminación de las flechas definiendo los límites al hacha.función de axis (). Proporcionamos los parámetros para que el primer parámetro muestre el valor mínimo de 'x'; El segundo parámetro muestra el valor máximo de 'x'; El tercer parámetro muestra el valor mínimo de 'y', y el último parámetro muestra el valor máximo de 'y'.

Ahora el gráfico se muestra usando el PLT.función show ().

Obtenemos dos flechas en este gráfico. Una flecha tiene una posición inicial (1, 1), apuntando en la dirección derecha hacia arriba. Del mismo modo, la otra flecha tiene una posición inicial (1, 1), y también está apuntando en la dirección derecha hacia abajo.

Dibuje la trama de carcaj mediante el uso de la cuadrícula de malla:

El programa posterior demuestra cómo mostrar una trama de carcaj con la ayuda de una cuadrícula de malla:

Importar matplotlib.Pyplot como PLT
importar numpy como 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.pecado (y)*y
Fig, Ax = PLT.subtramas (figsize = (12, 10))
hacha.Quiver (X, Y, U, V)
hacha.xaxis.set_ticks ([])
hacha.yaxis.set_ticks ([])
hacha.eje ([-0.2, 2.2 -0.2, 2.2])
hacha.set_aspect ('igual')
PLT.espectáculo()

Al inicio del programa, importamos dos paquetes, matplotlib.pyplot como plt y numpy como np. Aquí creamos la posición inicial usando la biblioteca Numpy. Declaramos dos matrices y asignamos estas matrices a la variable, respectivamente.

Ahora llamamos a la función MeshGrid () de la biblioteca Numpy. Esta función contiene dos parámetros. Ahora hacemos dos nuevas variables. Estas variables almacenan los puntos que muestran la dirección de las flechas. Tenemos que crear una trama usando el PLT.función subplot (). Podemos ajustar el tamaño de la gráfica con esta función.

Mientras tanto, aplicamos el hacha.Método Quiver (). Y este método contiene cuatro argumentos, incluidos los puntos de posición iniciales de las flechas y los puntos de dirección de las flechas. Declaramos dos funciones AX.eje.set_ticks ([]) y ax.yaxis.set_ticks ([]) que elimina las letreros de la marca del eje X y el eje Y.

Podemos hacer esto usando un hacha.eje(). Aquí modificamos los límites del eje. Al final, antes de mostrar el gráfico, definimos el hacha.Función set_aspect (). Esta función determina la relación de perspectiva de la gráfica.

En este caso, obtenemos este tipo de gráfico utilizando el método de la cuadrícula de malla. Este gráfico muestra una gráfica de carcaj que tiene múltiples flechas.

Especifique el color de la trazado de color a carcaj:

El hacha de la biblioteca matplotlib.La función Quiver () contiene un color de parámetros adicional que define el tono de la flecha. Los contornos del parámetro de color carcaj deben ser los mismos que las mediciones de la ubicación y los elementos direccionales.

Importar matplotlib.Pyplot como PLT
importar numpy como np
Fig, (Ax1, Ax2) = PLT.subtramas (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.pecado (y)*y
n = -4
color = np.sqrt ((((v-n)/2)*2 + ((u-n)/2)*2)
ax1.Quiver (x, y, u, v, color, alfa = 1.0)
ax1.xaxis.set_ticks ([])
ax1.yaxis.set_ticks ([])
ax1.eje ([-0.2, 2.3, -0.2, 2.3])
ax1.set_aspect ('igual')
ax1.set_title ('Primera gráfica')
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.Gradiente (Z)
n = -4
color = np.sqrt ((((dx-n)/2)*2 + ((dy-n)/2)*2)
ax2.Quiver (x, y, dx, dy, color)
ax2.xaxis.set_ticks ([])
ax2.yaxis.set_ticks ([])
ax2.set_aspect ('igual')
ax2.set_title ('segundo gráfico')
PLT.TRIT_LAYOUT ()
PLT.espectáculo()

Presentamos el matplotlib.Pyplot como PLT y Numpy como bibliotecas NP. En el siguiente paso, vamos a definir subtramas y ajustar el tamaño del gráfico. Para dibujar la primera subtrama, creamos flechas usando el paquete Numpy. Las posiciones iniciales y las direcciones de las flechas se definen para las flechas de la primera subtrama.

Además, establecemos el color de las flechas llamando a la función. Creamos el gráfico aplicando la función Quiver (). Aquí asignamos el color de la trama. Especificamos el título de la primera subtrama llamando a la función set_title ().

Ahora vamos por la segunda trama secundaria. Para crear flechas para la segunda subtrama, especificamos las posiciones iniciales y el punto para las direcciones de las flechas. Creamos un gradiente entre ambas subtramas. Definimos el color para la segunda trama secundaria. Creamos la subplot usando la función Quiver (). Decidimos el color de las flechas de la segunda trama secundaria.

Al final, mostramos el gráfico llamando al PLT.método show ().

Conclusión:

Utilizamos Matplotlib y Python para crear una variedad de nuevos gráficos temblores en este artículo. El paquete Pyplot de Matplotlib incluye gráficos Quiver. Los puntos posicionales de x e y y las direcciones de las flechas son los parámetros para el hacha.función quiver (). El método MeshGrid () en Numpy puede generar tales módulos posicionales. Además, introdujimos un tono adicional en gráficos temblores llamando al hacha.función quiver () con un nuevo parámetro 'color'.'