Matplotlib plott flere linjer

Matplotlib -modulen, det mest utnyttede biblioteket for visuell analyse, er tilgjengelig i Python. Det tilbyr mange diagrammer, metoder og omfattende rammer for effektiv dataanalyse. Vi kan lage 2D- og 3D -visualiseringer av datasett fra forskjellige domener, inkludert sett, matriser og numeriske verdier.

Den har en undermodul som kalles Pyplot, og den tilbyr flere former for grafer, illustrasjoner og tilhørende komponenter for datavisualisering. Et linjeplott er en graf som skildrer forholdet mellom to uavhengige variabler på en X-Y-akse. Vi skal diskutere metodene for å vise forskjellige linjer som bruker matplotlib i denne opplæringen.

Bruke flere linjer av linjer for å visualisere forskjellige linjer:

Ved hjelp av matplotlib kan vi til og med designe og lage mange linjer med forskjellige linjemønstre. Unike linjestiler kan være involvert i effektiviteten av å visualisere dataene.

Importer matplotlib.Pyplot som Plt
Importer numpy som NP
a = [2,4,6,8,10]
B = [8,8,8,8,8]
plt.plot (a, b, label = "første linje", linestyle = "-.")
plt.Plot (B, A, Label = "Second Line", Linestyle = "-")
plt.plot (a, np.sin (a), label = "tredje linje", linestyle = ":")
plt.Plott (B, NP.cos (a), label = "fjerde linje", linestyle = "-"))
plt.legende()
plt.forestilling()

I begynnelsen av koden importerer vi bare to biblioteker matplotlib.Pyplot som PLT og en numerisk pakke for Python kalt Numpy som NP. Vi krever to oppføringer som data, som hver har to separate variabler (A og B), før de presenterer linjene som distinkte konstruksjoner og parametere for de samme datasettene.

Videre vil vi bruke PLT.plot () funksjon for å generere flere linjer. Det er fire parametere involvert i disse funksjonene. Den første parameteren for funksjonen inneholder det første datasettet for å opprette linjen. Et annet datasett er også gitt som en parameter. Vi bruker "etikett" -argumentet for å spesifisere forskjellige tagger av de trukket linjene.

I tillegg til dette, må vi oppgi forskjellige mønstre for linjene. I dette eksemplet bruker vi '-', '-', '-.', og': 'linjestiler. Vi bruker PLT.Legend () Funksjon. Legend () er en metode i Matplotlib -biblioteket som vil bli brukt til å sette inn en tagg på flyene. Plt.Vis () -funksjon brukes for å visualisere plottet.

Flere linjer er tegnet med en legende i Python:

Ved å gi etiketten gitt til linjene på grunn av identifikasjonen i matplotlib.Pyplot.Plot () -metode, vi vil legge til en etikett i diagrammet for å skille mange linjer i plottet i Python med matplotlib.

Importer matplotlib.Pyplot som Plt
A1 = [150.250.350]
B1 = [250.100.350]
plt.Plot (A1, B1, Label = "First Line")
A2 = [100.200.300]
B2 = [200.100.300]
plt.Plot (A2, B2, Label = "Second Line")
plt.xlabel ('x')
plt.ylabel ('y')
plt.tittel ('figur')
plt.legende()
plt.forestilling()

Her må vi integrere matplotlib -pakken før vi starter koden. For å definere punktene på den første linjen, erklærer vi to forskjellige variabler, 'A1' og 'B1'. Nå må vi plante disse punktene, så vi ringer PLT.plot () -funksjon for den første linjen. Denne funksjonen har tre argumenter: punktene til x-aksen og y-aksen, og parameteren 'label' viser bildeteksten til den første linjen.

Tilsvarende definerer vi datasett for denne linjen. Disse datasettene lagres i to separate variabler. For å plotte datasettene på den andre linjen, PLT.plot () -funksjonen er definert. Inne i denne funksjonen spesifiserte vi taggen for den andre linjen.

Nå bruker vi to separate funksjoner for å definere etiketten til både x-aksen og y-aksen deretter. Vi setter også etiketten til plottet ved å ringe PLT.Tittel () Funksjon. Rett før vi presenterer plottet, utfører vi matplotlib.Pyplot.Legend () -funksjonen, som vil legge bildeteksten til figuren siden alle linjene vises.

Tegn forskjellige plotlinjer med tydelige skalaer:

Vi har ofte to sett med data som er passende for linjer i grafene; Datapunktene deres er imidlertid drastisk forskjellige, og å gjøre en sammenligning mellom disse to linjene er vanskelig. Vi tegner den eksponentielle sekvensen langs en loggskala i dette trinnet, noe som kan resultere i en relativt horisontal linje fordi Y-skalaen vil utvide seg gradvis.

Importer matplotlib.Pyplot som Plt
Importer numpy som NP
linear_sequence = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
eksponentiell_sequence = np.EXP (NP.Linspace (0, 20, 20))
Fig, AX = PLT.underplott ()
øks.plot (linear_sequence, color = 'svart')
øks.Tick_Params (Axis = 'Y', LabelColor = 'Black')
AX1 = AX.Twinx ()
AX1.plot (exponential_sequence, color = 'blue')
AX1.set_yscale ('log')
AX1.Tick_Params (Axis = 'Y', LabelColor = 'Blue')
plt.forestilling()

I dette tilfellet, la oss utvikle en eksponentielt voksende serie med tall med Numpy, og vise deretter den ene serien ved siden av den andre sekvensen langs de samme aksene, sekvensielt. Vi definerte forskjellige verdier for både Linear_Sequence Dataset og Exponential_Sequence Dataset.

Vi må tegne linjen for punktene for lineær sekvens ved å kalle øksen.plot () -metode. Og vi spesifiserte også fargelegging av flåtttekstene til svart farge. For dette formålet definerer vi funksjonsøksen.Tick_Params (). Øksen.Twinx () -metode kalles for å utvikle en ny akselinje som ligger i samme posisjon.

Tilsvarende tegner vi linjen for eksponentiell sekvens, og vi definerer også fargen på denne linjen og dens etikett. Hvis den første linjen inneholder en gradvis utvidende serie med verdier og den andre linjen har en lineært økende serie med tall, kan den første linjen ha mye større tall enn den andre linjen.

Vi har i tillegg oppdatert fargen på hake -titlene for å endre fargen på linjetomtene; ellers ville det være tøft å forutsi hvilken linje som er på hvilken akse.

Ulike linjer vises i Python av et dataaframe:

I Python kan vi også bruke matplotlib for å lage forskjellige linjer i samme graf ved data oppnådd av en dataaframe. Vi vil oppnå dette ved å bruke matplotlib.Pyplot.Plot () -metode for å definere flere verdier fra DataFrame som X-Axis og Y-Axis-argumenter. Ved å dele ut DataFrame, vil vi også spesifisere elementer.

Importer pandaer som PD
Importer matplotlib.Pyplot som Plt
Importer numpy som 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.gi nytt navn (kolonner = 0: 'a', 1: 'b', 2: 'c', inplace = true)
trykk (NP.form (df), type (df), df, sep = '\ n')
plt.plot (df ['a'], df ['b'], color = 'b', label = 'første linje')
plt.plot (df ['a'], df ['c'], color = 'g', label = 'andre linje')
plt.legende()
plt.forestilling()

Vi skaffer oss pakkene som kreves i dette tilfellet. For en visuell representasjon bruker vi Pyplot fra matplotlib, numpy for datainnsamling og prosessering, og pandaer for å indikere datasettet. Nå får vi dataene for dette scenariet. Så vi utvikler en dataaframe for å spesifisere den numeriske verdien som må representeres.

Vi initialiserer en 2D -matrise, og det blir gitt til Pandas 'bibliotek her. Vi kaller DF.gi nytt navn () -funksjon og komponentetikettene blir endret til 'x', 'y' og 'z'. I tillegg til dette, definerer vi funksjonene for å vise linjene på plottet. Derfor organiserer vi dataene og legger til grafattributtene som vi ønsker å være i plottet. Attributtet 'farge' og 'etikett' er gitt til PLT.plot () funksjon. Til slutt representerer vi figuren.

Konklusjon:

I denne artikkelen observerte vi hvordan vi kan bruke matplotlib for å vise mange linjer på samme graf eller dimensjoner. Vi har snakket om hvordan du viser linjene i de samme aksene som har flere skalaer, hvordan du viser linjer med etiketter og visningslinjer i en figur med en dataaframe.