有没有办法分离 matplotlib 图以便计算可以继续？

Question

在 Python 解释器中执行这些指令后，将出现一个带有绘图的窗口：

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

不幸的是，我不知道如何在程序进行进一步计算时继续以交互方式探索由 show() 创建的图形。

有可能吗？ 有时计算很长，如果在检查中间结果时继续进行计算将会有所帮助。

Answer 1

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

Answer 2

使用关键字“block”来覆盖阻止行为，例如

from matplotlib.pyplot import show, plot

plot(1)  
show(block=False)

# your code

继续您的代码。

Answer 3

最好始终检查您正在使用的库是否支持以非阻塞方式使用。

但是，如果您想要一个更通用的解决方案，或者没有其他方法，您可以使用 multprocessing 模块包含在 python 中。 计算将继续：

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 的 非阻塞 API 调用）

Answer 4

尝试

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 以覆盖上述阻止行为。

Answer 5

重要：只是为了澄清一些事情。 我假设这些命令位于 .py 脚本内，并且使用例如 python script.py 从控制台调用该脚本。

对我有用的一个简单方法是：

1. 在 show 中使用 block = False ： plt.show(block = False)
2. 在最后使用 another show() .py 脚本的。

---

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

---

Answer 6

您可能需要在 matplotlib 的文档中阅读此文档，标题为：

在 python shell 中使用 matplotlib

Answer 7

就我而言，我希望在计算时弹出几个窗口。 作为参考，方法如下：

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 接口指南 。

Answer 8

好吧，我在弄清楚非阻塞命令方面遇到了很大的麻烦......但最后，我设法重新设计了“Cookbook/Matplotlib/Animations - 动画选定的绘图元素”示例，因此它可以与线程一起使用（并通过全局变量或通过多进程管道在线程之间传递数据）在 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! 

希望这对某人有帮助，
干杯!

Answer 9

在许多情况下，将图像保存为硬盘上的 .png 文件更方便。 原因如下：

优点：

• 在此过程中您可以随时打开它、查看它并关闭它。 当您的应用程序长时间运行时，这特别方便
  时间。
• 不会弹出任何内容，也不会强迫您打开窗户。 当您处理许多数字时，这特别方便。
• 您的图像可供以后参考，并且在关闭图形窗口时不会丢失。

缺点：

• 我唯一能想到的是，您必须自己找到文件夹并打开图像。

Answer 10

如果您在控制台（即 IPython）中工作，您可以使用 plt.show(block=False) 正如其他答案中指出的那样。 但如果你很懒，你可以直接输入：

plt.show(0)

这将是相同的。

Answer 11

我还必须将 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)

Answer 12

在我的系统上，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)

尽管脚本仍在运行。

Answer 13

OP 询问有关分离 matplotlib 图的问题。 大多数答案都假设命令是在 python 解释器中执行的。 这里介绍的用例是我在终端（例如 bash）中测试代码的偏好，其中运行 file.py 并且您希望出现绘图但需要 python 脚本完成并返回到命令提示符。

该独立文件使用 multiprocessing 启动一个单独的进程，以使用 matplotlib 绘制数据。 主线程使用这篇文章。 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

Answer 14

我还希望我的图显示运行其余代码（然后继续显示），即使存在错误（我有时使用图进行调试）。 我编写了这个小技巧，以便此 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 -输入中断实施。

Answer 15

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

Answer 16

在我看来，该线程中的答案提供的方法并不适用于每个系统以及动画等更复杂的情况。 我建议看看 MiKTeX 在以下线程中的答案，其中找到了一个可靠的方法：
如何等待matplotlib动画结束？

Answer 17

这是我找到的最简单的解决方案（线程阻塞代码）

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

Answer 18

如果您想打开多个图形，同时保持它们全部打开，则此代码对我有用：

show(block=False)
draw()

Answer 19

虽然没有直接回答 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”标识循环中的绘图，因此它不会被覆盖。

Answer 20

我发现最好的解决方案是在最后显示所有图，这样程序就不会等待您关闭图形并将所有图放在一起以便您可以并排检查它们。
但这样你就无法在程序运行时检查绘图。

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

Answer 21

使用 plt.show(block=False)，并在脚本末尾调用 plt.show()。

这将确保脚本完成后窗口不会关闭。