Plotagem matplotlib Várias linhas

O módulo Matplotlib, a biblioteca mais amplamente utilizada para análise visual, é acessível no Python. Oferece muitos gráficos, métodos e estruturas abrangentes para análise de dados eficientes. Poderíamos fazer visualizações 2D e 3D de conjuntos de dados de vários domínios, incluindo conjuntos, matrizes e valores numéricos.

Possui um sub -módulo denominado PyPlot e oferece várias formas de gráficos, ilustrações e componentes associados para visualização de dados. Um gráfico de linha é um gráfico que descreve a relação entre duas variáveis ​​independentes em um eixo x-y. Vamos discutir os métodos para exibir diferentes linhas utilizando o matplotlib neste tutorial.

Usando vários padrões de linhas para visualizar linhas diferentes:

Com o auxílio do matplotlib, podemos até projetar e criar muitas linhas com padrões de linha diferentes. Estilos de linha exclusivos podem estar envolvidos na eficácia de visualizar os dados.

importar matplotlib.pyplot como plt
importar numpy como np
a = [2,4,6,8,10]
b = [8,8,8,8]
plt.plot (a, b, label = "primeira linha", linestyle = "-.")
plt.plot (b, a, label = "Segunda linha", linestyle = "-")
plt.Lote (A, NP.sin (a), label = "terceira linha", linestyle = ":")
plt.Lote (B, NP.cos (a), gravadora = "quarta linha", linestyle = "-")
plt.lenda()
plt.mostrar()

No início do código, apenas importamos duas bibliotecas matplotlib.Pyplot como PLT e um pacote numérico para Python chamado Numpy como NP. Exigiremos duas entradas como dados, cada uma com duas variáveis ​​separadas (A e B), antes de apresentar as linhas como construções e parâmetros distintos para os mesmos conjuntos de dados.

Além disso, utilizaremos o PLT.plot () função para gerar várias linhas. Existem quatro parâmetros envolvidos nessas funções. O primeiro parâmetro da função contém o primeiro conjunto de dados para criar a linha. Outro conjunto de dados também é fornecido como um parâmetro. Usamos o argumento 'rótulo' para especificar diferentes tags das linhas desenhadas.

Além disso, temos que declarar diferentes padrões para as linhas. Neste exemplo, empregamos '-', '-', '-.'e': 'estilos de linha. Aplicamos o PLT.função legend (). Legend () é um método na biblioteca Matplotlib que seria usada para inserir uma tag nos aviões. Plt.A função SHOW () é aplicada para visualizar o enredo.

Várias linhas são desenhadas com uma lenda em Python:

Fornecendo o rótulo dado às linhas por causa de sua identificação no matplotlib.Pyplot.Método plot (), adicionaremos um rótulo ao gráfico para distinguir inúmeras linhas no enredo em Python com matplotlib.

importar matplotlib.pyplot como plt
A1 = [150.250.350]
B1 = [250.100.350]
plt.Plot (A1, B1, Label = "Primeira linha")
A2 = [100.200.300]
B2 = [200.100.300]
plt.Plot (A2, B2, Label = "Segunda linha")
plt.xlabel ('x')
plt.ylabel ('y')
plt.título ('figura')
plt.lenda()
plt.mostrar()

Aqui devemos integrar o pacote Matplotlib antes de iniciar o código. Para definir os pontos da primeira linha, declaramos duas variáveis ​​diferentes, 'A1' e 'B1'. Agora temos que plotar esses pontos, então chamamos o PLT.plot () função para a primeira linha. Esta função mantém três argumentos: os pontos do eixo x e do eixo y, e o parâmetro 'rótulo' mostra a legenda da primeira linha.

Da mesma forma, definimos conjuntos de dados para esta linha. Esses conjuntos de dados são armazenados em duas variáveis ​​separadas. Para plotar os conjuntos de dados da segunda linha, o PLT.plot () função é definida. Dentro desta função, especificamos a tag para a segunda linha.

Agora empregamos duas funções separadas para definir o rótulo do eixo x e do eixo y. Também definimos o rótulo da trama chamando o PLT.função title (). Pouco antes de apresentar o enredo, executamos o matplotlib.Pyplot.função legend (), que adicionaria a legenda à figura, pois todas as linhas são exibidas.

Desenhe diferentes linhas de enredo com escalas distintas:

Geralmente, temos dois conjuntos de dados apropriados para linhas dos gráficos; No entanto, seus pontos de dados são drasticamente diferentes, e fazer uma comparação entre essas duas linhas é difícil. Desenhamos a sequência exponencial ao longo de uma escala de log nesta etapa, o que pode resultar em uma linha relativamente horizontal, porque a escala Y se expandirá gradualmente.

importar matplotlib.pyplot como plt
importar numpy como np
linear_sequence = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
exponencial_sequence = np.exp (np.Linspace (0, 20, 20))
fig, ax = pLT.subtramas ()
machado.plot (linear_sequence, color = 'preto')
machado.tick_params (axis = 'y', labelcolor = 'preto')
ax1 = ax.Twinx ()
AX1.plot (exponencial_sequence, color = 'azul')
AX1.set_yscale ('log')
AX1.tick_params (eixo = 'y', labelcolor = 'azul')
plt.mostrar()

Nesse caso, vamos desenvolver uma série de números exponencialmente em crescimento com Numpy, depois exibirá uma série ao lado da outra sequência ao longo dos mesmos eixos, sequencialmente. Definimos valores diferentes para o conjunto de dados Linear_Sequence e Exponencial_Sequence.

Temos que desenhar a linha dos pontos para a sequência linear chamando o machado.Método plot (). E também especificamos a coloração das legendas para a cor preta. Para esse fim, definimos o machado de função.tick_params (). O machado.O método twinx () é chamado para desenvolver uma nova linha de eixos localizada na mesma posição.

Da mesma forma, desenhamos a linha para sequência exponencial e também definimos a cor desta linha e seu rótulo. Se a primeira linha contiver uma série de valores em expansão progressiva e a segunda linha possui uma série de números crescentes linearmente, a primeira linha pode ter números muito maiores do que a segunda linha.

Além disso, atualizamos o tom dos títulos para alterar a matiz das parcelas da linha; caso contrário, seria difícil prever qualquer linha que seja sobre qual eixo.

Diferentes linhas são exibidas em Python por um DataFrame:

No Python, também poderíamos utilizar o matplotlib para criar linhas diferentes no mesmo gráfico por dados obtidos por um dataframe. Vamos fazer isso usando o matplotlib.Pyplot.Método plot () para definir vários valores do quadro de dados como os argumentos do eixo x e do eixo y. Ao dividir o quadro de dados, também especificaremos elementos.

importar pandas como PD
importar matplotlib.pyplot como plt
importar numpy como np
df = pd.DataFrame ([[8, 6, 4], [11, 15, 6], [20, 13, 17],
[27, 22, 19], [33, 35, 16], [40, 25, 28],
[50, 36, 30]])
df.Renomear (colunas = 0: 'a', 1: 'b', 2: 'c', inplace = true)
Imprimir (NP.forma (df), tipo (df), df, sep = '\ n')
plt.plot (df ['a'], df ['b'], color = 'b', etiqueta = 'primeira linha')
plt.plot (df ['a'], df ['c'], color = 'g', etiqueta = 'segunda linha')
plt.lenda()
plt.mostrar()

Adquirimos os pacotes necessários nesta instância. Para uma representação visual, empregamos PyPlot da Matplotlib, Numpy para coleta e processamento de dados e pandas para indicar o conjunto de dados. Agora vamos obter os dados para este cenário. Por isso, desenvolvemos um quadro de dados para especificar o valor numérico que precisa ser representado.

Inicializamos uma matriz 2D e é fornecida à biblioteca dos pandas aqui. Nós chamamos o df.Renomear () função e os rótulos dos componentes estão sendo modificados para 'x', 'y' e 'z'. Além disso, definimos as funções para exibir as linhas no enredo. Portanto, organizamos os dados e adicionamos os atributos do gráfico que queremos estar no enredo. O atributo 'cor' e 'rótulo' é fornecido ao PLT.plot () função. No final, representamos a figura.

Conclusão:

Neste artigo, observamos como utilizar o matplotlib para mostrar muitas linhas no mesmo gráfico ou dimensões. Conversamos sobre como exibir as linhas dentro dos mesmos eixos com várias escalas, como exibir linhas com rótulos e exibir linhas em uma figura com um DataFrame.