Python matplotlib plot subplot

matplotlib.pyplot.subplots#

matplotlib.pyplot. subplots ( nrows = 1 , ncols = 1 , * , sharex = False , sharey = False , squeeze = True , width_ratios = None , height_ratios = None , subplot_kw = None , gridspec_kw = None , ** fig_kw ) [source] #

Create a figure and a set of subplots.

This utility wrapper makes it convenient to create common layouts of subplots, including the enclosing figure object, in a single call.

Parameters : nrows, ncols int, default: 1

Number of rows/columns of the subplot grid.

sharex, sharey bool or , default: False

Controls sharing of properties among x (sharex) or y (sharey) axes:

• True or ‘all’: x- or y-axis will be shared among all subplots.
• False or ‘none’: each subplot x- or y-axis will be independent.
• ‘row’: each subplot row will share an x- or y-axis.
• ‘col’: each subplot column will share an x- or y-axis.

When subplots have a shared x-axis along a column, only the x tick labels of the bottom subplot are created. Similarly, when subplots have a shared y-axis along a row, only the y tick labels of the first column subplot are created. To later turn other subplots’ ticklabels on, use tick_params .

When subplots have a shared axis that has units, calling set_units will update each axis with the new units.

• If True, extra dimensions are squeezed out from the returned array of Axes :
  • if only one subplot is constructed (nrows=ncols=1), the resulting single Axes object is returned as a scalar.
  • for Nx1 or 1xM subplots, the returned object is a 1D numpy object array of Axes objects.
  • for NxM, subplots with N>1 and M>1 are returned as a 2D array.

  Defines the relative widths of the columns. Each column gets a relative width of width_ratios[i] / sum(width_ratios) . If not given, all columns will have the same width. Equivalent to gridspec_kw= .

  height_ratios array-like of length nrows, optional

  Defines the relative heights of the rows. Each row gets a relative height of height_ratios[i] / sum(height_ratios) . If not given, all rows will have the same height. Convenience for gridspec_kw= .

  subplot_kw dict, optional

  Dict with keywords passed to the add_subplot call used to create each subplot.

  gridspec_kw dict, optional

  Dict with keywords passed to the GridSpec constructor used to create the grid the subplots are placed on.

  All additional keyword arguments are passed to the pyplot.figure call.

  Returns : fig Figure ax Axes or array of Axes

  ax can be either a single Axes object, or an array of Axes objects if more than one subplot was created. The dimensions of the resulting array can be controlled with the squeeze keyword, see above.

  Typical idioms for handling the return value are:

  # using the variable ax for single a Axes fig, ax = plt.subplots() # using the variable axs for multiple Axes fig, axs = plt.subplots(2, 2) # using tuple unpacking for multiple Axes fig, (ax1, ax2) = plt.subplots(1, 2) fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2) 

  The names ax and pluralized axs are preferred over axes because for the latter it’s not clear if it refers to a single Axes instance or a collection of these.

  # First create some toy data: x = np.linspace(0, 2*np.pi, 400) y = np.sin(x**2) # Create just a figure and only one subplot fig, ax = plt.subplots() ax.plot(x, y) ax.set_title('Simple plot') # Create two subplots and unpack the output array immediately f, (ax1, ax2) = plt.subplots(1, 2, sharey=True) ax1.plot(x, y) ax1.set_title('Sharing Y axis') ax2.scatter(x, y) # Create four polar axes and access them through the returned array fig, axs = plt.subplots(2, 2, subplot_kw=dict(projection="polar")) axs[0, 0].plot(x, y) axs[1, 1].scatter(x, y) # Share a X axis with each column of subplots plt.subplots(2, 2, sharex='col') # Share a Y axis with each row of subplots plt.subplots(2, 2, sharey='row') # Share both X and Y axes with all subplots plt.subplots(2, 2, sharex='all', sharey='all') # Note that this is the same as plt.subplots(2, 2, sharex=True, sharey=True) # Create figure number 10 with a single subplot # and clears it if it already exists. fig, ax = plt.subplots(num=10, clear=True) 

  Источник

  Creating multiple subplots using plt.subplots #

  pyplot.subplots creates a figure and a grid of subplots with a single call, while providing reasonable control over how the individual plots are created. For more advanced use cases you can use GridSpec for a more general subplot layout or Figure.add_subplot for adding subplots at arbitrary locations within the figure.

  import matplotlib.pyplot as plt import numpy as np # Some example data to display x = np.linspace(0, 2 * np.pi, 400) y = np.sin(x ** 2) 

  A figure with just one subplot#

  subplots() without arguments returns a Figure and a single Axes .

  This is actually the simplest and recommended way of creating a single Figure and Axes.

  fig, ax = plt.subplots() ax.plot(x, y) ax.set_title('A single plot') 

  

  Stacking subplots in one direction#

  The first two optional arguments of pyplot.subplots define the number of rows and columns of the subplot grid.

  When stacking in one direction only, the returned axs is a 1D numpy array containing the list of created Axes.

  fig, axs = plt.subplots(2) fig.suptitle('Vertically stacked subplots') axs[0].plot(x, y) axs[1].plot(x, -y) 

  

  If you are creating just a few Axes, it’s handy to unpack them immediately to dedicated variables for each Axes. That way, we can use ax1 instead of the more verbose axs[0] .

  fig, (ax1, ax2) = plt.subplots(2) fig.suptitle('Vertically stacked subplots') ax1.plot(x, y) ax2.plot(x, -y) 

  

  To obtain side-by-side subplots, pass parameters 1, 2 for one row and two columns.

  fig, (ax1, ax2) = plt.subplots(1, 2) fig.suptitle('Horizontally stacked subplots') ax1.plot(x, y) ax2.plot(x, -y) 

  

  Stacking subplots in two directions#

  When stacking in two directions, the returned axs is a 2D NumPy array.

  If you have to set parameters for each subplot it’s handy to iterate over all subplots in a 2D grid using for ax in axs.flat: .

  fig, axs = plt.subplots(2, 2) axs[0, 0].plot(x, y) axs[0, 0].set_title('Axis [0, 0]') axs[0, 1].plot(x, y, 'tab:orange') axs[0, 1].set_title('Axis [0, 1]') axs[1, 0].plot(x, -y, 'tab:green') axs[1, 0].set_title('Axis [1, 0]') axs[1, 1].plot(x, -y, 'tab:red') axs[1, 1].set_title('Axis [1, 1]') for ax in axs.flat: ax.set(xlabel='x-label', ylabel='y-label') # Hide x labels and tick labels for top plots and y ticks for right plots. for ax in axs.flat: ax.label_outer() 

  

  You can use tuple-unpacking also in 2D to assign all subplots to dedicated variables:

  fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2) fig.suptitle('Sharing x per column, y per row') ax1.plot(x, y) ax2.plot(x, y**2, 'tab:orange') ax3.plot(x, -y, 'tab:green') ax4.plot(x, -y**2, 'tab:red') for ax in fig.get_axes(): ax.label_outer() 

  

  Sharing axes#

  By default, each Axes is scaled individually. Thus, if the ranges are different the tick values of the subplots do not align.

  fig, (ax1, ax2) = plt.subplots(2) fig.suptitle('Axes values are scaled individually by default') ax1.plot(x, y) ax2.plot(x + 1, -y) 

  

  You can use sharex or sharey to align the horizontal or vertical axis.

  fig, (ax1, ax2) = plt.subplots(2, sharex=True) fig.suptitle('Aligning x-axis using sharex') ax1.plot(x, y) ax2.plot(x + 1, -y) 

  

  Setting sharex or sharey to True enables global sharing across the whole grid, i.e. also the y-axes of vertically stacked subplots have the same scale when using sharey=True .

  fig, axs = plt.subplots(3, sharex=True, sharey=True) fig.suptitle('Sharing both axes') axs[0].plot(x, y ** 2) axs[1].plot(x, 0.3 * y, 'o') axs[2].plot(x, y, '+') 

  

  For subplots that are sharing axes one set of tick labels is enough. Tick labels of inner Axes are automatically removed by sharex and sharey. Still there remains an unused empty space between the subplots.

  To precisely control the positioning of the subplots, one can explicitly create a GridSpec with Figure.add_gridspec , and then call its subplots method. For example, we can reduce the height between vertical subplots using add_gridspec(hspace=0) .

  label_outer is a handy method to remove labels and ticks from subplots that are not at the edge of the grid.

  fig = plt.figure() gs = fig.add_gridspec(3, hspace=0) axs = gs.subplots(sharex=True, sharey=True) fig.suptitle('Sharing both axes') axs[0].plot(x, y ** 2) axs[1].plot(x, 0.3 * y, 'o') axs[2].plot(x, y, '+') # Hide x labels and tick labels for all but bottom plot. for ax in axs: ax.label_outer() 

  

  Apart from True and False , both sharex and sharey accept the values ‘row’ and ‘col’ to share the values only per row or column.

  fig = plt.figure() gs = fig.add_gridspec(2, 2, hspace=0, wspace=0) (ax1, ax2), (ax3, ax4) = gs.subplots(sharex='col', sharey='row') fig.suptitle('Sharing x per column, y per row') ax1.plot(x, y) ax2.plot(x, y**2, 'tab:orange') ax3.plot(x + 1, -y, 'tab:green') ax4.plot(x + 2, -y**2, 'tab:red') for ax in fig.get_axes(): ax.label_outer() 

  

  If you want a more complex sharing structure, you can first create the grid of axes with no sharing, and then call axes.Axes.sharex or axes.Axes.sharey to add sharing info a posteriori.

  fig, axs = plt.subplots(2, 2) axs[0, 0].plot(x, y) axs[0, 0].set_title("main") axs[1, 0].plot(x, y**2) axs[1, 0].set_title("shares x with main") axs[1, 0].sharex(axs[0, 0]) axs[0, 1].plot(x + 1, y + 1) axs[0, 1].set_title("unrelated") axs[1, 1].plot(x + 2, y + 2) axs[1, 1].set_title("also unrelated") fig.tight_layout() 

  

  Polar axes#

  The parameter subplot_kw of pyplot.subplots controls the subplot properties (see also Figure.add_subplot ). In particular, this can be used to create a grid of polar Axes.

  fig, (ax1, ax2) = plt.subplots(1, 2, subplot_kw=dict(projection='polar')) ax1.plot(x, y) ax2.plot(x, y ** 2) plt.show() 

  

  Total running time of the script: ( 0 minutes 8.036 seconds)

  Источник

  Читайте также:  What are events in java