Есть ли способ отсоединить графики matplotlib, чтобы вычисления могли продолжаться?

Во многих случаях удобнее сохранять изображение как файл .png на жестком диске. Вот почему:

Преимущества:

• Вы можете открыть его, посмотреть и закрыть в любой момент в процессе. Это особенно удобно, когда ваше приложение работает долгое время.
• Ничего не всплывает, и вас не заставляют открывать окна. Это особенно удобно, когда вы имеете дело с большим количеством фигур.
• Ваше изображение доступно для дальнейшего использования и не теряется при закрытии окна рисунка.

Недостаток:

• Единственное, что я могу придумать, это то, что вам нужно будет найти папку и открыть изображение самостоятельно.

Если вы работаете в консоли, т.е. IPython, вы можете использовать plt.show(block=False), как указано в других ответах. Но если вам лень, вы можете просто ввести:

plt.show(0)

Что будет таким же.

Мне также пришлось добавить 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)

В моей системе 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)

хотя сценарий все еще работал.

Я также хотел, чтобы мои графики отображали выполнение остальной части кода (а затем продолжали отображать), даже если есть ошибка (я иногда использую графики для отладки). Я закодировал этот небольшой прием, чтобы любые графики внутри этого оператора 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Нажмите p, если вы хотите, чтобы вывод графика был приостановлен (у вас есть 5 секунд):» from https://stackoverflow.com/questions/26704840/corner-cases-for-my-wait-for-user-input-interruption-implementation.

ОП спрашивает об отсоединении matplotlib участков. Большинство ответов предполагают выполнение команды из интерпретатора Python. Представленный здесь вариант использования - это мое предпочтение для тестирования кода в терминале (например, bash), где запущен file.py, и вы хотите, чтобы сюжет (-ы) появлялись, но скрипт python завершился и вернулся в командную строку.

Этот автономный файл использует multiprocessing для запуска отдельного процесса построения данных с помощью matplotlib. Основной поток завершается с использованием os._exit(1), упомянутого в this сообщение. 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

На мой взгляд, ответы в этой ветке предоставляют методы, которые не работают для всех систем и в более сложных ситуациях, таких как анимация. Предлагаю взглянуть на ответ MiKTeX в следующем потоке, где был найден надежный метод: Как дождаться окончания анимации matplotlib?

Если вы хотите открыть несколько фигур, оставив их все открытыми, у меня сработал этот код:

show(block=False)
draw()

Не отвечая напрямую на запрос OP, я публикую этот обходной путь, поскольку он может помочь кому-то в этой ситуации:

• Я создаю .exe с помощью pyinstaller, так как я не могу установить 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» определяет график в цикле, поэтому он не будет перезаписан.

Используйте plt.show(block=False), а в конце вашего скрипта вызовите plt.show().

Это гарантирует, что окно не закроется после завершения скрипта.

Мой ответ немного не по теме, но я просто решил уйти от matplotlib в своем приложении из-за проблемы, указанной в этом вопросе.

Кроме того, вы можете использовать плотно. Это не блокирует процесс.