python - font - Trazar de forma no bloqueante con Matplotlib

matplotlib title position

Question

He estado jugando con Numpy y matplotlib en los últimos días. Tengo problemas para hacer que matplotlib trace una función sin bloquear la ejecución. Sé que ya hay muchos temas aquí en SO que hacen preguntas similares, y he buscado mucho en Google, pero no he logrado hacer que esto funcione.

He intentado usar show (block = False) como algunas personas sugieren, pero todo lo que obtengo es una ventana congelada. Si simplemente llamo a show (), el resultado se traza correctamente, pero la ejecución se bloquea hasta que se cierre la ventana. De otros hilos que he leído, sospecho que si show (block = False) funciona o no depende del back-end. ¿Es esto correcto? Mi back end es Qt4Agg. ¿Podrías echar un vistazo a mi código y decirme si ves algo mal? Aquí está mi código. Gracias por cualquier ayuda.

from math import *
from matplotlib import pyplot as plt
print plt.get_backend()
def main():
x = range(-50, 51, 1)
for pow in range(1,5): # plot x^1, x^2, ..., x^4
y = [Xi**pow for Xi in x]
print y
plt.plot(x, y)
plt.draw()
#plt.show() #this plots correctly, but blocks execution.
plt.show(block=False) #this creates an empty frozen window.
_ = raw_input("Press [enter] to continue.")
if __name__ == ''__main__'':
main()

PD. Olvidé decir que me gustaría actualizar la ventana existente cada vez que trazo algo, en lugar de crear uno nuevo.

Answer 1

Pasé mucho tiempo buscando soluciones y encontré esta respuesta .

Parece que, para obtener lo que usted (y yo) queremos, necesita la combinación de plt.ion() , plt.show() (no con blocking=False , eso está en desuso) y, lo más importante, plt.pause(.001) (o lo que quieras). La pause es necesaria porque los eventos de la GUI suceden mientras el código principal está en reposo, incluido el dibujo. Es posible que esto se implemente recogiendo el tiempo de un hilo que duerme, por lo que los IDE pueden meterse con eso, no sé.

Aquí hay una implementación que funciona para mí en Python 3.5:

import numpy as np
from matplotlib import pyplot as plt
def main():
plt.axis([-50,50,0,10000])
plt.ion()
plt.show()
x = np.arange(-50, 51)
for pow in range(1,5): # plot x^1, x^2, ..., x^4
y = [Xi**pow for Xi in x]
plt.plot(x, y)
plt.draw()
plt.pause(0.001)
input("Press [enter] to continue.")
if __name__ == ''__main__'':
main()

Answer 2

Puede evitar el bloqueo de la ejecución escribiendo la trama en una matriz, y luego mostrando la matriz en una secuencia diferente. Aquí hay un ejemplo de generación y visualización de gráficos simultáneamente usando pf.screen desde pyformulas 0.2.8 :

import pyformulas as pf
import matplotlib.pyplot as plt
import numpy as np
import time
fig = plt.figure()
canvas = np.zeros((480,640))
screen = pf.screen(canvas, ''Sinusoid'')
start = time.time()
while True:
now = time.time() - start
x = np.linspace(now-2, now, 100)
y = np.sin(2*np.pi*x) + np.sin(3*np.pi*x)
plt.xlim(now-2,now+1)
plt.ylim(-3,3)
plt.plot(x, y, c=''black'')
# If we haven''t already shown or saved the plot, then we need to draw the figure first...
fig.canvas.draw()
image = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='''')
image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))
screen.update(image)
#screen.close()

Resultado:

Descargo de responsabilidad: soy el mantenedor de las pyformulas.

Referencia: Matplotlib: guardar el diagrama para numpy array

Answer 3

Un truco simple que funciona para mí es el siguiente:

1. Usa el bloque = Falso dentro de show: plt.show ( block = False )
2. Use otro show () al final del script .py.

Ejemplo :

import matplotlib.pyplot as plt
plt.imshow(add_something)
plt.xlabel("x")
plt.ylabel("y")
plt.show(block=False)
#more code here (e.g. do calculations and use print to see them on the screen
plt.show()

Nota : plt.show() es la última línea de mi script.