Matplotlib vidinad

Matplotlib pole mõeldud ainult staatiliste graafikute jaoks. Kuigi GUI-d luuakse tavaliselt GUI teekide ja raamistikega, nagu PyQt, Tkinter, Pettunud ja wxPythonja kuigi Pythonil on suurepärane integratsioon PyQti, Tkinteriga ja wxPython – GUI põhifunktsioonide jaoks pole neid vaja kasutada Matplotlib vidinad.

. matplotlib.widgets moodulil on mitu klassi, sealhulgas AxesWidget, millest Buttons, CheckButtons, Sliders, TextBoxes jne on tuletatud. Need kõik aktsepteerivad Axes need lisatakse ühe ja ainsa kohustusliku konstruktori argumendina ning nende positsioneerimine tuleb käsitsi seadistada. Tuleb märkida, et vidin on teljed, nii et loote Axes eksemplar iga vidina jaoks.

Teine asi, mida tuleb tähele panna, on see peate alles jätma viited vidinatele vastasel juhul võidakse prügi koguda.

Igaüks neist saab ka seadistustega keelata active et False, sel juhul ei reageeri nad ühelegi sündmusele, näiteks klõpsamisele. Nagu öeldud, saame erinevate GUI elementide ja komponentide kaudu tutvustada oma süžeedele uut tüüpi interaktiivsust.

Märge: Matplotlib ei ole mõeldud kasutamiseks kvaliteetse GUI loomiseks ega kasutajasõbralike süsteemide jaoks. Need vidinad on algelised, ei näe eriti hea välja ja nende funktsionaalsus on piiratud. Need on mõeldud asjade prototüüpimiseks ja testimiseks, selle asemel, et neid tegelikult tarnida.

Kui olete PyQtiga varem töötanud, võite märgata, et nende vidinate lisamise ja sündmuste töötlejatega ühendamise üldine süntaks ja lähenemisviis on üsna tuttavad.

Nuppude lisamine

Alustame sellest nupud - matplotlib.widgets moodul määratleb a Button klass. Sellega ühenduse loomiseks helistame on_clicked() funktsioon, mis täidab meie pakutava funktsiooni. Kui klõps on tuvastatud, funktsioon käivitub.

Nupu loomise ajal määrame Axes selle külge, kasutatakse positsioneerimiseks. Võime läbida ka a label sel ajal teksti lisamiseks ja kasutaja jaoks märkuste tegemiseks. The color ja hovercolor argumendid määravad nupu värvi enne ja pärast selle kohale hõljutamist.

Kuna meie hoolitseme kõigi vidinate positsioneerimise ja ruumi eest – loome a Figure ja Axes, jätke nupu lisamiseks allosas tühikuid ja joonistage tühi hajuvusgraafik. Seejärel määratleme an EventHandler klass, millel on üks meetod add_random(). Meetod genereerib kaks juhuslikku arvu ja joonistab nende jaoks markeri Axes oleme varem loonud ja kõned plt.draw(), mis joonistab uuesti Figure. Kruntide uuendamisel peame alati helistama plt.draw() uuesti, et seda tegelikult värskendada:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Button fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2)
plot = ax.scatter([], []) class EventHandler: def add_random(self, event): x = np.random.randint(0, 100) y = np.random.randint(0, 100) ax.scatter(x, y) plt.draw() # Axes for the Button and positioning
# xposition and yposition in percentages, width, height
button_ax = plt.axes([0.7, 0.05, 0.2, 0.07])
# Create Button and assign it to `button_ax` with label
button = Button(button_ax, 'Add Random', color='green', hovercolor='red')
# On a detected click, execute add_random()
button.on_clicked(EventHandler().add_random) plt.show()

Selle tulemuseks on a Figure, tühjaga Axes selle sees ja nupp ekraani paremas ülanurgas Axes:

Ja pärast paarkümmend korda nupule vajutamist, meie ax täidetakse juhuslike markeritega:

Praktilisemalt võiksime luua a tsükkel funktsioone, mida iga nupuvajutusega joonistada. See nõuab mõningaid muudatusi EventHandler, samuti veel üks nupp selle tsükli läbimiseks.

Kasutame Punase veini kvaliteet andmekogum uuesti ja visualiseerida mitmeid funktsioone Alkohol tunnusjoon. Kuna me ei saa olla vaevunud neid eraldi joonistama, kirjutades koodi, mis joonistab ühe tunnuse teise vastu, ja seejärel muutke seda koodi, et joonistada mõni muu tunnus teise vastu.

Hajumaatriksi loomine võib meid siin aidata, kuid kui andmekogumil on palju funktsioone, on see üsna loetamatu ja me ei jõua kaugele. Kui sa tahaksid mõlemad suuremahulised süžeed, mida saate hõlpsalt vaadata ja tõlgendada, samuti kuna sellel on mitu funktsiooni, mida saab kasutada ilma täiendava pingutuseta – saate seda protsessi nuppude abil automatiseerida:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.widgets import Button fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2) df = pd.read_csv('winequality-red.csv')
plot = ax.scatter([], []) class EventHandler: i = 0 # Find and plot next feature, re-draw the Axes def next_feature(self, event): # If the counter is at the end of the columns # Revert it back to 0 to cycle through again if self.i >= len(df.columns): self.i = 0 # Clear Axes from last plot ax.cla() # Plot a feature against a feature located on the `i` column ax.scatter(df['alcohol'], df.iloc[:,self.i]) # Set labels ax.set_xlabel('Alcohol') ax.set_ylabel(df.columns[self.i]) # Increment i self.i += 1 # Update Figure plt.draw() def previous_feature(self, event): # If the counter is at the start of the columns # Revert it back to the last column to cycle through if self.i <= 0: self.i = len(df.columns)-1 ax.cla() ax.scatter(df['alcohol'], df.iloc[:,self.i]) ax.set_xlabel('Alcohol') ax.set_ylabel(df.columns[self.i]) self.i -= 1 plt.draw() # Add buttons
button1_ax = plt.axes([0.7, 0.02, 0.2, 0.07])
next_button = Button(button1_ax, 'Next Feature')
next_button.on_clicked(EventHandler().next_feature) button2_ax = plt.axes([0.45, 0.02, 0.2, 0.07])
previous_button = Button(button2_ax, 'Previous Feature')
previous_button.on_clicked(EventHandler().previous_feature) plt.show()

. EventHandler klassil on nüüd kaks meetodit – next_feature() ja previous_feature(). Mõlemad kontrollivad, kas loendur i on jõudnud veergude loendi lõppu või algusesse – ja et vältida IndexError, lähtestame indeksi vastupidisele väärtusele ja simuleerime a tsükkel. Lähen allapoole 0 viib meid tagasi lõpp veergude loendist ja viimasest veerust kõrgemale minnes pöördume tagasi esimese veeru juurde.

Pärast asukoha kindlakstegemist – meie tühjendage Axes, kuna me joonistaksime uuesti olemasolevale krundile ilma seda tühjendamata cla() (clkõrv axes). Teise võimalusena võite kuhjata ka funktsioonisuhteid, joonistades üksteise peale ja kasutades cla() avaldus indeksi lähtestamisel tsükli lõpus/alguses.

Pärast kustutamist Axes – meil on puhastatud lõuend, millele sellega maalida ax.scatter() funktsiooni. Selles näites on fikseeritud funktsioon Alkohol, seega on see kogu aeg olemas. Teine funktsioon on erinev ja sellele pääseb juurde iloc[], möödudes veeru indeksist. See tagastab a Series mida saame sellel süžeel kasutada. Samamoodi pääseme juurde veergude nimed ka nende indeksi kaudu – df.columns[index], mida kasutatakse Y-telje sildi määramiseks.

Lõpuks suurendame/vähendame loendurit ja helistame plt.draw() värskendada Figure:

Kui klõpsame nuppu Järgmine funktsioon nuppu, joonistatakse veergude loendi järgmine omadus AlkoholJa Figure ajakohastatakse asjakohaselt – sildid, markerid ja skaala. Sama kehtib ka teistpidi – Eelmine funktsioon läbib loendi vastupidises suunas, võimaldades meil liikuda edasi-tagasi, kasutades turvamehhanismi, mis lähtestab loenduri iga kord, kui jõuame tsükli lõppu või algusesse.

Raadionuppude ja märkeruutude lisamine

raadio nupud kasutatakse selleks, et võimaldada kasutajal valida üks väärtus väljaspool mitu väärtust. Korraga saab valida ainult ühe raadionupu ja need tähistavad tavaliselt valikut. Märkeruudud saab kasutada, kui soovite lasta kasutajal valida mitu valikut korraga.

Märge: Võimalus kontrollida, kas märkeruut on olemas, on väga piiratud on or maha. Tegelikult pole ühtegi karbist väljas. Saate ainult kontrollida, kas kast on pressitud or mitte, mis seab selle kasutamisele tõsise piirangu, kuna meil pole aimugi, millises olekus see enne seda oli. Ainus alternatiiv on säilitada oma loendur/kontroll kasti hetkeseisu kohta tõeväärtusega ja muuta selle alusel loogikat.

See võimaldab teil näiteks lisada iga jaoks märkeruudu kohandamise argument teatud süžee, võimaldades kasutajal neid määrata True or False (märgitud või märkimata) või mõni muu nendel olekutel põhinev mittekonfliktne kaardistus.

Kuna aga API on iseenesest piiratud, piirdume ka ettenähtud kasutusega – asjade sisse- ja väljalülitamisega. Meil on kaks funktsiooni, mida saame muuta on ja maha märkeruudu kaudu. Pange tähele, et isegi see funktsioon on piiratud objektidega, mille puhul saate kontrollida, kas need on nähtavad või mitte.

Teisest küljest ei taha me lubada kasutajal rakendada kahte skaalat korraga ega määrata korraga kahte X-limiiti, kuna rakendataks ainult lauset, mida nimetatakse jada teiseks. Nende jaoks kasutaksime raadionuppe.

Lisame paar raadionuppu, et kasutaja saaks paari raadionupu abil teljevahemikku valida, aga ka funktsioonide visualiseerimisi pöörata on ja maha:

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.widgets import CheckButtons
from matplotlib.widgets import RadioButtons fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2) df = pd.read_csv('winequality-red.csv') # Plot two line plots for two features, and turn them invisible
line1, = ax.plot(df['fixed acidity'], visible=False)
line2, = ax.plot(df['citric acid'], visible=False) class EventHandler: # set_range handler def set_range(label): if (label == 'Small Range'): ax.set_xlim(0, 1600) ax.set_ylim(0, 25) else: ax.set_xlim(0, 1600) ax.set_ylim(0, 50) plt.draw() # Turn off, if on, and on if off def apply_features(label): if (label == 'Fixed Acidity'): line1.set_visible(not line1.get_visible()) elif (label == 'Citric Acid'): line2.set_visible(not line2.get_visible()) plt.draw() # Add radio buttons and checkboxes
ranges_ax = plt.axes([0.7, 0.02, 0.2, 0.1])
range_radio_buttons = RadioButtons(ranges_ax, ('Small Range', 'Large Range'))
range_radio_buttons.on_clicked(EventHandler.set_range) checkboxes_ax = plt.axes([0.4, 0.02, 0.25, 0.1])
checkboxes = CheckButtons(checkboxes_ax, ('Fixed Acidity', 'Citric Acid'))
checkboxes.on_clicked(EventHandler.apply_features) plt.show()

Jällegi on meil kaks meetodit EventHandler() klass – set_range() ja apply_features(). set_range() meetod määrab vahemiku kas "väike" või "suur", reguleerides Axes' X ja Y-limiidid. The apply_features() funktsioon muudab visible varem koostatud joondiagrammide välja, lähtudes nende praegusest ajast visible olek. Kui visible == True, lülitame joondiagrammi välja ja vastupidi.

Line Plots'i nähtavuse kontrollimiseks peame lootma sisseehitatud võimalusele, kuna me ei saa kontrollida, kas see ruut oli varem märgitud või mitte. Seda sama võimet saab jäljendada a status Boolean ulatus EventHandler() klass, mis on seatud True ja False igal klikil jooniste tüüpide puhul, mis ei toeta kontrollimist, kas need on karbist väljas nähtavad.

Selle koodi käivitamise tulemuseks on a Figure kahe nupukomplektiga allosas. Kui märgime mõlemad märkeruudud, kuvatakse mõlemad jooned:

Saame need ükshaaval välja lülitada:

Ja me saame muuta vahemikku Axes raadionuppude kaudu:

Tekstikastide lisamine

Tekstikastid on harjunud koguma kasutaja andmed – ja me saame nende andmete põhjal graafikuid muuta. Näiteks võime paluda kasutajal sisestada funktsiooni nime või lisada funktsiooni, et meie süžee visualiseerida. Muidugi võib kasutaja sisendiga töötamine olla keeruline – alati on äärmuslikke juhtumeid, millele tähelepanu pöörata.

Kirjutame skripti, mis võimaldab kasutajal sisestada a funktsiooni nimi andmestikust ja Axes iga esitluse värskendused, et kajastada sisendit. Kasutaja mugavuse huvides anname neile teada, kui sisendit ei õnnestu veeru nimega sobitada:

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.widgets import TextBox fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2) df = pd.read_csv('winequality-red.csv') class EventHandler: def submit(feature_name): if feature_name != "" or feature_name != None: if feature_name in df: ax.cla() ax.plot(df[feature_name]) else: if len(textbox_ax.texts) > 2: del textbox_ax.texts[-1] textbox_ax.text(-2, 0.4, feature_name + ' was not found.') plt.draw() textbox_ax = plt.axes([0.7, 0.02, 0.2, 0.1])
textbox = TextBox(textbox_ax, 'Feature Name')
textbox.on_submit(EventHandler.submit) plt.show()

Meil on lihtne kontrollida, kas see on ette nähtud feature_name on tühi või None, sel juhul me midagi ei tee. Kui ei, siis kontrollime, kas feature_name on olemas DataFrame, lisades teate, et funktsiooni ei leitud, kui seda pole. Enne teksti lisamist tuleb aga veenduda, et eelmine kiri on eemaldatud, et uus sellega ei kattuks. The axes.texts atribuut on loetelu kõigist Text juhtumid an Axes. Alates sellest kuupäevast Axes on juba a Text näiteks meie oma TextBox, me ei taha midagi eemaldada, kui neid on 2 või vähem Text esinevad juhtumid – veateade ja TextBox silt.

Kui see on üle kahe, on meil juba veateade, mis tuleks eemaldada.

Kui funktsioon is kohal DataFrame, aga kustutame Axes ja joonista see:

Laiusevalijate lisamine

Span Selectors saab kasutada selleks, et kasutaja saaks valida andmevahemiku ja sellele keskenduda, määrates selle valiku alusel teljepiirangud. Vaikimisi toetavad paljud raamatukogud seda funktsiooni, kuid kahjuks ei toeta Matplotlib ja me peame seda käsitsi tegema. Lisaks peame lisama lisa „Lähtesta” nuppu, kui tahame suumimiseks samuti.

A lisamiseks Laiuse valija, me ei pea pühendama täiesti uut Axes selle jaoks – saame selle olemasoleva külge kinnitada, mis on väga mõttekas. Kui genereeritakse a SpanSelector, pakume Axes see kuulub, samuti sündmuste käitleja, millele järgneb 'horizontal' or 'vertical', mis pöörab Axes ja Span Selector mõlemad.

. useblit argument on tavaliselt seatud True sest see parandab jõudlust enamikus taustaprogrammides. Lisaks oleme lisanud mõned stiiliomadused, nagu näiteks määramine alpha ristkülikust, mis on loodud ulatusevalijana 0.5 ja facecolor kenale tab:blue:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.widgets import SpanSelector
from matplotlib.widgets import Button fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2) df = pd.read_csv('AmesHousing.csv') ax.scatter(x = df['Year Built'], y = df['Total Bsmt SF'], alpha = 0.6) class EventHandler: def select_horizontal(x, y): ax.set_xlim(x, y) plt.draw() def reset(self): ax.set_xlim(df['Year Built'].min(), df['Year Built'].max()) plt.draw span_horizontal = SpanSelector(ax, EventHandler.select_horizontal, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='tab:blue')) button_ax = plt.axes([0.7, 0.02, 0.2, 0.07])
button = Button(button_ax, 'Reset')
button.on_clicked(EventHandler.reset) plt.show()

Selle käivitamisel luuakse graafik, millelt saame valida ulatuseid ja neid sisse suumida, määrates telgede piirangud etteantud väärtustele:

Liugurite lisamine

Liugurid võimaldab kasutajatel valida paljude väärtuste vahel intuitiivselt, libistades markerit ja valides väärtuse. Tavaliselt kasutatakse liugureid graafiku mõne väärtuse, näiteks selle vahemiku, pidevaks värskendamiseks or isegi funktsioon. Näiteks saate liuguri abil reguleerida konstandi väärtust, mis omakorda mõjutab funktsiooni, mis sellele konstandile tugineb.

Kirjutame skripti, mis võimaldab meil muuta Y- ja X-telje piiranguid liuguri kaudu, mis võimaldab meil muuta vaatenurka, millest me oma andmeid vaatame:

import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider fig, ax = plt.subplots()
fig.subplots_adjust(bottom=0.2, left=0.2) df = pd.read_csv('winequality-red.csv')
plot, = ax.plot(df['volatile acidity']) class EventHandler: def update(val): ax.set_ylim(0, yslider.val) ax.set_xlim(0, xslider.val) plt.draw() xslider_ax = plt.axes([0.35, 0.03, 0.5, 0.07])
xslider = Slider( ax=xslider_ax, label="X-limit", valmin=0, valmax=len(df['volatile acidity']), valinit=len(df['volatile acidity']), orientation="horizontal"
) yslider_ax = plt.axes([0.03, 0.2, 0.07, 0.5])
yslider = Slider( ax=yslider_ax, label="Y-limit", valmin=0, valmax=3, valinit=1.5, orientation="vertical"
) xslider.on_changed(EventHandler.update)
yslider.on_changed(EventHandler.update) plt.show()

Oleme kohandanud polsterdust, et võimaldada liugurit vasakul ja allosas Axesja joonistas lihtsa joondiagrammi. Liuguri lisamiseks peame tegema an Axes selle jaoks, nagu enamiku teiste vidinate puhul, ja määrake see ax argument Slider konstruktori kaudu. Lisaks saame määrata liuguri miinimum-, maksimum- ja algväärtused. Tavaliselt on need dünaamilised vahemikud, mis põhinevad joonistatavatel andmetel, kuid neid saab ka käsitsi määrata skalaarväärtusi.

Lõpuks Sliders võib olla suunatud horisontaalselt või vertikaalselt. Kuna need on mõeldud pidevaks värskendamiseks hiireliigutusega – on_changed() funktsiooni kasutatakse vastuse käivitamiseks, kui kasutaja annab sisendi. Oleme muutnud EventHandler klass koos an update() funktsioon, mis lihtsalt reguleerib X- ja Y-limiitide väärtusi valvastavate liugurite kasutamine.

Selle koodi käivitamine loob kahe liuguriga graafiku, mida saame kasutada koodi ulatuse muutmiseks Axes:

• Münditark. Euroopa parim Bitcoini ja krüptobörs.
• Platoblockchain. Web3 metaversiooni intelligentsus. Täiustatud teadmised. TASUTA PÄÄS.
• CryptoHawk. Altcoini radar. Tasuta prooviversioon.
• Allikas: https://stackabuse.com/matplotlib-widgets/