libe - matplotlib python3




C'è un modo per separare i grafici di matplotlib in modo che il calcolo possa continuare? (12)

È meglio controllare sempre con la libreria che si sta utilizzando se supporta l'utilizzo in modo non bloccante .

Ma se vuoi una soluzione più generica, o se non c'è altro modo, puoi eseguire qualsiasi cosa che blocchi in un processo separato usando il modulo multprocessing incluso in python. Il calcolo continuerà:

from multiprocessing import Process
from matplotlib.pyplot import plot, show

def plot_graph(*args):
    for data in args:
        plot(data)
    show()

p = Process(target=plot_graph, args=([1, 2, 3],))
p.start()

print 'yay'
print 'computation continues...'
print 'that rocks.'

print 'Now lets wait for the graph be closed to continue...:'
p.join()

Questo ha il sovraccarico di lanciare un nuovo processo e talvolta è più difficile eseguire il debug su scenari complessi, quindi preferirei l'altra soluzione (usando le chiamate API non matplotlib di matplotlib )

Dopo queste istruzioni nell'interprete Python si ottiene una finestra con una trama:

from matplotlib.pyplot import *
plot([1,2,3])
show()
# other code

Sfortunatamente, non so come continuare a esplorare in modo interattivo la figura creata da show() mentre il programma esegue ulteriori calcoli.

È possibile a tutti? A volte i calcoli sono lunghi e sarebbe utile se procedessero durante l'esame dei risultati intermedi.


A mio parere, le risposte in questa discussione forniscono metodi che non funzionano per tutti i sistemi e in situazioni più complesse come le animazioni. Suggerisco di dare un'occhiata alla risposta di MikeTex nel thread seguente, in cui è stato trovato un metodo robusto: come aspettare che l'animazione matplotlib finisca?


Ho dovuto aggiungere anche plt.pause(0.001) al mio codice per farlo funzionare all'interno di un ciclo for (altrimenti mostrerebbe solo il primo e l'ultimo grafico):

import matplotlib.pyplot as plt

plt.scatter([0], [1])
plt.draw()
plt.show(block=False)

for i in range(10):
    plt.scatter([i], [i+1])
    plt.draw()
    plt.pause(0.001)

In molti casi è più conveniente salvare l'immagine come file .png sul disco rigido. Ecco perché:

vantaggi:

  • Puoi aprirlo, dare un'occhiata e chiuderlo in qualsiasi momento nel processo. Questo è particolarmente comodo quando la tua applicazione è in funzione da molto tempo.
  • Non si apre nulla e non sei costretto ad aprire le finestre. Questo è particolarmente comodo quando hai a che fare con molte figure.
  • L'immagine è accessibile per riferimenti futuri e non viene persa quando si chiude la finestra della figura.

Inconveniente:

  • L'unica cosa che posso pensare è che dovrai andare a cercare la cartella e aprire l'immagine da solo.

Provare

from matplotlib.pyplot import *
plot([1,2,3])
show(block=False)
# other code
# [...]

# Put
show()
# at the very end of your script
# to make sure Python doesn't bail out
# before you finished examining.

La documentazione di show() dice:

In modalità non interattiva, visualizza tutte le figure e il blocco finché le figure non sono state chiuse; in modalità interattiva non ha alcun effetto a meno che non siano state create figure prima di passare dalla modalità non interattiva alla modalità interattiva (sconsigliato). In tal caso visualizza le figure ma non blocca.

Un singolo argomento della parola chiave sperimentale, block , può essere impostato su True o False per sovrascrivere il comportamento di blocco sopra descritto.


Se ho capito bene la domanda, usare Ipython (o Ipython QT o Ipython) ti permetterebbe di lavorare in modo interattivo con il grafico mentre i calcoli vanno in background. http://ipython.org/


Se stai lavorando in console, ad esempio in IPython puoi usare plt.show(block=False) come indicato nelle altre risposte. Ma se sei pigro puoi semplicemente digitare:

plt.show(0)

Quale sarà lo stesso.



Usa la parola chiave "blocco" per ignorare il comportamento di blocco, ad es

from matplotlib.pyplot import show, plot

plot(1)  
show(block=False)

# your code

per continuare il tuo codice.


Usa le chiamate di matplotlib che non bloccheranno:

Usando draw() :

from matplotlib.pyplot import plot, draw, show
plot([1,2,3])
draw()
print 'continue computation'

# at the end call show to ensure window won't close.
show()

Utilizzo della modalità interattiva:

from matplotlib.pyplot import plot, ion, show
ion() # enables interactive mode
plot([1,2,3]) # result shows immediatelly (implicit draw())

print 'continue computation'

# at the end call show to ensure window won't close.
show()

IMPORTANTE : solo per chiarire qualcosa. Presumo che i comandi siano all'interno di uno script .py e che lo script venga chiamato usando ad esempio python script.py dalla console.

Un modo semplice che funziona per me è:

  1. Usa il blocco = False all'interno dello show: plt.show (block = False)
  2. Usa un altro show () alla fine dello script .py.

Esempio di file script.py :

plt.imshow(*something*)                                                               
plt.colorbar()                                                                             
plt.xlabel("true ")                                                                   
plt.ylabel("predicted ")                                                              
plt.title(" the matrix")  

# Add block = False                                           
plt.show(block = False)

# OTHER CALCULATIONS AND CODE

# the next is the last line of my script
plt.show()

plt.figure(1)
plt.imshow(your_first_image)

plt.figure(2)
plt.imshow(your_second_image)

plt.show(block=False) # That's important 

raw_input("Press ENTER to exist") # Useful when you run your Python script from the terminal and you want to hold the running to see your figures until you press Enter






plot