Aljava de matplotlib

Um gráfico de aljava mostra componentes de velocidade como setas contendo parâmetros direcionais u e v nas variáveis ​​bidimensionais x e y. Para usar o método Quiver () em Matplotlib, geraremos um gráfico de aljava. Os gráficos de aljava ilustrariam a produção elétrica em engenharia elétrica e demonstram variações de pressão na engenharia mecânica.

Neste artigo, discutiremos os métodos de como criar gráficos de aljava no Python.

Desenhe o enredo de aljava com uma seta:

Nesta etapa, vamos criar um enredo de aljava que tenha uma flecha e observaremos o funcionamento do matplotlib.machado.Função de Quiver ().

importar matplotlib.pyplot como plt
importar numpy como np
x = 2
y = 2
u = 3
v = 3
fig, ax = pLT.subparcelas (figSize = (5, 5))
machado.aljava (x, y, u, v)
machado.set_title ('trama de aljava')
plt.mostrar()

Para criar as lotes de aljava, devemos adquirir as bibliotecas necessárias: Matplotlib e Numpy. Para criar a flecha, declaramos algumas variáveis ​​e damos valores aleatórios. Essas variáveis ​​mostram a posição e a direção da seta. Além disso, criamos um objeto que mostra o tamanho da figura.

Nós chamamos a função aljava (). Esta função contém quatro parâmetros. Os parâmetros 'x' e 'y' mostram os pontos de partida da seta desenhada. As diretivas da flecha são mostradas pelos parâmetros 'u' e 'v.'Além disso; Nós chamamos o conjunto.função title (), que mostra o rótulo do enredo de aljava. No final, podemos exibir o gráfico de aljava usando o PLT.show () função.

Este gráfico tem uma seta de aljava na saída que começa no 'x' = 2 e 'y' = 2. Em 'u' = 3 e 'v' = 3, a direção da seta desenhada é para cima e para a direita.

Desenhe o enredo de aljava com duas setas:

Agora temos que inserir outra flecha no gráfico. Podemos conseguir isso fornecendo dois pontos iniciais de seta e duas diretivas das setas.

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]
machado.aljava (x, y, u, v,
Escala = 8)
machado.eixo ([ -5, 5, -5, 5])
plt.mostrar()

Depois de integrar as bibliotecas matplotlib.Pyplot como PLT e Numpy como NP, chamamos a função PLT.Subparcelas () funções para criar o gráfico. Em seguida, declaramos duas matrizes que contêm os pontos iniciais das setas. Enquanto isso, armazenamos essas matrizes nas variáveis ​​'x' e 'y'.

Da mesma forma, declaramos as outras duas matrizes que mantêm a direção das setas e as atribuem às variáveis ​​'u' e 'v'. Nós chamamos o machado.Função de Quiver () agora. No código acima, esta função possui 4 parâmetros, incluindo a posição inicial das setas e a direção das setas. Mas nesse cenário, um parâmetro adicional 'escala' é fornecido ao machado.Função de Quiver (). Este parâmetro é usado para ajustar a dimensão das setas.

Ao diminuir o valor do argumento de 'escala', podemos desenhar uma grande flecha. Podemos ajustar os pontos iniciais e de terminação das setas, definindo os limites para o machado.função eixo (). Fornecemos os parâmetros para que o primeiro parâmetro mostre o valor mínimo de 'x'; O segundo parâmetro mostra o valor máximo de 'x'; O terceiro parâmetro mostra o valor mínimo de 'y', e o último parâmetro mostra o valor máximo de 'y'.

Agora o gráfico é exibido usando o PLT.show () função.

Temos duas flechas neste gráfico. Uma seta tem uma posição inicial (1, 1), apontando na direção certa para cima. Da mesma forma, a outra seta tem uma posição inicial (1, 1) e também está apontando na direção certa para baixo.

Desenhe o enredo de aljava por uso da grade de malha:

O programa subsequente demonstra como mostrar um enredo de aljava com a ajuda de uma grade de malha:

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.subparcelas (figSize = (12, 10))
machado.aljava (x, y, u, v)
machado.Xaxis.set_ticks ([])
machado.yaxis.set_ticks ([])
machado.eixo ([-0.2, 2.2 -0.2, 2.2])
machado.set_aspect ('igual')
plt.mostrar()

No início do programa, importamos dois pacotes, matplotlib.pyplot tão plt e numpy quanto np. Aqui criamos a posição inicial usando a biblioteca Numpy. Declaramos duas matrizes e atribuímos essas matrizes à variável, respectivamente.

Agora chamamos a função MeshGrid () da biblioteca Numpy. Esta função contém dois parâmetros. Agora, fazemos duas novas variáveis. Essas variáveis ​​armazenam os pontos que mostram a direção das setas. Temos que criar um enredo usando o PLT.Função Subplot (). Podemos ajustar o tamanho da trama com esta função.

Enquanto isso, aplicamos o machado.Método Quiver (). E este método mantém quatro argumentos, incluindo os pontos de posição inicial das setas e os pontos de direção das setas. Declaramos duas funções AX.eixo.set_ticks ([]) e machado.yaxis.set_ticks ([]) que elimina os sinais de carrapato do eixo x e y.

Podemos fazer isso usando um machado.eixo(). Aqui modificamos os limites do eixo. No final, antes de exibir o gráfico, definimos o machado.função set_aspect (). Esta função determina a taxa de perspectiva da trama.

Nesse caso, obtemos esse tipo de gráfico usando o método da grade de malha. Este gráfico mostra um gráfico de aljava com várias setas.

Especifique a cor para treinar a trama:

O machado da biblioteca Matplotlib.A função Quiver () contém uma cor de parâmetro adicional que define o tom da seta. Os contornos do parâmetro de cor de trêmula devem ser os mesmos que as medições da localização e elementos direcionais.

importar matplotlib.pyplot como plt
importar numpy como np
Fig, (AX1, AX2) = PLT.subparcelas (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
cor = np.sqrt (((v-n)/2)*2 + ((u-n)/2)*2)
AX1.aljava (x, y, u, v, cor, alfa = 1.0)
AX1.Xaxis.set_ticks ([])
AX1.yaxis.set_ticks ([])
AX1.eixo ([-0.2, 2.3, -0.2, 2.3])
AX1.set_aspect ('igual')
AX1.set_title ('Primeiro Lote')
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
cor = np.sqrt (((dx-n)/2)*2 + ((dy-n)/2)*2)
AX2.aljava (x, y, dx, dy, cor)
AX2.Xaxis.set_ticks ([])
AX2.yaxis.set_ticks ([])
AX2.set_aspect ('igual')
AX2.set_title ('segundo lote')
plt.Fight_Layout ()
plt.mostrar()

Apresentamos o matplotlib.Pyplot como PLT e Numpy como Bibliotecas NP. Na próxima etapa, vamos definir subparcelas e ajustar o tamanho do gráfico. Para desenhar a primeira subtrama, criamos flechas usando o pacote Numpy. As posições iniciais e as direções das setas são definidas para as setas da primeira subtrama.

Além disso, definimos a cor das setas chamando a função. Criamos o gráfico aplicando a função Quiver (). Aqui atribuímos a cor da trama. Especificamos o título da primeira subtrama chamando a função set_title ().

Agora vamos para a segunda subtrama. Para criar flechas para a segunda subtrama, especificamos as posições e o ponto iniciais das instruções das setas. Criamos um gradiente entre as duas subparcelas. Definimos a cor da segunda subtrama. Criamos a subtrama usando a função Quiver (). Decidimos a cor das setas da segunda subparcela.

No final, mostramos o gráfico chamando o PLT.Método Show ().

Conclusão:

Utilizamos Matplotlib e Python para criar uma variedade de novos gráficos de quiver neste artigo. O pacote PyPlot do Matplotlib inclui gráficos de trêmulo. Os pontos posicionais de x e y e as direções das setas são os parâmetros para o machado.Função de Quiver (). O método MeshGrid () em Numpy pode gerar esses módulos posicionais. Além disso, introduzimos uma tonalidade adicional em gráficos de trêmulo chamando o machado.Quiver () função com um novo parâmetro 'cor.'