TL; DR->如何在不创建任何额外变量Matplotlib的PyPlot情况下为的线形图创建图例？

请考虑以下图形脚本：

if __name__ == '__main__':
    PyPlot.plot(total_lengths, sort_times_bubble, 'b-',
                total_lengths, sort_times_ins, 'r-',
                total_lengths, sort_times_merge_r, 'g+',
                total_lengths, sort_times_merge_i, 'p-', )
    PyPlot.title("Combined Statistics")
    PyPlot.xlabel("Length of list (number)")
    PyPlot.ylabel("Time taken (seconds)")
    PyPlot.show()

正如你所看到的，这是一个非常基本的使用matplotlib的PyPlot。理想情况下，生成如下图所示的图：

我知道没什么特别的。但是，尚不清楚在何处绘制哪些数据（我正在尝试绘制某些排序算法的数据，长度与所用时间的关系，并且我想确保人们知道哪条线是哪条）。因此，我需要一个图例，不过，请看下面的示例（来自官方网站）：

ax = subplot(1,1,1)
p1, = ax.plot([1,2,3], label="line 1")
p2, = ax.plot([3,2,1], label="line 2")
p3, = ax.plot([2,3,1], label="line 3")

handles, labels = ax.get_legend_handles_labels()

# reverse the order
ax.legend(handles[::-1], labels[::-1])

# or sort them by labels
import operator
hl = sorted(zip(handles, labels),
            key=operator.itemgetter(1))
handles2, labels2 = zip(*hl)

ax.legend(handles2, labels2)

您将看到我需要创建一个额外的变量ax。如何在图例中添加图例而不必创建此额外变量并保持当前脚本的简单性？

label=在每个plot()呼叫中添加一个，然后呼叫legend(loc='upper left')。

考虑以下示例（使用Python 3.8.0测试）：

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 20, 1000)
y1 = np.sin(x)
y2 = np.cos(x)

plt.plot(x, y1, "-b", label="sine")
plt.plot(x, y2, "-r", label="cosine")
plt.legend(loc="upper left")
plt.ylim(-1.5, 2.0)
plt.show()

从本教程中略作修改：http : //jakevdp.github.io/mpl_tutorial/tutorial_pages/tut1.html

您可以使用访问Axes实例（ax）plt.gca()。在这种情况下，您可以使用

plt.gca().legend()

您可以通过label=在每个plt.plot()调用中使用关键字或通过将标签分配为元组或list中的列表来做到这一点legend，如本工作示例所示：

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-0.75,1,100)
y0 = np.exp(2 + 3*x - 7*x**3)
y1 = 7-4*np.sin(4*x)
plt.plot(x,y0,x,y1)
plt.gca().legend(('y0','y1'))
plt.show()

但是，如果您需要多次访问Axes实例，建议您使用以下命令将其保存到变量ax中：

ax = plt.gca()

然后呼叫ax而不是plt.gca()。

这是一个帮助您的示例…

fig = plt.figure(figsize=(10,5))
ax = fig.add_subplot(111)
ax.set_title('ADR vs Rating (CS:GO)')
ax.scatter(x=data[:,0],y=data[:,1],label='Data')
plt.plot(data[:,0], m*data[:,0] + b,color='red',label='Our Fitting 
Line')
ax.set_xlabel('ADR')
ax.set_ylabel('Rating')
ax.legend(loc='best')
plt.show()

一个带有图例的正弦和余弦曲线的简单图解。

用过的 matplotlib.pyplot

import math
import matplotlib.pyplot as plt
x=[]
for i in range(-314,314):
    x.append(i/100)
ysin=[math.sin(i) for i in x]
ycos=[math.cos(i) for i in x]
plt.plot(x,ysin,label='sin(x)')  #specify label for the corresponding curve
plt.plot(x,ycos,label='cos(x)')
plt.xticks([-3.14,-1.57,0,1.57,3.14],['-$\pi$','-$\pi$/2',0,'$\pi$/2','$\pi$'])
plt.legend()
plt.show()

将标签添加到绘图调用中与绘图系列相对应的每个参数，即 label = "series 1"

然后只需将其添加Pyplot.legend()到脚本的底部，图例将显示这些标签。

您可以添加自定义图例文档

first = [1, 2, 4, 5, 4]
second = [3, 4, 2, 2, 3]
plt.plot(first,'g--', second, 'r--')
plt.legend(['First List','Second List'], loc='upper left')
plt.show()

    # Dependencies
    import numpy as np
    import matplotlib.pyplot as plt

    #Set Axes
    # Set x axis to numerical value for month
    x_axis_data = np.arange(1,13,1)
    x_axis_data

    # Average weather temp
    points = [39, 42, 51, 62, 72, 82, 86, 84, 77, 65, 55, 44]

    # Plot the line
    plt.plot(x_axis_data, points)
    plt.show()

    # Convert to Celsius C = (F-32) * 0.56
    points_C = [round((x-32) * 0.56,2) for x in points]
    points_C

    # Plot using Celsius
    plt.plot(x_axis_data, points_C)
    plt.show()

    # Plot both on the same chart
    plt.plot(x_axis_data, points)
    plt.plot(x_axis_data, points_C)

    #Line colors
    plt.plot(x_axis_data, points, "-b", label="F")
    plt.plot(x_axis_data, points_C, "-r", label="C")

    #locate legend
    plt.legend(loc="upper left")
    plt.show()

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

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

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

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

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

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

from matplotlib.pyplot import show, plot

plot(1)  
show(block=False)

# your code

继续您的代码。

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

但是，如果您需要更通用的解决方案，或者没有其他方法，则可以使用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的非阻塞API调用）

尝试

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

重要提示：只是为了澄清一些内容。我假设命令在.py脚本中，并且使用例如python script.py从控制台调用脚本。

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

1. 在show中使用block = False：plt.show（block = False）
2. 在.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()

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

在python shell中使用matplotlib

就我而言，我想在计算窗口时弹出几个窗口。供参考，方法如下：

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接口的非常有用的指南。

好吧，我很难弄清非阻塞命令.​​..但是最后，我设法重做了“ Cookbook / Matplotlib / Animations-动画选定的绘图元素 ”示例，因此它可以与线程一起使用（并在线程之间传递数据通过全局变量或通过multiprocessPipe）（在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! 

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

在许多情况下，将图像另存为.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如果您想中止绘图输出（您有5秒钟），请按 p：“，来自/programming/26704840/corner我的情况下等待用户输入中断的实现。

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

OP询问有关拆除matplotlib地块的问题。大多数答案都假定命令是从python解释器中执行的。此处提供的用例是我偏爱在运行a的终端（例如bash）中测试代码，file.py并且您希望绘制图但python脚本完成并返回命令提示符。

此独立文件用于multiprocessing启动一个单独的过程，以使用绘制数据matplotlib。主线程退出使用os._exit(1)中提到的这个职位。的os._exit()主要退出，但叶势力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的请求，但我发布了此变通办法，因为它可能会在这种情况下帮助某些人：

• 我用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”标识循环中的图，因此不会被覆盖。

使用plt.show(block=False)和在脚本调用的结尾plt.show()。

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

我有一个Semilogx图，我想删除xticks。我试过了：

plt.gca().set_xticks([])
plt.xticks([])
ax.set_xticks([])

网格消失（确定），但仍保留小刻度线（在主刻度线的位置）。如何删除它们？

该tick_params方法对于这样的事情非常有用。此代码关闭主要和次要刻度线，并从x轴删除标签。

from matplotlib import pyplot as plt
plt.plot(range(10))
plt.tick_params(
    axis='x',          # changes apply to the x-axis
    which='both',      # both major and minor ticks are affected
    bottom=False,      # ticks along the bottom edge are off
    top=False,         # ticks along the top edge are off
    labelbottom=False) # labels along the bottom edge are off
plt.show()
plt.savefig('plot')
plt.clf()

不完全是OP的要求，但是禁用所有轴线，刻度和标签的简单方法是简单地调用：

plt.axis('off')

另外，您可以传递一个空的刻度位置并将其标记为

# for matplotlib.pyplot
# ---------------------
plt.xticks([], [])
# for axis object
# ---------------
# from Anakhand May 5 at 13:08
# for major ticks
ax.set_xticks([])
# for minor ticks
ax.set_xticks([], minor=True)

这是我在matplotlib邮件列表中找到的替代解决方案：

import matplotlib.pylab as plt

x = range(1000)
ax = plt.axes()
ax.semilogx(x, x)
ax.xaxis.set_ticks_position('none') 

有比John Vinyard提供的解决方案更好，更简单的解决方案。用途NullLocator：

import matplotlib.pyplot as plt

plt.plot(range(10))
plt.gca().xaxis.set_major_locator(plt.NullLocator())
plt.show()
plt.savefig('plot')

希望能有所帮助。

尝试删除标签（但不删除刻度）：

import matplotlib.pyplot as plt

plt.setp( ax.get_xticklabels(), visible=False)

例

此代码片段可能仅有助于删除xtick。

from matplotlib import pyplot as plt    
plt.xticks([])

此代码片段可能有助于同时删除xtick和yticks。

from matplotlib import pyplot as plt    
plt.xticks([]),plt.yticks([])

# remove all the ticks (both axes), and tick labels on the Y axis
plt.tick_params(top='off', bottom='off', left='off', right='off', labelleft='off', labelbottom='on')

那些正在寻找一个简短的命令来关闭所有刻度线和标签的人应该可以

plt.tick_params(top=False, bottom=False, left=False, right=False, labelleft=False, labelbottom=False)

bool从版本matplotlib> = 2.1.1开始，允许输入各个参数

对于自定义刻度线设置，文档非常有用：

https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.tick_params.html

我正在尝试在两个轴上绘制一个没有刻度或数字的图形（我使用传统意义上的轴，而不是matplotlib命名法！）。我遇到的一个问题是matplotlib通过减去值N来调整x（y）ticklabel，然后在轴的末端添加N。

这可能含糊其词，但以下简化示例突出了该问题，其中“ 6.18”是N的有问题的值：

import matplotlib.pyplot as plt
import random
prefix = 6.18

rx = [prefix+(0.001*random.random()) for i in arange(100)]
ry = [prefix+(0.001*random.random()) for i in arange(100)]
plt.plot(rx,ry,'ko')

frame1 = plt.gca()
for xlabel_i in frame1.axes.get_xticklabels():
    xlabel_i.set_visible(False)
    xlabel_i.set_fontsize(0.0)
for xlabel_i in frame1.axes.get_yticklabels():
    xlabel_i.set_fontsize(0.0)
    xlabel_i.set_visible(False)
for tick in frame1.axes.get_xticklines():
    tick.set_visible(False)
for tick in frame1.axes.get_yticklines():
    tick.set_visible(False)

plt.show()

我想知道的三件事是：

1. 如何关闭这一行为在首位（虽然在大多数情况下，它是有用的，它并不总是！）我已经通过看matplotlib.axis.XAxis，并不能找到任何合适

2. 如何使N消失（即X.set_visible(False)）

3. 无论如何，还有更好的方法来做上述事情吗？如果可以的话，我的最终绘图将是图中的4×4子图。

除了隐藏每个元素，您还可以隐藏整个轴：

frame1.axes.get_xaxis().set_visible(False)
frame1.axes.get_yaxis().set_visible(False)

或者，您可以将刻度线设置为空列表：

frame1.axes.get_xaxis().set_ticks([])
frame1.axes.get_yaxis().set_ticks([])

在第二个选项中，您仍然可以使用plt.xlabel()和plt.ylabel()在轴上添加标签。

如果要仅隐藏保留网格线的轴文本：

frame1 = plt.gca()
frame1.axes.xaxis.set_ticklabels([])
frame1.axes.yaxis.set_ticklabels([])

做set_visible(False)或set_ticks([])也将隐藏网格线。

如果您像我一样，并且ax在绘制图形时并不总是检索轴，则一个简单的解决方案是

plt.xticks([])
plt.yticks([])

有点旧的线程，但是，这似乎是使用最新版本的matplotlib的更快方法：

设置x轴的主要格式

ax.xaxis.set_major_formatter(plt.NullFormatter())

我实际上无法根据此处的任何代码段（甚至答案中接受的代码段）绘制没有边界或轴数据的图像。在浏览了一些API文档之后，我使用了这段代码来渲染图像

plt.axis('off')
plt.tick_params(axis='both', left='off', top='off', right='off', bottom='off', labelleft='off', labeltop='off', labelright='off', labelbottom='off')
plt.savefig('foo.png', dpi=100, bbox_inches='tight', pad_inches=0.0)

我使用该tick_params调用基本上关闭了可能呈现的任何其他信息，并且在输出文件中有一个完美的图形。

我已经对该图进行了颜色编码以简化此过程。

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)

您可以使用以下命令完全控制图形，以完成答案，我还添加了对样条线的控制：

ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)

# X AXIS -BORDER
ax.spines['bottom'].set_visible(False)
# BLUE
ax.set_xticklabels([])
# RED
ax.set_xticks([])
# RED AND BLUE TOGETHER
ax.axes.get_xaxis().set_visible(False)

# Y AXIS -BORDER
ax.spines['left'].set_visible(False)
# YELLOW
ax.set_yticklabels([])
# GREEN
ax.set_yticks([])
# YELLOW AND GREEN TOGHETHER
ax.axes.get_yaxis().set_visible(False)

使用面向对象的API时，该Axes对象有两种用于删除轴文本的有用方法，set_xticklabels()和set_xticks()。

假设您使用

fig, ax = plt.subplots(1)
ax.plot(x, y)

如果您只想删除刻度线标签，则可以使用

ax.set_xticklabels([])

或完全删除刻度线，您可以使用

ax.set_xticks([])

这些方法对于准确指定刻度线的位置以及如何标记刻度线很有用。传递空列表将分别导致没有滴答声或标签。

一种技巧可能是将刻度标签的颜色设置为白色以隐藏它！

plt.xticks(color='w')
plt.yticks(color='w')

我正在编写一个快速脚本来动态生成绘图。我使用下面的代码（来自Matplotlib文档）作为起点：

from pylab import figure, axes, pie, title, show

# Make a square figure and axes
figure(1, figsize=(6, 6))
ax = axes([0.1, 0.1, 0.8, 0.8])

labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
fracs = [15, 30, 45, 10]

explode = (0, 0.05, 0, 0)
pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True)
title('Raining Hogs and Dogs', bbox={'facecolor': '0.8', 'pad': 5})

show()  # Actually, don't show, just save to foo.png

我不想将图形显示在GUI上，而是要将图形保存到文件（例如foo.png）中，以便可以在批处理脚本中使用它。我怎么做？

在回答问题后，我想在使用matplotlib.pyplot.savefig时添加一些有用的提示。文件格式可以通过扩展名指定：

from matplotlib import pyplot as plt

plt.savefig('foo.png')
plt.savefig('foo.pdf')

将分别给出栅格化或矢量化的输出，这两个都可能有用。此外，您会发现pylab在图像周围留有大量的空白，通常是不希望的空白。使用以下方法删除它：

savefig('foo.png', bbox_inches='tight')

正如其他人所说的，plt.savefig()或者fig1.savefig()确实是保存图像的方法。

但是我发现在某些情况下总是显示该图。（例如，在Spyder具有plt.ion()：交互模式= On的情况下）。我通过强制关闭巨型循环中的图形窗口来解决此问题plt.close(figure_object)（请参阅文档），因此在循环中没有一百万个开放图形：

import matplotlib.pyplot as plt
fig, ax = plt.subplots( nrows=1, ncols=1 )  # create figure & 1 axis
ax.plot([0,1,2], [10,20,3])
fig.savefig('path/to/save/image/to.png')   # save the figure to file
plt.close(fig)    # close the figure window

如有需要，您应该可以重新打开该图fig.show()（不必测试自己）。

解决方案是：

pylab.savefig('foo.png')

刚在MatPlotLib文档中找到此链接，可以解决此问题： http

他们说，防止图形弹出的最简单方法是通过使用非交互式后端（例如Agg）matplotib.use(<backend>)，例如：

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.plot([1,2,3])
plt.savefig('myfig')

我个人还是喜欢使用 plt.close( fig )，因为从那时起，您可以选择隐藏某些图形（在循环过程中），但仍显示图形以进行循环后数据处理。不过，它可能比选择非交互式后端要慢-如果有人对此进行了测试，那将很有趣。

更新：对于Spyder，您通常无法以这种方式设置后端（因为Spyder通常会较早加载matplotlib，从而阻止您使用matplotlib.use()）。

而是在Spyder偏好设置中使用plt.switch_backend('Agg')或关闭“ 启用支持 ”，然后运行matplotlib.use('Agg')自己命令。

从这两个提示：一，二

如果您不喜欢“当前”数字的概念，请执行以下操作：

import matplotlib.image as mpimg

img = mpimg.imread("src.png")
mpimg.imsave("out.png", img)

其他答案是正确的。但是，有时我发现我想稍后再打开图形对象。例如，我可能想更改标签大小，添加网格或进行其他处理。在理想的情况下，我只需要重新运行生成图的代码并修改设置即可。las，世界并不完美。因此，除了保存为PDF或PNG之外，我还添加：

with open('some_file.pkl', "wb") as fp:
    pickle.dump(fig, fp, protocol=4)

这样，以后我可以加载图形对象并根据需要操纵设置。

我还用源代码写出了堆栈， locals()每个函数/方法字典的堆栈，以便以后可以准确地知道是什么产生了该图。

注意：请小心，因为有时此方法会生成巨大的文件。

import datetime
import numpy as np
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt

# Create the PdfPages object to which we will save the pages:
# The with statement makes sure that the PdfPages object is closed properly at
# the end of the block, even if an Exception occurs.
with PdfPages('multipage_pdf.pdf') as pdf:
    plt.figure(figsize=(3, 3))
    plt.plot(range(7), [3, 1, 4, 1, 5, 9, 2], 'r-o')
    plt.title('Page One')
    pdf.savefig()  # saves the current figure into a pdf page
    plt.close()

    plt.rc('text', usetex=True)
    plt.figure(figsize=(8, 6))
    x = np.arange(0, 5, 0.1)
    plt.plot(x, np.sin(x), 'b-')
    plt.title('Page Two')
    pdf.savefig()
    plt.close()

    plt.rc('text', usetex=False)
    fig = plt.figure(figsize=(4, 5))
    plt.plot(x, x*x, 'ko')
    plt.title('Page Three')
    pdf.savefig(fig)  # or you can pass a Figure object to pdf.savefig
    plt.close()

    # We can also set the file's metadata via the PdfPages object:
    d = pdf.infodict()
    d['Title'] = 'Multipage PDF Example'
    d['Author'] = u'Jouni K. Sepp\xe4nen'
    d['Subject'] = 'How to create a multipage pdf file and set its metadata'
    d['Keywords'] = 'PdfPages multipage keywords author title subject'
    d['CreationDate'] = datetime.datetime(2009, 11, 13)
    d['ModDate'] = datetime.datetime.today()

在使用plot（）和其他函数创建所需的内容之后，可以使用如下子句在绘制到屏幕或文件之间进行选择：

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(4, 5))       # size in inches
# use plot(), etc. to create your plot.

# Pick one of the following lines to uncomment
# save_file = None
# save_file = os.path.join(your_directory, your_file_name)  

if save_file:
    plt.savefig(save_file)
    plt.close(fig)
else:
    plt.show()

我使用了以下内容：

import matplotlib.pyplot as plt

p1 = plt.plot(dates, temp, 'r-', label="Temperature (celsius)")  
p2 = plt.plot(dates, psal, 'b-', label="Salinity (psu)")  
plt.legend(loc='upper center', numpoints=1, bbox_to_anchor=(0.5, -0.05),        ncol=2, fancybox=True, shadow=True)

plt.savefig('data.png')  
plt.show()  
f.close()
plt.close()

保存数字后，我发现使用plt.show非常重要，否则它将无法正常工作。图以png格式导出

您可以执行以下操作：

plt.show(hold=False)
plt.savefig('name.pdf')

并记得在关闭GUI图之前先让savefig完成。这样，您可以预先查看图像。

或者，你可以看看它plt.show() 然后关闭GUI，然后再次运行该脚本，但这次替换plt.show()用plt.savefig()。

或者，您可以使用

fig, ax = plt.figure(nrows=1, ncols=1)
plt.plot(...)
plt.show()
fig.savefig('out.pdf')

如果像我一样使用Spyder IDE，则必须使用以下命令禁用交互模式：

plt.ioff()

（此命令随科学启动一起自动启动）

如果要再次启用它，请使用：

plt.ion()

解决方案 ：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')
ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()
plt.figure()
ts.plot()
plt.savefig("foo.png", bbox_inches='tight')

如果确实要显示图像并保存图像，请使用：

%matplotlib inline

后 import matplotlib

根据问题Matplotlib（pyplot）savefig输出空白图像。

请注意一件事：如果使用plt.show，则应在之后plt.savefig，否则将给出空白图像。

详细的例子：

import numpy as np
import matplotlib.pyplot as plt


def draw_result(lst_iter, lst_loss, lst_acc, title):
    plt.plot(lst_iter, lst_loss, '-b', label='loss')
    plt.plot(lst_iter, lst_acc, '-r', label='accuracy')

    plt.xlabel("n iteration")
    plt.legend(loc='upper left')
    plt.title(title)
    plt.savefig(title+".png")  # should before plt.show method

    plt.show()


def test_draw():
    lst_iter = range(100)
    lst_loss = [0.01 * i + 0.01 * i ** 2 for i in xrange(100)]
    # lst_loss = np.random.randn(1, 100).reshape((100, ))
    lst_acc = [0.01 * i - 0.01 * i ** 2 for i in xrange(100)]
    # lst_acc = np.random.randn(1, 100).reshape((100, ))
    draw_result(lst_iter, lst_loss, lst_acc, "sgd_method")


if __name__ == '__main__':
    test_draw()

import matplotlib.pyplot as plt
plt.savefig("image.png")

在Jupyter Notebook中，您必须在一个单元格中删除plt.show()并添加plt.savefig()，以及其余的plt代码。该图像仍将显示在笔记本中。

鉴于今天（提出此问题时尚不可用）很多人将Jupyter Notebook用作python控制台，所以有一种极为简单的方式将图保存为.png，只需从Jupyter Notebook 调用matplotlib的pylab类，将图绘制为“内联” ‘jupyter单元格，然后将该图形/图像拖到本地目录。不要忘记 %matplotlib inline第一行！

除了上述内容外，我还添加__file__了名称，以便图片和Python文件获得相同的名称。我还添加了一些参数使它看起来更好：

# Saves a PNG file of the current graph to the folder and updates it every time
# (nameOfimage, dpi=(sizeOfimage),Keeps_Labels_From_Disappearing)
plt.savefig(__file__+".png",dpi=(250), bbox_inches='tight')
# Hard coded name: './test.png'

使用时matplotlib.pyplot，必须先保存您的绘图，然后使用以下两行将其关闭：

fig.savefig('plot.png') # save the plot, place the path you want to save the figure in quotation
plt.close(fig) # close the figure window

如前所述，您可以使用：

import matplotlib.pyplot as plt
plt.savefig("myfig.png")

用于保存您正在显示的任何IPhython图像。或者换个角度（从另一个角度看），如果您曾经使用过开放式简历，或者如果您导入过开放式简历，则可以进行以下工作：

导入cv2

cv2.imwrite（“ myfig.png”，图像）

但这只是万一，如果您需要使用Open CV。否则，plt.savefig（）应该足够。

您可以使用任何扩展名（png，jpg等）并以所需的分辨率保存图像。这是保存您的身材的功能。

import os

def save_fig(fig_id, tight_layout=True, fig_extension="png", resolution=300):
    path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)
    print("Saving figure", fig_id)
    if tight_layout:
        plt.tight_layout()
    plt.savefig(path, format=fig_extension, dpi=resolution)

“ fig_id”是您要用来保存图形的名称。希望能帮助到你：）

您可以这样做：

def plotAFig():
  plt.figure()
  plt.plot(x,y,'b-')
  plt.savefig("figurename.png")
  plt.close()