在 Python 解释器中执行这些指令后，您会看到一个带有绘图的窗口：
from matplotlib.pyplot import *
plot([1,2,3])
show()
# other code
不幸的是，我不知道如何show()在程序进行进一步计算时继续以交互方式探索创建的图形。
有可能吗？有时计算很长，如果在检查中间结果的过程中继续进行会有所帮助。
meteore
问问题
302887 次
21 回答
243
使用matplotlib不会阻塞的调用：
使用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()
使用交互模式：
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()
于 2009-01-19T16:52:17.983 回答
153
使用关键字 'block' 覆盖阻止行为，例如
from matplotlib.pyplot import show, plot
plot(1)
show(block=False)
# your code
继续您的代码。
于 2012-11-13T13:40:54.717 回答
32
如果它支持以非阻塞方式使用，最好始终检查您正在使用的库。
但是，如果您想要一个更通用的解决方案，或者没有其他方法，您可以使用multprocessingpython 中包含的模块在单独的进程中运行任何阻塞的东西。计算将继续：
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()
这具有启动新进程的开销，并且有时在复杂场景中更难调试，所以我更喜欢其他解决方案（使用matplotlib's 的非阻塞 API 调用）
于 2009-01-19T16:40:24.983 回答
26
尝试
import matplotlib.pyplot as plt
plt.plot([1,2,3])
plt.show(block=False)
# other code
# [...]
# Put
plt.show()
# at the very end of your script to make sure Python doesn't bail out
# before you finished examining.
show()文档说：
在非交互模式下，显示所有图形并阻塞，直到图形关闭；在交互模式下，除非在从非交互模式更改为交互模式之前创建图形（不推荐），否则它不起作用。在这种情况下，它会显示数字但不会阻塞。
单个实验性关键字参数 block 可以设置为 True 或 False 以覆盖上述阻止行为。
于 2013-01-18T11:53:33.170 回答
11
重要提示：只是为了说清楚。我假设命令在.py脚本中，并且使用例如python script.py从控制台调用脚本。
一个对我有用的简单方法是：
- 在 show 中使用 block = False ：plt.show(block = False)
- 在 .py 脚本的末尾使用另一个show() 。
文件示例 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 HERE ! ! !
################################
# the next command is the last line of my script
plt.show()
于 2017-03-08T14:37:09.667 回答
10
您可能想在matplotlib的文档中阅读此文档，标题为：
于 2009-01-19T17:00:04.630 回答
8
就我而言，我希望在计算它们时弹出几个窗口。供参考，方法如下：
from matplotlib.pyplot import draw, figure, show
f1, f2 = figure(), figure()
af1 = f1.add_subplot(111)
af2 = f2.add_subplot(111)
af1.plot([1,2,3])
af2.plot([6,5,4])
draw()
print 'continuing computation'
show()
PS。matplotlib 的 OO 界面非常有用的指南。
于 2009-01-21T14:05:30.923 回答
6
好吧，我在弄清楚非阻塞命令时遇到了很大的麻烦......但最后，我设法重新编写了“ Cookbook/Matplotlib/Animations - Animating selected plot elements ”示例，因此它适用于线程（并在线程之间传递数据）通过全局变量，或通过多Pipe进程）在 Ubuntu 10.04 上的 Python 2.6.5 上。
该脚本可以在这里找到：Animating_selected_plot_elements-thread.py - 否则粘贴在下面（注释较少）以供参考：
import sys
import gtk, gobject
import matplotlib
matplotlib.use('GTKAgg')
import pylab as p
import numpy as nx
import time
import threading
ax = p.subplot(111)
canvas = ax.figure.canvas
# for profiling
tstart = time.time()
# create the initial line
x = nx.arange(0,2*nx.pi,0.01)
line, = ax.plot(x, nx.sin(x), animated=True)
# save the clean slate background -- everything but the animated line
# is drawn and saved in the pixel buffer background
background = canvas.copy_from_bbox(ax.bbox)
# just a plain global var to pass data (from main, to plot update thread)
global mypass
# http://docs.python.org/library/multiprocessing.html#pipes-and-queues
from multiprocessing import Pipe
global pipe1main, pipe1upd
pipe1main, pipe1upd = Pipe()
# the kind of processing we might want to do in a main() function,
# will now be done in a "main thread" - so it can run in
# parallel with gobject.idle_add(update_line)
def threadMainTest():
global mypass
global runthread
global pipe1main
print "tt"
interncount = 1
while runthread:
mypass += 1
if mypass > 100: # start "speeding up" animation, only after 100 counts have passed
interncount *= 1.03
pipe1main.send(interncount)
time.sleep(0.01)
return
# main plot / GUI update
def update_line(*args):
global mypass
global t0
global runthread
global pipe1upd
if not runthread:
return False
if pipe1upd.poll(): # check first if there is anything to receive
myinterncount = pipe1upd.recv()
update_line.cnt = mypass
# restore the clean slate background
canvas.restore_region(background)
# update the data
line.set_ydata(nx.sin(x+(update_line.cnt+myinterncount)/10.0))
# just draw the animated artist
ax.draw_artist(line)
# just redraw the axes rectangle
canvas.blit(ax.bbox)
if update_line.cnt>=500:
# print the timing info and quit
print 'FPS:' , update_line.cnt/(time.time()-tstart)
runthread=0
t0.join(1)
print "exiting"
sys.exit(0)
return True
global runthread
update_line.cnt = 0
mypass = 0
runthread=1
gobject.idle_add(update_line)
global t0
t0 = threading.Thread(target=threadMainTest)
t0.start()
# start the graphics update thread
p.show()
print "out" # will never print - show() blocks indefinitely!
希望这对某人有帮助，
干杯！
于 2010-11-10T21:55:48.713 回答
5
在许多情况下，将图像保存为硬盘上的 .png 文件会更方便。原因如下：
好处：
- 您可以在此过程中随时打开、查看和关闭它。当您的应用程序运行很长时间时，这特别方便。
- 什么都不会弹出，您也不会被迫打开窗户。当您处理许多图形时，这特别方便。
- 您的图像可供以后参考，并且在关闭图形窗口时不会丢失。
退税：
- 我唯一能想到的是，您必须自己去查找文件夹并打开图像。
于 2013-12-18T18:21:54.910 回答
5
如果您在控制台中工作，即IPython您可以plt.show(block=False)按照其他答案中的说明使用。但如果你很懒，你可以输入：
plt.show(0)
这将是相同的。
于 2016-01-18T11:11:44.670 回答
5
我还必须添加plt.pause(0.001)到我的代码中才能真正使它在 for 循环中工作（否则它只会显示第一个和最后一个图）：
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)
于 2016-11-09T14:16:16.620 回答
4
在我的系统上 show() 不会阻塞，尽管我希望脚本在继续之前等待用户与图形交互（并使用“pick_event”回调收集数据）。
为了在绘图窗口关闭之前阻止执行，我使用了以下内容：
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.plot(x,y)
# set processing to continue when window closed
def onclose(event):
fig.canvas.stop_event_loop()
fig.canvas.mpl_connect('close_event', onclose)
fig.show() # this call does not block on my system
fig.canvas.start_event_loop_default() # block here until window closed
# continue with further processing, perhaps using result from callbacks
但是请注意，canvas.start_event_loop_default() 产生了以下警告：
C:\Python26\lib\site-packages\matplotlib\backend_bases.py:2051: DeprecationWarning: Using default event loop until function specific to this GUI is implemented
warnings.warn(str,DeprecationWarning)
尽管脚本仍在运行。
于 2011-03-17T05:06:56.213 回答
3
我还希望我的绘图显示运行其余代码（然后继续显示），即使出现错误（我有时使用绘图进行调试）。我编写了这个小技巧，以便该with语句中的任何情节都如此。
这可能有点太不标准了，不建议用于生产代码。这段代码中可能有很多隐藏的“陷阱”。
from contextlib import contextmanager
@contextmanager
def keep_plots_open(keep_show_open_on_exit=True, even_when_error=True):
'''
To continue excecuting code when plt.show() is called
and keep the plot on displaying before this contex manager exits
(even if an error caused the exit).
'''
import matplotlib.pyplot
show_original = matplotlib.pyplot.show
def show_replacement(*args, **kwargs):
kwargs['block'] = False
show_original(*args, **kwargs)
matplotlib.pyplot.show = show_replacement
pylab_exists = True
try:
import pylab
except ImportError:
pylab_exists = False
if pylab_exists:
pylab.show = show_replacement
try:
yield
except Exception, err:
if keep_show_open_on_exit and even_when_error:
print "*********************************************"
print "Error early edition while waiting for show():"
print "*********************************************"
import traceback
print traceback.format_exc()
show_original()
print "*********************************************"
raise
finally:
matplotlib.pyplot.show = show_original
if pylab_exists:
pylab.show = show_original
if keep_show_open_on_exit:
show_original()
# ***********************
# Running example
# ***********************
import pylab as pl
import time
if __name__ == '__main__':
with keep_plots_open():
pl.figure('a')
pl.plot([1,2,3], [4,5,6])
pl.plot([3,2,1], [4,5,6])
pl.show()
pl.figure('b')
pl.plot([1,2,3], [4,5,6])
pl.show()
time.sleep(1)
print '...'
time.sleep(1)
print '...'
time.sleep(1)
print '...'
this_will_surely_cause_an_error
如果/当我实施适当的“保持绘图打开（即使发生错误）并允许显示新绘图”时，如果没有用户干预告诉它，我希望脚本正确退出（用于批量执行目的）。
我可能会使用类似超时问题“脚本结束！\n如果您希望绘图输出暂停（您有 5 秒），请按 p：”来自https://stackoverflow.com/questions/26704840/corner -cases-for-my-wait-for-user-input-interruption-implementation。
于 2014-11-04T12:14:28.230 回答
2
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
于 2017-02-21T06:27:52.817 回答
2
OP询问有关分离matplotlib情节的问题。大多数答案都假设从 python 解释器中执行命令。这里介绍的用例是我偏好在运行 a 的终端（例如 bash）中测试代码，file.py并且您希望绘图出现但 python 脚本完成并返回命令提示符。
这个独立文件用于multiprocessing启动一个单独的过程来绘制数据matplotlib。主线程使用本文os._exit(1)中提到的方法退出。os._exit()强制 main 退出，但让子matplotlib进程保持活动状态并做出响应，直到绘图窗口关闭。这完全是一个单独的过程。
这种方法有点像 Matlab 开发会话，带有带有响应式命令提示符的图形窗口。使用这种方法，您将失去与图形窗口进程的所有联系，但是，这对于开发和调试来说是可以的。只需关闭窗口并继续测试。
multiprocessing专为仅 python 的代码执行而设计，这使得它可能比subprocess. multiprocessing是跨平台的，所以这应该在 Windows 或 Mac 中运行良好，几乎不需要调整。无需检查底层操作系统。这是在 linux、Ubuntu 18.04LTS 上测试的。
#!/usr/bin/python3
import time
import multiprocessing
import os
def plot_graph(data):
from matplotlib.pyplot import plot, draw, show
print("entered plot_graph()")
plot(data)
show() # this will block and remain a viable process as long as the figure window is open
print("exiting plot_graph() process")
if __name__ == "__main__":
print("starting __main__")
multiprocessing.Process(target=plot_graph, args=([1, 2, 3],)).start()
time.sleep(5)
print("exiting main")
os._exit(0) # this exits immediately with no cleanup or buffer flushing
运行file.py会打开一个图形窗口，然后__main__退出，但multiprocessing+matplotlib图形窗口仍然响应缩放、平移和其他按钮，因为它是一个独立的过程。
在 bash 命令提示符下检查进程：
ps ax|grep -v grep |grep file.py
于 2019-07-11T05:43:29.553 回答
1
在我看来，这个线程中的答案提供的方法并不适用于每个系统以及动画等更复杂的情况。我建议在以下线程中查看 MiKTeX 的答案，其中找到了一个可靠的方法： 如何等到 matplotlib 动画结束？
于 2015-12-27T06:17:15.197 回答
1
这是我找到的最简单的解决方案（线程阻塞代码）
plt.show(block=False) # this avoids blocking your thread
plt.pause(1) # comment this if you do not want a time delay
# do more stuff
plt.show(block=True) # this prevents the window from closing on you
于 2021-11-23T17:31:01.270 回答
0
如果你想打开多个图形，同时保持它们全部打开，这段代码对我有用：
show(block=False)
draw()
于 2016-09-16T15:11:08.363 回答
0
虽然没有直接回答 OP 的请求，但我发布了这个解决方法，因为它可能会在这种情况下对某人有所帮助：
- 我用pyinstaller创建了一个.exe，因为我无法在需要生成绘图的地方安装python，所以我需要python脚本来生成绘图，将其保存为.png，关闭它并继续下一个，实现为几个绘图循环或使用函数。
为此我使用：
import matplotlib.pyplot as plt
#code generating the plot in a loop or function
#saving the plot
plt.savefig(var+'_plot.png',bbox_inches='tight', dpi=250)
#you can allways reopen the plot using
os.system(var+'_plot.png') # unfortunately .png allows no interaction.
#the following avoids plot blocking the execution while in non-interactive mode
plt.show(block=False)
#and the following closes the plot while next iteration will generate new instance.
plt.close()
其中“var”标识循环中的绘图，因此它不会被覆盖。
于 2020-01-10T22:01:59.140 回答
0
我发现最好的解决方案是让程序不会等待您关闭图形并将所有图放在一起以便您可以并排检查它们是在最后显示所有图。
但是这样你就不能在程序运行时检查绘图。
# stuff
numFig = 1
plt.figure(numFig)
numFig += 1
plt.plot(x1, y1)
# other stuff
plt.figure(numFig)
numFig += 1
plt.plot(x2, y2)
# more stuff
plt.show()
于 2021-11-27T18:27:33.323 回答
-2
plt.show(block=False)在脚本调用结束时使用, 和plt.show()。
这将确保脚本完成后不会关闭窗口。
于 2019-08-18T02:25:26.597 回答