Widget Matplotlib

Matplotlib non è solo per grafici statici. Mentre le GUI vengono generalmente create con librerie e framework GUI come PyQt, Tkinter, Kivy ed wxPython, e mentre Python ha un'eccellente integrazione con PyQt, Tkinter ed wxPython: non è necessario utilizzare nessuno di questi per alcune funzionalità di base della GUI, attraverso Widget Matplotlib.

I matplotlib.widgets il modulo ha diverse classi, inclusa la AxesWidget, fuori dal quale Buttons, CheckButtons, Sliders, TextBoxes, ecc. sono derivati. Tutti questi accettano il Axes vengono aggiunti come unico argomento di costruzione obbligatorio e il loro posizionamento deve essere impostato manualmente. Una cosa da notare è che il il widget è gli assi, quindi creerai un file Axes istanza per ciascun widget.

Un'altra cosa da notare è che devi mantenere i riferimenti ai widget in caso contrario, potrebbero ricevere la raccolta dei rifiuti.

Ognuno di essi può anche essere disabilitato tramite impostazione active a False, nel qual caso non risponderanno ad alcun evento, ad esempio se viene fatto clic su di essi. Detto questo, possiamo introdurre un nuovo tipo di interattività nelle nostre trame, attraverso vari elementi e componenti della GUI.

Nota: Matplotlib non è pensato per essere utilizzato per la creazione di GUI di alta qualità, né per sistemi intuitivi. Questi widget sono rudimentali, non hanno un bell'aspetto e hanno funzionalità limitate. Sono intesi come un modo per prototipare e testare le cose, piuttosto che spedirle effettivamente.

Se hai già lavorato con PyQt, potresti notare che la sintassi generale e l'approccio per aggiungere questi widget, nonché collegarli ai gestori di eventi, sono abbastanza familiari.

Aggiunta di pulsanti

Cominciamo con pulsanti - Il matplotlib.widgets il modulo definisce a Button classe. Per connetterci ad esso, chiamiamo the on_clicked() funzione, che esegue la funzione che forniamo. Una volta rilevato un clic, la funzione viene eseguita.

Durante la creazione del pulsante, assegniamo un Axes ad esso, utilizzato per il posizionamento. Possiamo anche passare in a label in quel momento, per aggiungere del testo e annotarlo per un utente. IL color ed hovercolor gli argomenti definiscono il colore del pulsante prima e dopo il passaggio del mouse.

Poiché ci prendiamo cura del posizionamento e dello spazio per tutti i widget, creiamo un file Figure ed Axes, lasciare un po' di spazio nella parte inferiore per aggiungere un pulsante e tracciare un grafico a dispersione vuoto. Quindi definiremo un EventHandler class, che ha un unico metodo add_random(). Il metodo genera due numeri casuali e traccia un indicatore per essi sul file Axes abbiamo creato prima e chiama plt.draw(), che ridisegna il Figure. Quando aggiorniamo le trame, dovremo sempre chiamare plt.draw() di nuovo per aggiornarlo effettivamente:

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()

Ciò si traduce in a Figure, con un vuoto Axes al suo interno e un pulsante nell'angolo in alto a destra dello schermo, a sé stante Axes:

E dopo aver premuto il pulsante un paio di dozzine di volte, il nostro ax sarà popolato con marcatori casuali:

In termini più pratici, potremmo creare a ciclo di funzioni da tracciare ad ogni pressione del pulsante. Ciò richiede alcune modifiche al file EventHandler, così come un altro pulsante per tornare indietro attraverso quel ciclo.

Usiamo il file Qualità del vino rosso di nuovo il set di dati e visualizzare diverse funzionalità rispetto al file alcol caratteristica. Dal momento che non possiamo prenderci la briga di tracciarli individualmente scrivendo il codice per tracciare una caratteristica contro l'altra, e poi modificare quel codice per tracciare un'altra caratteristica contro l'altra.

Creare una matrice di dispersione potrebbe aiutarci in questo caso, ma se il set di dati ha molte funzionalità, sarà abbastanza illeggibile e non andremo lontano. Se desideri avere entrambi grafici su larga scala che puoi facilmente visualizzare e interpretare, anche poiché hai più funzionalità che scorrono senza alcuno sforzo aggiuntivo: puoi automatizzare questo processo con i pulsanti:

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()

I EventHandler la classe ora ha due metodi: next_feature() ed previous_feature(). Entrambi controllano se il contatore i ha raggiunto la fine o l'inizio dell'elenco delle colonne e per evitare un IndexError, reimpostamo l'indice sul valore opposto e simuliamo a ciclo. Andando sotto 0 ci riporterà al fine dell'elenco delle colonne e andando sopra l'ultima colonna si tornerà alla prima.

Dopo aver accertato dove ci troviamo, noi cancella il Axes, poiché complicheremmo di nuovo su un grafico esistente senza cancellarlo cla() (clorecchio ax). In alternativa, puoi anche accumulare relazioni tra caratteristiche, tracciandole una sopra l'altra e utilizzando il file cla() dichiarazione quando si reimposta l'indice alla fine/inizio del ciclo.

Dopo aver cancellato il file Axes – abbiamo una tela pulita su cui dipingere con ax.scatter() funzione. In questo esempio, la funzione fissa è alcol, quindi è presente in ogni momento. L'altra funzionalità varia ed è possibile accedervi tramite iloc[], passando nell'indice della colonna. Questo restituisce a Series che possiamo usare in questa trama. Allo stesso modo, possiamo accedere nomi di colonne anche attraverso il loro indice – df.columns[index], che viene utilizzato per impostare l'etichetta dell'asse Y.

Infine, aumentiamo/diminuiamo il contatore e chiamiamo plt.draw() per aggiornare il Figure:

Dopo aver fatto clic sul file Funzionalità successiva pulsante, verrà tracciata la caratteristica successiva nell'elenco delle colonne alcol, e il Figure saranno opportunamente aggiornati: etichette, indicatori e scala. Lo stesso vale al contrario – Caratteristica precedente attraverserà l'elenco nella direzione opposta, permettendoci di andare avanti e indietro, con un meccanismo di sicurezza che reimposta il nostro contatore ogni volta che arriviamo alla fine o all'inizio del ciclo.

Aggiunta di pulsanti di opzione e caselle di controllo

Pulsanti di scelta vengono utilizzati per consentire all'utente di selezionare un valore su diversi valori. È possibile selezionare un solo pulsante di opzione alla volta e in genere rappresentano una scelta. Caselle di controllo può essere utilizzato se desideri consentire all'utente di selezionare più opzioni contemporaneamente.

Nota: La capacità di verificare se una casella di controllo lo è è molto limitata on or MENO. In effetti, non ce n'è nessuno fuori dagli schemi. Puoi controllare solo se la casella lo è pressato or non, il che pone una seria limitazione al suo utilizzo poiché non abbiamo idea in quale stato si trovasse prima. L'unica alternativa è mantenere il proprio contatore/controllare lo stato corrente della scatola con un valore booleano e modificare la logica in base a quello.

Ciò ti consentirebbe, ad esempio, di aggiungere una casella di controllo per ciascuno argomento di personalizzazione di una determinata trama, consentendo all'utente di impostarli True or False (selezionato o deselezionato) o qualsiasi altra mappatura non in conflitto basata su questi stati.

Tuttavia, poiché l'API è di per sé limitata, ci limiteremo anche all'utilizzo previsto, attivando e disattivando le cose. Avremo due funzionalità che potremo trasformare on ed MENO tramite una casella di controllo. Tieni presente che anche questa funzionalità è limitata agli oggetti per i quali puoi verificare se sono visibili o meno.

D'altra parte, non vogliamo consentire all'utente di applicare due scale contemporaneamente, o di impostare due limiti X contemporaneamente, poiché verrebbe applicata solo l'istruzione chiamata secondo nella sequenza. Per questi utilizziamo i pulsanti radio.

Aggiungiamo un paio di pulsanti di opzione per consentire all'utente di selezionare l'intervallo dell'asse tramite un paio di pulsanti di opzione, ma consentiamo anche loro di attivare la visualizzazione delle funzionalità on ed MENO:

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()

Ancora una volta, abbiamo due metodi nel file EventHandler() classe - set_range() ed apply_features(). set_range() Il metodo imposta l'intervallo su "piccolo" o "grande", regolando il Axes' Limiti X e Y. IL apply_features() la funzione altera il visible campo dei grafici a linee che abbiamo realizzato in precedenza, in base alla loro corrente visible stato. Se visible == True, disattiviamo il grafico a linee e viceversa.

Dobbiamo fare affidamento sulla capacità integrata di verificare la visibilità dei grafici a linee, poiché non possiamo verificare se la casella di controllo è stata selezionata o meno prima. Questa stessa abilità può essere emulata con a status booleano nell'ambito di EventHandler() classe, che è impostata su True ed False ad ogni clic, per i tipi di grafico che non supportano il controllo se sono visibili immediatamente.

L'esecuzione di questo codice risulta in a Figure con due serie di pulsanti nella parte inferiore. Se selezioniamo entrambe le caselle, appariranno entrambi i grafici delle linee:

Possiamo disattivarli individualmente:

E possiamo cambiare la gamma di Axes tramite i pulsanti radio:

Aggiunta di caselle di testo

Caselle di testo sono abituati a raccogliere dati dall'utente - e possiamo modificare i grafici in base a questi dati. Ad esempio, possiamo chiedere a un utente di inserire il nome di una caratteristica o di inserire una funzione da visualizzare nel nostro grafico. Naturalmente, lavorare con l’input dell’utente può essere complicato: ci sono sempre casi limite a cui prestare attenzione.

Scriviamo uno script che consenta all'utente di inserire a nome della funzione di un set di dati e il Axes aggiornamenti su ogni invio per riflettere l'input. Per comodità dell'utente, gli faremo sapere se non è stato possibile abbinare l'input al nome di una colonna:

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()

Abbiamo un semplice controllo per vedere se il fornito feature_name è vuoto o None, nel qual caso non facciamo nulla. In caso contrario, controlliamo se il feature_name è presente in DataFrame, allegando un messaggio che la funzionalità non è stata trovata se non è presente. Prima di allegare il testo, però, dobbiamo assicurarci che il messaggio precedente venga rimosso, in modo che quello nuovo non si sovrapponga ad esso. IL axes.texts proprietà è un elenco di tutti i Text istanze su un Axes. Dal momento che il Axes ha già un Text esempio, appartenente al nostro TextBox, non vogliamo rimuovere nulla se ce ne sono 2 o meno Text istanze presenti: il messaggio di errore e il file TextBox .

Se superiore a due, abbiamo già un messaggio di errore, che dovrebbe essere rimosso.

Se la funzionalità is presente nel DataFrame, tuttavia, cancelliamo il Axes e traccialo:

Aggiunta di selettori di intervallo

Selettori di intervallo può essere utilizzato per consentire all'utente di selezionare un intervallo di dati e concentrarsi su di esso, impostando i limiti dell'asse in base a tale selezione. Per impostazione predefinita, molte librerie supportano questa funzionalità, anche se sfortunatamente Matplotlib no e dovremo farlo manualmente. Inoltre, dovremo aggiungere un extra "Reset" pulsante se vogliamo Zoom indietro come pure.

Per aggiungere un Selettore di intervallo, non abbiamo bisogno di dedicare un intero nuovo Axes per esso – possiamo collegarlo a uno esistente, il che ha molto senso. Quando si genera a SpanSelector, forniamo il Axes a cui appartiene, così come il gestore dell'evento, seguito da 'horizontal' or 'vertical', che ruota il Axes ed Entrambi i selettori di intervallo.

I useblit l'argomento è in genere impostato su True perché migliora le prestazioni sulla maggior parte dei backend. Inoltre, abbiamo aggiunto alcune proprietà di stile, come l'impostazione del file alpha del rettangolo creato come selettore di estensione 0.5 e la facecolor ad un bello 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()

L'esecuzione di questo genera un grafico sul quale possiamo selezionare campate e ingrandirle impostando i limiti degli assi sui valori forniti:

Aggiunta di cursori

Sliders consentire agli utenti di selezionare tra molti valori in modo intuitivo facendo scorrere un indicatore e selezionando un valore. In genere, i dispositivi di scorrimento vengono utilizzati per aggiornare continuamente alcuni valori su un grafico, ad esempio il suo intervallo or anche una caratteristica. Ad esempio, puoi regolare il valore di una costante tramite un cursore, che a sua volta influisce su una funzione che si basa su quella costante.

Scriviamo uno script che ci permetta di modificare i limiti degli assi Y e X, tramite uno slider, che ci permetterà di cambiare la prospettiva da cui stiamo visualizzando i nostri dati:

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()

Abbiamo regolato l'imbottitura per consentire un cursore a sinistra e in basso Axese tracciato un semplice grafico a linee. L'aggiunta di uno slider richiede la creazione di un file Axes per esso, come con la maggior parte degli altri widget, e assegnarlo al file ax argomento del Slider tramite il costruttore. Inoltre, possiamo impostare i valori minimo, massimo e iniziale dello slider. Si tratta in genere di intervalli dinamici, basati sui dati che stai tracciando, ma possono anche essere valori scalari impostati manualmente.

Infine, Sliders possono essere orientati orizzontalmente o verticalmente. Dal momento che sono pensati per essere continuamente aggiornati tramite il passaggio del mouse, il file on_changed() la funzione viene utilizzata per attivare una risposta quando un utente fornisce input. Abbiamo ottimizzato il EventHandler lezione con un update() funzione che regola semplicemente i valori dei limiti X e Y in base a value dei rispettivi cursori.

L'esecuzione di questo codice produrrà un grafico con due cursori, che possiamo utilizzare per modificare l'ambito del file Axes:

• Coinsmart. Il miglior scambio di bitcoin e criptovalute d'Europa.
• Platoblockchain. Web3 Metaverse Intelligence. Conoscenza amplificata. ACCESSO LIBERO.
• Criptofalco. Radar Altcoin. Prova gratuita.
• Fonte: https://stackabuse.com/matplotlib-widgets/