A Guide to Setting Plot Styles Based on the Matplotlib Library

A Guide to Setting Plot Styles Based on the Matplotlib Library

Content

Basic Usage

Draw plots

# Style 1
fig = plt.figure(figsize=(12, 8))

plt.plot(x, y, linestyle='--', color='red', linewidth=2, marker='o', markerfacecolor='blue', markersize=8, zorder=3)

# Style 2
fig = plt.figure(figsize=(12, 8))

plt.subplot(3, 3, i)
plt.plot(...)

ax = plt.subplot(3, 3, i)
ax.plot(...)

# Style 3
fig, axs = plt.subplots(3, 3, figsize=(12, 8))
fig, axs = plt.subplots(3, 1, figsize=(12, 10), gridspec_kw={'height_ratios': [1, 1, 1]})

axs[0, 0].plot(...)

# Style 4
fig, ax = plt.subplots(figsize=(12, 8))

ax.plot(...)
plt.plot(...)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Adjust style

axes[i,j].set_xlabel('Recall', fontsize=14, fontweight='bold', , loc="center", labelpad=20)
axes[i,j].set_ylabel('Precision', fontsize=14, fontweight='bold')
axes[i,j].set_title(f'OvR Precision-Recall Curve ({feature_type}-Ch{channel})', fontsize=14, fontweight='bold')
axes[i,j].legend(loc="best", fontsize=12)
axes[i,j].set_xlim([0.0, 1.05])
axes[i,j].set_ylim([0.0, 1.05])
# Set tick parameters to be larger
axes[i,j].tick_params(axis='both', which='both', width=2, labelsize=14)
axes[i,j].spines['top'].set_linewidth(2) # Thicken the top spine
axes[i,j].spines['bottom'].set_linewidth(2) # Thicken the bottom spine
axes[i,j].spines['left'].set_linewidth(2) # Thicken the left spine
axes[i,j].spines['right'].set_linewidth(2) # Thicken the right spine

fig, ax = plt.subplots(figsize=(10, 6))

plt.xlabel('Recall', fontsize=14, fontweight='bold')
plt.ylabel('Precision', fontsize=14, fontweight='bold')
plt.title(f'Micro-Averaged Precision-Recall Curve ({feature_type})', fontsize=14, fontweight='bold')

plt.legend(loc="lower left", fontsize=12)
plt.legend(loc="upper right", fontsize=12)

# Set tick parameters to be larger
plt.tick_params(axis='both', which='both', width=2, labelsize=14)
ax.spines['top'].set_linewidth(2) # Thicken the top spine
ax.spines['bottom'].set_linewidth(2) # Thicken the bottom spine
ax.spines['left'].set_linewidth(2) # Thicken the left spine
ax.spines['right'].set_linewidth(2) # Thicken the right spine

plt.xlim([0.0, 1.05])
plt.ylim([0.0, 1.05])
plt.grid(True)

# plt.subplots_adjust(left=0.08, right=0.97, bottom=0.07, top = 0.96, hspace=0.45)
plt.tight_layout()
plt.savefig(f"{output_basedir}\{time_stamp}_figure1.png")
plt.show()
plt.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

• Example：

format_plot(axs[0], 'Time (s)', 'Res. (kΩ)', y_range=[-50, 700], legend_pos="upper left")
format_plot(ax, 'PC 1', "PC 2", title=f'{feature_type}-{_cluster_type}', show_legend=False)

add_sequence_label(axs, lbl_x=-0.18, lbl_y=1.08)
1
2
3
4

Save plots

Matplotlib supports a wide variety of file formats for saving figures, which allows for flexibility depending on your needs for visualization quality, file size, and compatibility with other software. Here are the main types of file formats you can save to using Matplotlib:

• PNG (.png) - A popular raster graphics file format that supports lossless data compression. PNGs are ideal for use on the web and in applications where lossless compression is important.

• JPEG (.jpg, .jpeg) - A commonly used method of lossy compression for digital images, particularly for those images produced by digital photography. JPEG is suitable for realistic images with smooth variations in tone and color.

• SVG (.svg) - Scalable Vector Graphics format is a vector format that can be edited with vector graphic software and is ideal for web pages and technical illustrations that require resizing.

• PDF (.pdf) - Portable Document Format is a file format used to present documents in a manner independent of application software, hardware, and operating systems. PDF is suitable for documents needing high-quality print formats and archival.

• PS (.ps) - PostScript file, a type of vector graphics file and page description language, which can be used in electronic and desktop publishing.

• EPS (.eps) - Encapsulated PostScript, a type of vector format that is somewhat outdated but still used for high-quality graphics where scalability is needed without loss of resolution.

• TIFF (.tif, .tiff) - Tagged Image File Format is used for storing raster graphics images, popular among graphic artists, the publishing industry, and photographers. TIFF is widely supported and versatile.

Annotate plots

函数原型：

plt.text(x, y, s, **kwargs)
1

• Parameters:x, y: These are the coordinates where you want to place the text. These coordinates can be specified in data coordinates, or you can use the transform parameter to specify other coordinate systems such as axes or figure coordinates.

• s (or text): This is the string of text that you want to display.

• fontsize: Controls the size of the font.

• color: Specifies the color of the text.

• fontweight: Specifies the weight of the font (e.g., ‘normal’, ‘bold’, ‘light’).

• fontstyle: Specifies the style of the font (e.g., ‘normal’, ‘italic’).

• horizontalalignment (or ha): Specifies the horizontal alignment of the text relative to the given (x, y) coordinates.

• verticalalignment (or va): Specifies the vertical alignment of the text relative to the given (x, y) coordinates.

• rotation: Specifies the rotation angle of the text.

• bbox: A dictionary specifying properties for a bounding box around the text.

• Coordinate Systems: By default, the x and y coordinates are interpreted in data coordinates. However, you can use the transform parameter to specify other coordinate systems such as:

  • ‘figure points’: Coordinates are in points from the lower-left corner of the figure.

  • ‘figure pixels’: Coordinates are in pixels from the lower-left corner of the figure.

  • ‘axes points’: Coordinates are in points from the lower-left corner of the axes.

  • ‘axes pixels’: Coordinates are in pixels from the lower-left corner of the axes.

Custom transformations can also be defined.

• Alignment:You can control the alignment of the text relative to the (x, y) coordinates using the horizontalalignment and verticalalignment parameters. These parameters accept values such as ‘left’, ‘right’, ‘center’, ‘top’, ‘bottom’, etc.

• Rotation:The rotation parameter allows you to rotate the text by a specified angle, in degrees.

• Bounding Box:The bbox parameter allows you to specify properties for a bounding box around the text. This can be useful for highlighting the text or providing visual separation from the rest of the plot.

• Advanced Usage: You can use LaTeX-style formatting for mathematical expressions by enclosing them in $ symbols.
  You can add annotations with arrows using the plt.annotate() function, which is similar to plt.text() but includes an arrow.

Text properties can be specified using keyword arguments, making it easy to customize the appearance of the text.

Examples：

ax[0].text(3, 5, "Point (3, 5)", fontsize=12, color='red')
plt.text(3, 5, "Point (3, 5)", fontsize=12, color='red')
plt.text(3, 5, "Point (3, 5)", fontsize=12, color='blue', font="arial", style='italic', weight='bold')
plt.text(3, 5, "Rotated Text", fontsize=12, color='green', rotation=45)
plt.text(0.5, 0.95, f'ARI: {ari_score:.3f}, NMI: {nmi_score:.3f}', ha='center', va='center', transform=plt.gca().transAxes)
ax[0].text(0.5, 0.95, f'ARI: {ari_score:.3f}, NMI: {nmi_score:.3f}', ha='center', va='center', transform=ax[0].transAxes)
1
2
3
4
5
6

The transform parameter in Matplotlib’s plt.text() function allows you to specify the coordinate system in which the (x, y) coordinates are interpreted. By default, when you specify coordinates for text annotations, Matplotlib assumes you’re using data coordinates (i.e., the actual values of your plotted data). However, sometimes you might want to specify coordinates in a different coordinate system.

In the example you provided:

plt.text(0.5, 0.95, f'ARI: {ari_score:.3f}, NMI: {nmi_score:.3f}', ha='center', va='center', transform=plt.gca().transAxes)
1

The transform=plt.gca().transAxes part specifies that the (0.5, 0.95) coordinates are interpreted in axes coordinates. Here’s what each part does:

• plt.gca(): This function gets the current Axes instance. gca stands for “get current axes.” This ensures that the transformation is applied to the current axes.
• .transAxes: This is an attribute of the Axes object that represents the transformation from axes coordinates to display (pixel) coordinates. When you specify transform=plt.gca().transAxes, you’re telling Matplotlib to interpret the (0.5, 0.95) coordinates as 50% of the way across the x-axis and 95% of the way up the y-axis of the current axes.

In summary, using transform=plt.gca().transAxes allows you to specify coordinates relative to the axes rather than the data being plotted. This can be useful, for example, when you want text annotations to remain in a fixed position relative to the axes regardless of the data being plotted.

• Adjustments and Customizations

  • Positioning: The coordinates (0.05, 0.95) in ax.text() specify the position of the text within the subplot in axes coordinates (from 0 to 1). You can adjust these values to move the label around.
  • Formatting: You can adjust the fontsize, fontweight, and other properties to customize the appearance of the labels.
  • Alignment: va='top' aligns the text at the top of the specified position, and you can use ha='right' for horizontal alignment if needed.

Add sequence labels

Adding sequence labels such as (a), (b), ©, etc., to subfigures in a Matplotlib plot is a common requirement for publications and presentations. These labels help to identify each subplot clearly when referred to in the text. Here’s how you can add sequence labels to each subplot:

The easiest way to add sequence labels is by using the text() method of an Axes object in Matplotlib. You usually want to place these labels inside the subplot, typically at the top left corner, but this can vary based on content and preference.

Here’s an example with a 2x2 grid of subplots:

import matplotlib.pyplot as plt

# Create a 2x2 subplot
fig, axs = plt.subplots(2, 2, figsize=(10, 8))

## List of labels
# labels = ['(a)', '(b)', '(c)', '(d)']

# Number of labels needed 
num_labels = 4 
# Generate labels from 'a' to 'd' 
labels = [f'({chr(97 + i)})' for i in range(num_labels)]

# Iterate over all subplots to add labels
for i, ax in enumerate(axs.flatten()):
    # Place the text
    ax.text(-0.1, 1.1, labels[i], transform=ax.transAxes, font="arial", fontsize=18, fontweight='bold', va='top')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Elements Order

In matplotlib, the stacking order of various plot elements like grids, legends, curves, and more can be controlled using the zorder parameter. The zorder property determines the drawing order of these elements. A higher zorder value means the element is drawn on top of elements with lower zorder values.

Here’s how to use the zorder parameter to control the stacking sequence:

• Basic Example

Let’s create a simple plot with a curve, grid, and legend, and set their zorder to control their stacking:

import matplotlib.pyplot as plt
import numpy as np

# Generate some data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create the plot
plt.figure()
plt.plot(x, y, label='Sin(x)', zorder=3)  # Curve with higher zorder

# Add grid
plt.grid(True, zorder=2)  # Grid with lower zorder than the curve

# Add legend
plt.legend(loc='upper right', zorder=4)  # Legend with the highest zorder

plt.title("Control of stacking order using zorder")
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

In this example:

• The curve (plot) has a zorder of 3, placing it above the grid.
• The grid has a zorder of 2.
• The legend has a zorder of 4, making it appear on top of all other elements.

• More Details on zorder

  Here’s a bit more detail on how zorder can be applied to other elements:

  • Axes and Labels: You can set zorder for plot elements like axes and labels. For example, ax.xaxis.set_zorder(5) or using ax.text(..., zorder=5) for text.
  • Multiple Curves and Annotations: When plotting multiple lines or annotations, assign different zorder values to each to control their visual stacking.
  • Images: When working with images (using imshow), you can adjust zorder to decide whether the image appears above or below other plot elements like grids or lines.
  • Error Bars, Bars, and Scatters: Elements like error bars in errorbar, bars in bar plots, and points in scatter plots can also have their zorder set.

• Practical Example with Multiple Elements

Here’s an example with multiple plot elements:

# Create some data for different plot types
x = np.arange(10)
y = 2.5 * np.sin(x / 20 * np.pi)
yerr = np.linspace(0.05, 0.2, 10)

# Create the plot
plt.figure()

# Bar plot
plt.bar(x, y + 3, color='blue', label='Bar', zorder=3)

# Line plot
plt.errorbar(x, y, yerr=yerr, label='Error Bar', fmt='-o', zorder=4)

# Scatter plot
plt.scatter(x, y - 3, color='red', label='Scatter', zorder=5)

# Set grid and legend
plt.grid(True, zorder=2)
plt.legend(loc='upper right', zorder=6)

plt.title("Complex Example with Multiple Elements")
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

In this complex example, each type of plot is given a specific zorder to control its layering in relation to other plot elements, ensuring a clear and comprehensible visualization. Adjusting these values will help in creating visually effective and hierarchy-appropriate plots.

Format Function

• The function named def format_plot(...) is used to format the basic style using predefined parameters, such as font size. If you want to define the style that has part of a difference from this function, you can just set the corresponding attributes outside the function and disable the utilities in the function, such as set show_legend=False and define the legend style outside.

def format_plot(ax, xlabel, ylabel, x_range=None, y_range=None, title=None, show_grid=True, show_legend=True, legend_pos="upper right"):
    """
    Formats the matplotlib axes with labels, titles, legends, and grid.

    Parameters:
    ax : matplotlib.axes.Axes
        The axes object to format.
    xlabel : str
        The label for the x-axis.
    ylabel : str
        The label for the y-axis.
    x_range : tuple, optional
        The range to use for the x-axis (xmin, xmax).
    y_range : tuple, optional
        The range to use for the y-axis (ymin, ymax).
    title : str, optional
        The title of the plot.
    show_grid : bool, optional
        If True, display the grid; otherwise, do not display the grid.
    show_legend : bool, optional
        If True, display the legend; otherwise, do not display the legend.
    legend_pos : str, optional
        The position of the legend within the plot. Default is "upper right".

    Enhancements:
    - Font sizes and weights are set for readability.
    - Axis limits are adjustable.
    - Optional legend and grid display for flexibility.
    - Increased spine and tick width for better visibility.
    """
    # Set the x-axis label with specified font size and weight
    ax.set_xlabel(xlabel, fontsize=14, fontweight='bold')
    # Set the y-axis label with specified font size and weight
    ax.set_ylabel(ylabel, fontsize=14, fontweight='bold')

    # Set the range for the x-axis if specified
    if x_range != None:
        ax.set_xlim(x_range)
    # Set the range for the y-axis if specified
    if y_range != None:
        ax.set_ylim(y_range)
    # Set the plot title if specified
    if title != None:
        ax.set_title(title, fontsize=12)
    # Display the legend if requested, at the specified position
    if show_legend:
        ax.legend(loc=legend_pos, fontsize=12)
    # Enable or disable the grid based on the show_grid boolean
    if show_grid:    
        ax.grid(show_grid, zorder=0)
        
    # Set larger font size and thicker ticks for both axes
    ax.tick_params(axis='both', which='both', width=2, labelsize=14)
    # Set the thickness of the plot spines
    ax.spines['top'].set_linewidth(2)
    ax.spines['bottom'].set_linewidth(2)
    ax.spines['left'].set_linewidth(2)
    ax.spines['right'].set_linewidth(2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

• The function named def add_sequence_label(...)is designed for add sequence labels to subplots, such as (a), (b), ©, and so on.

def add_sequence_label(axs: np.array, lbl_x=-0.1, lbl_y=1.1, start_char='a'):
    """
    Adds sequence labels (like '(a)', '(b)', etc.) to subplots.

    Parameters:
    axs : numpy array of matplotlib.axes.Axes
        An array of axes objects to which labels will be added.
    lbl_x : float, optional
        The x-coordinate (in axes fraction) for placing the label. Default is -0.1 (left of the y-axis).
    lbl_y : float, optional
        The y-coordinate (in axes fraction) for placing the label. Default is 1.1 (above the top axis line).

    Usage:
    - Designed for use with subplots to label each subplot uniquely within the figure space.
    - Labels are placed relative to the axes' coordinate system, ensuring consistency across different subplot sizes.
    """
    # Calculate the number of labels based on the number of subplots in axs
    num_labels = len(axs)
    # Create a list of labels ranging from '(a)' to whatever is needed based on the number of subplots
    labels = [f'({chr(ord(start_char) + i)})' for i in range(num_labels)]

    # Loop through each subplot in the axs array
    for i, ax in enumerate(axs.flatten()):
        # Add a text label inside the plot using plot coordinates
        ax.text(lbl_x, lbl_y, labels[i], transform=ax.transAxes, font="arial", fontsize=18, fontweight='bold', va='top')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Layout of Subplots

Using subplots_adjust

The plt.subplots_adjust() function is a straightforward way to adjust the spacing between subplots. It allows you to control the spacing around and between subplots through several parameters:

• left, right, top, bottom: These parameters control the spacing from the edges of the figure to the subplots and are given as fractions of the figure width or height.
• wspace and hspace: These control the spacing between subplots horizontally and vertically and are expressed as fractions of the subplot width and height.

Here’s how you might use it:

import matplotlib.pyplot as plt

# Create a figure with subplots
fig, ax = plt.subplots(2, 2)  # 2x2 grid of subplots
fig, ax = plt.subplots(2, 2, gridspec_kw={'height_ratios': [2, 1], 'width_ratios': [1, 1], 'hspace': 0.5, 'wspace': 0.5})

# Adjust spacings
plt.subplots_adjust(left=0.1, right=0.9, bottom=0.1, top=0.9, wspace=0.5, hspace=0.5)

plt.show()
1
2
3
4
5
6
7
8
9
10

Using tight_layout

The tight_layout() method automatically adjusts the positions of the axes on the figure canvas so that there is less overlap and everything fits nicely. It is very useful if you have labels, titles, or ticks that otherwise tend to overlap.

import matplotlib.pyplot as plt

# Create a figure with subplots
fig, ax = plt.subplots(2, 2)  # 2x2 grid of subplots

# Automatically adjust subplot params
plt.tight_layout()

plt.show()
1
2
3
4
5
6
7
8
9

Using constrained_layout

Constrained layout automatically adjusts subplots and decorations like legends and colorbars to make sure they fit within the figure and don’t overlap each other. It’s similar to tight_layout but more powerful.

import matplotlib.pyplot as plt

# Create a figure with subplots
fig, ax = plt.subplots(2, 2, constrained_layout=True)  # Enable constrained layout

plt.show()
1
2
3
4
5
6

These methods provide flexibility and control over the layout of multiple subplots in a Matplotlib figure. You can choose one based on the complexity of your figure and the degree of control you need over the spacing.****

Using GridSpec

For more complex subplot arrangements, GridSpec gives more control over the layout. It provides an interface for specifying the geometry of the grid that a subplot will be placed in.

import matplotlib.pyplot as plt
from matplotlib import gridspec

# Create figure
fig = plt.figure()

# Define GridSpec
gs = gridspec.GridSpec(2, 2, figure=fig, width_ratios=[1, 2], height_ratios=[4, 1], wspace=0.5, hspace=0.5)

# Create subplots
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1])
ax3 = fig.add_subplot(gs[1, :])  # Span all columns in second row

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Using add_subplot()

Alternatively, you can achieve the same result by directly specifying the layout using the add_subplot() method.

Example:

import matplotlib.pyplot as plt

# Create a figure and set its size
fig = plt.figure(figsize=(10, 6))

# Define grid layout (3 rows, 3 columns)
# The first subplot spans from row 0, column 0 to row 2, column 1
ax1 = fig.add_subplot(3, 2, 1)

# The second subplot spans from row 0, column 2 to row 1, column 2
ax2 = fig.add_subplot(3, 2, 3)

# The third subplot spans from row 2, column 2 to row 2, column 2
ax3 = fig.add_subplot(3, 2, 5)

# Plot something in each subplot (just for demonstration)
ax1.plot([1, 2, 3], [1, 2, 3])
ax2.plot([1, 2, 3], [3, 2, 1])
ax3.plot([1, 2, 3], [1, 1, 1])

# Adjust layout
fig.tight_layout()

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

In this example, add_subplot() is used to create three subplots with different configurations within a 3x2 grid layout.

Using subplot2grid()

The subplot2grid() function allows you to create subplots within a grid layout with control over the starting position and the number of rows and columns each subplot spans.

Example:

import matplotlib.pyplot as plt

# Create a figure and set its size
fig = plt.figure(figsize=(10, 6))

# Define grid layout (3 rows, 3 columns)
# The first subplot spans from row 0, column 0 to row 2, column 1
ax1 = plt.subplot2grid((3, 3), (0, 0), rowspan=3, colspan=2)

# The second subplot spans from row 0, column 2 to row 1, column 2
ax2 = plt.subplot2grid((3, 3), (0, 2), rowspan=2, colspan=1)

# The third subplot spans from row 2, column 2 to row 2, column 2
ax3 = plt.subplot2grid((3, 3), (2, 2))

# Plot something in each subplot (just for demonstration)
ax1.plot([1, 2, 3], [1, 2, 3])
ax2.plot([1, 2, 3], [3, 2, 1])
ax3.plot([1, 2, 3], [1, 1, 1])

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

In this example, subplot2grid() is used to create three subplots with different configurations within a 3x3 grid layout.

Adjusting Line Style

You can control the style of the line using the linestyle parameter in plt.plot().

• linestyle: Specifies the style of the line. Options include '-' (solid line), '--' (dashed line), '-.' (dash-dot line), ':' (dotted line), and more.

Example:

plt.plot(x, y, linestyle='--')  # Dashed line
1

Line Color

You can set the color of the line using the color parameter.

• color: Specifies the color of the line. You can use color names (e.g., 'red', 'blue'), hex codes (e.g., '#FF5733'), or RGB tuples.

Example:

plt.plot(x, y, color='red')  # Red line
1

Marker Style

If you’re plotting points, you can control the style of the markers using the marker parameter.

• marker: Specifies the marker style. Options include 'o' (circle), 's' (square), '^' (triangle), '.' (point), and more.

Example:

plt.plot(x, y, marker='o')  # Circles as markers
1

Marker Color and Size

You can set the color and size of the markers using the markerfacecolor, markeredgecolor, and markersize parameters.

• markerfacecolor: Specifies the color of the marker fill.
• markeredgecolor: Specifies the color of the marker edge.
• markersize: Specifies the size of the markers.

Example:

plt.plot(x, y, marker='o', markerfacecolor='blue', markeredgecolor='black', markersize=8)
1

Combining Styles:

You can combine these parameters to create customized styles.

Example:

plt.plot(x, y, linestyle='--', color='red', marker='o', markersize=8)
1

Adjusting Line Width

You can control the width of the line using the linewidth or lw parameter.

• linewidth or lw: Specifies the width of the line. It takes a numerical value representing the width in points.

Example:

plt.plot(x, y, linewidth=2)  # Line width of 2 points
1

Example:
Let’s say you want to create a plot with a red dashed line of width 2, with circles as markers in blue with a marker size of 8, you would do:

import matplotlib.pyplot as plt

# Sample data
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# Plot with customized styles
plt.plot(x, y, linestyle='--', color='red', linewidth=2, marker='o', markerfacecolor='blue', markersize=8)

# Add labels and title
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Customized Plot')

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

This will generate a plot with a red dashed line, circles as markers filled in blue, and with a line width of 2 points.

Horizontal and Vertical Lines

In Matplotlib, you can plot horizontal or vertical lines across the axis of a plot using specific functions designed for this purpose. These functions are particularly useful for marking significant values or thresholds in data visualization. Here’s how you can use them:

Plotting Horizontal Lines

To plot a horizontal line across the plot, you can use the axhline() function. It spans the width of the plot area and is typically used to highlight a specific y-axis value.

Syntax and Usage:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

# Plot some data
ax.plot(range(10), range(10))  # Example line plot

# Add a horizontal line at y = 5
ax.axhline(y=5, color='r', linestyle='--', linewidth=2)

plt.show()
1
2
3
4
5
6
7
8
9
10
11

Parameters:

• y: The y-coordinate through which the line spans.
• color: Color of the line.
• linestyle: Style of the line ('-', '--', '-.', ':', etc.).
• linewidth: Thickness of the line.

Plotting Vertical Lines

For vertical lines, the axvline() function is used. This function draws a vertical line at a specific x-axis value and spans the height of the y-axis.

Syntax and Usage:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

# Plot some data
ax.plot(range(10), range(10))  # Example line plot

# Add a vertical line at x = 5
ax.axvline(x=5, color='b', linestyle=':', linewidth=2)

plt.show()
1
2
3
4
5
6
7
8
9
10
11

Parameters:

• x: The x-coordinate through which the line spans.
• color: Color of the line.
• linestyle: Style of the line ('-', '--', '-.', ':', etc.).
• linewidth: Thickness of the line.

Advanced Usage

You can also specify additional parameters to control the extent of these lines within the plot:

• xmin and xmax for axhline: These parameters control the starting and ending point of the horizontal line, expressed as a fraction of the total width (from 0 to 1).
• ymin and ymax for axvline: These parameters manage where the vertical line begins and ends, also as a fraction of the total height (from 0 to 1).

Example with xmin and xmax:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()

# Add a horizontal line with limited span
ax.axhline(y=0.5, xmin=0.25, xmax=0.75, color='green', linestyle='-', linewidth=3)

plt.show()
1
2
3
4
5
6
7
8

These functionalities allow you to highlight specific areas or thresholds in your plots, which can be very useful for analysis and presentations.

Adjustment of Legend

Certainly! In Matplotlib, the plt.legend() function is used to add a legend to a plot. A legend is a key that helps to identify each dataset displayed in the plot by associating line styles, marker types, colors, or labels with them. Here’s a detailed introduction to using plt.legend() effectively.

Basic Usage of plt.legend()

To use plt.legend(), you typically provide labels for each of the lines or markers you plot, and then call plt.legend() to display the legend.

Example:

import matplotlib.pyplot as plt

plt.plot([1, 2, 3], label='Line 1')
plt.plot([3, 2, 1], label='Line 2')
plt.legend()
plt.show()
1
2
3
4
5
6

In this example, each plt.plot() includes a label, which plt.legend() uses to create the legend.

Parameters of plt.legend()

Here are some of the commonly used parameters that allow you to customize the appearance and position of your legend:

• loc: Specifies the location of the legend. The parameter accepts location strings like 'upper left', 'lower right', etc., or location codes (0-10).
• title: Adds a title to the legend.
• fontsize: Controls the font size of the legend text.
• frameon: A boolean that turns the frame of the legend on (True) or off (False).
• ncol: Number of columns in the legend (useful for when you have many items).
• shadow: A boolean that adds a shadow behind the legend (True), or not (False).
• borderpad, labelspacing, handlelength, handletextpad: These parameters allow you to adjust the padding and spacing within the legend.

Customizing the Legend

You can customize the legend further to better fit the needs of your visualization. Below is a detailed example:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

plt.plot(x, y1, '-b', label='sin(x)')
plt.plot(x, y2, '-r', label='cos(x)')

plt.legend(loc='upper right', frameon=False, title='Functions', fontsize='large')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

In this example, plt.legend() is customized with the location set to 'upper right', the frame turned off for a cleaner look, and a title added.

Advanced Customization

You can also customize the legend’s handles (lines or markers) and labels explicitly by creating custom legend handles:

from matplotlib.lines import Line2D

custom_lines = [Line2D([0], [0], color='b', lw=4),
                Line2D([0], [0], color='r', lw=4)]

plt.plot(x, y1, '-b')
plt.plot(x, y2, '-r')

plt.legend(custom_lines, ['sin(x)', 'cos(x)'], loc='best')
plt.show()
1
2
3
4
5
6
7
8
9
10

In this setup, Line2D objects are used to create custom lines for the legend, which is useful if the plot itself does not contain a direct correlation to the items you want to represent in the legend.

Handling Large Legends

When dealing with complex plots that contain many labeled elements, adjusting the ncol parameter to spread the legend items over multiple columns or using the bbox_to_anchor parameter to place the legend outside the plot area can help avoid overcrowding the visual space.

• Example: How to anchor the large legends outside of the subplots?

fig, axs = plt.subplots(3, 3, figsize=(12, 10))

for j, data in tqdm(enumerate(dfs), total=len(dfs), desc="2D cluster", ncols=75):
    #### Omit extraneous code above
    ax = axs.flatten()[j]
    unique_label = sorted(data[cluster_type].unique())
    
    for label in unique_label:
        indices = data[cluster_type] == label
        plot1 = ax.scatter(pca_components[indices, 0], pca_components[indices, 1], label=f'{label}', marker='o', edgecolor='k', s=40, zorder=3)
        
    format_plot(ax, 'PC 1', "PC 2", title=f'{cluster_algo}_{feature_type.upper()} - Ch{j + 2}-{_cluster_type}', show_legend=False)

add_sequence_label(axs.flatten(), lbl_x=-0.22, lbl_y=1.1)
# ax.legend(title=_cluster_type, bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=12)
# fig.legend(handles=[plot1, ], labels=unique_label, bbox_to_anchor=(0.5, 0), loc='lower center', ncol=5, fontsize=12)
fig.legend(labels=unique_label, bbox_to_anchor=(0.5, 0), loc='lower center', ncol=5, fontsize=12)

# plt.tight_layout()
plt.subplots_adjust(left=0.08, right=0.98, bottom=0.12, top=0.95, wspace=0.35, hspace=0.4)

plt.savefig(f"{output_basedir}/{cluster_algo}_clustering_2D_{feature_type}_{_cluster_type}.svg")
plt.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Axis Ticks and Labels

Matplotlib provides extensive options for customizing the appearance and positioning of axis ticks and tick labels, which are crucial for making your plots clear and visually appealing. Here’s a detailed introduction to managing these elements:

• Ticks are the markers denoting data points on axes.
• Tick Labels are the texts or numbers placed at the ticks to denote specific values.

Accessing Ticks and Labels

• In Matplotlib, you can access and modify ticks through Axes objects.
• Use ax.xaxis for modifications along the x-axis and ax.yaxis for the y-axis.

Here’s how to access the x-axis and y-axis tick labels for modification:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot(range(10))

# Accessing and printing x-axis and y-axis tick labels
print("X-axis tick labels:", [tick.get_text() for tick in ax.get_xticklabels()])
print("Y-axis tick labels:", [tick.get_text() for tick in ax.get_yticklabels()])

plt.show()
1
2
3
4
5
6
7
8
9
10

Set Tick Labels

The set_xticklabels and set_yticklabels functions explicitly set the text labels for the ticks on either the x-axis or the y-axis. Unlike formatters that dynamically adjust tick labels based on the data values, using set_xticklabels and set_yticklabels allows you to specify a fixed list of label strings that correspond directly to the ticks at predetermined positions.

a basic example to illustrate the use of these functions:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot(range(10))  # Plot some data

# Setting custom tick labels
ax.set_xticklabels(['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'], rotation=45)
ax.set_yticklabels(['0%', '10%', '20%', '30%', '40%', '50%', '60%', '70%', '80%', '90%'])

plt.show()
1
2
3
4
5
6
7
8
9
10

** Important Considerations**

1. Alignment with Data Points: When using set_xticklabels or set_yticklabels, ensure that the number of labels matches the number of ticks on the respective axis. If the number of labels and ticks don’t match, the labels may not align correctly with the intended data points.

2. Using with Locators: These functions do not change the positions of the ticks; they only change the labels. To ensure that labels align with the correct data points, you should manually set the tick positions using locators like FixedLocator, or ensure the default locators align with your labels.

3. Avoiding Overlapping Labels: Since these functions allow for custom text, there’s a risk of overlapping labels if the text is too long or if there are too many ticks close together. Using the rotation parameter can help improve readability by rotating labels, especially on the x-axis.

4. Dynamic Data: If your plot’s data is dynamic, you may need to update both the ticks and labels regularly to ensure they stay in sync with the changing data.

By understanding and utilizing these functions, you can create more tailored and readable visualizations, especially when standard numeric or time-series labels do not suffice.

Controlling Ticks Position

• set_major_locator and set_minor_locator: These methods control where ticks appear. Major ticks are typically larger or more prominent, while minor ticks are often smaller and less noticeable.
• Locators: AutoLocator, MultipleLocator, FixedLocator, MaxNLocator (for maximum number of ticks), and others help in defining the placement of ticks.

Using MultipleLocator to place ticks at set intervals:

from matplotlib.ticker import MultipleLocator
import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot(range(100))

# Setting major tick locator
ax.xaxis.set_major_locator(MultipleLocator(20))  # Ticks at every 20 units
ax.yaxis.set_major_locator(MultipleLocator(10))  # Ticks at every 10 units

plt.show()
1
2
3
4
5
6
7
8
9
10
11

Locators

Using locators in Matplotlib is crucial for managing the positions of ticks on an axis, allowing for precise control over where ticks appear, which can significantly improve the readability and aesthetics of a plot. Matplotlib provides several locators in the matplotlib.ticker module, each designed for different types of data or plotting needs.

Commonly Used Locators:

1. AutoLocator:

   • The default locator, which tries to find an ideal number of ticks based on the data range and chooses sensible locations for ticks.

2. MaxNLocator:

   • Finds up to a maximum number of intervals at nice locations.

3. MultipleLocator:

   • Places ticks at multiples of some base number, useful for fixed intervals on an axis.

4. FixedLocator:

   • Sets ticks at fixed positions specified by the user. This is particularly useful when combined with set_xticklabels or set_yticklabels for categorical data.

5. LinearLocator:

   • Places a set number of ticks evenly spaced on the axis, determined by the number parameter.

6. LogLocator:

   • Places ticks in a logarithmic scale, useful for log-transformed data.

Example of Using Locators:

import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator, AutoLocator, MaxNLocator
import numpy as np

fig, ax = plt.subplots()

# Generate some data
x = np.linspace(0, 10, 100)
y = np.sin(x)
ax.plot(x, y)

# Using MultipleLocator to set tick marks at every 1 unit on x-axis
ax.xaxis.set_major_locator(MultipleLocator(1))

# Using MaxNLocator to limit the number of ticks on y-axis for clarity
ax.yaxis.set_major_locator(MaxNLocator(5))

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Best Practices for Using Locators:

1. Choosing the Right Locator: Select a locator based on the data’s nature and the desired frequency of tick marks. For example, MultipleLocator is very useful for evenly spaced intervals like time series (hours, days), while LogLocator is perfect for data spanning several orders of magnitude.

2. Combining with Formatters: Locators determine where the ticks appear, but you can use formatters to control what labels appear at these ticks, giving a high degree of control over both position and presentation.

3. Dynamic Data: When working with dynamic or updating data, reevaluate the choice of locator and formatter to ensure that ticks remain meaningful as data changes.

4. Performance Considerations: Using a large number of ticks (by setting a very fine locator) can slow down plotting and clutter the visual presentation. Always balance clarity with performance.

Using locators effectively can make your plots clearer and more professional. They are a fundamental tool for any data visualization task in Matplotlib, enabling precise control over the aesthetics of a plot.

Styling Ticks and Labels

• Visibility: You can show or hide ticks or labels using ax.xaxis.set_tick_params() with parameters like labeltop, labelbottom for positioning.
• Rotation: Tick labels can be rotated for better fit or readability using rotation parameter in set_tick_params.
• Size and Color: Customize size and color of tick labels using labelsize and labelcolor.
• Alignment: Adjust the alignment of tick labels relative to ticks with horizontalalignment or verticalalignment.

Customizing the appearance of tick labels:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot(range(10))

# Styling tick labels
ax.tick_params(axis='x', direction='out', length=6, width=2, colors='blue',
               grid_color='gray', grid_alpha=0.5, labelsize='medium', labelcolor='green', rotation=45)
ax.tick_params(axis='y', direction='inout', length=12, width=2, colors='red',
               grid_alpha=0.5, labelsize='small', labelcolor='purple', rotation=-45)

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

Change Tick Marks

In Matplotlib, you can control the visibility of the tick marks (the “-” like marks on the spine of an axis) using the tick_params method of an Axes object. Here’s how you can hide or show the tick marks on a specific axis:

Hiding Tick Marks

To hide the tick marks, you can set the length parameter to 0 using the tick_params method.

Showing Tick Marks

To show the tick marks (if they are hidden), you can set the length parameter to a positive value.

Example Code

Hiding Tick Marks:

Here’s an example demonstrating how to hide the tick marks on both the x-axis and y-axis:

import matplotlib.pyplot as plt
import numpy as np

# Create some data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create the plot
fig, ax = plt.subplots()
ax.plot(x, y)

# Hide tick marks on both x and y axes
ax.tick_params(axis='both', which='both', length=0)

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Showing Tick Marks:

Here’s an example demonstrating how to show the tick marks with a specific length:

import matplotlib.pyplot as plt
import numpy as np

# Create some data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create the plot
fig, ax = plt.subplots()
ax.plot(x, y)

# Show tick marks on both x and y axes with a specific length
ax.tick_params(axis='both', which='both', length=6)  # Length can be adjusted

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Detailed Explanation

1. Create the Plot:

   • Generate some data and create a plot using plot.

2. Hide Tick Marks:

   • Use ax.tick_params(axis='both', which='both', length=0) to hide tick marks on both the x and y axes.
   • axis='both': Applies the changes to both x and y axes.
   • which='both': Applies the changes to both major and minor ticks.
   • length=0: Sets the length of the tick marks to zero, effectively hiding them.

3. Show Tick Marks:

   • Use ax.tick_params(axis='both', which='both', length=6) to show tick marks on both the x and y axes with a length of 6.
   • You can adjust the length parameter to set the desired length of the tick marks.

Summary

• Use ax.tick_params(axis='both', which='both', length=0) to hide tick marks on both the x and y axes.
• Use ax.tick_params(axis='both', which='both', length=6) (or another positive value) to show tick marks with a specified length.

These methods provide a straightforward way to control the visibility of tick marks on your plots in Matplotlib.

Advanced Customization

• Tick Direction: tick_params can be used to set the direction of ticks (inward, outward, or both) with the direction parameter.
• Grids: Ticks are often associated with grid lines, which can be enabled or customized by axis (ax.grid(True)).

Adjusting tick direction and utilizing grid lines:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot(range(10))

# Advanced customization of ticks
ax.tick_params(axis='both', direction='inout', length=10, which='major')

# Enabling and customizing grid lines
ax.grid(True, which='both', linestyle='--', linewidth=0.5, color='gray')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

Comprehensive Examples

Below is a comprehensive example that incorporates various aspects of handling ticks and labels in Matplotlib, including the use of locators, formatters, and styling. This example will plot a simple graph, demonstrating:

1. The use of MultipleLocator and MaxNLocator for controlling tick positions.
2. Applying FuncFormatter for custom tick labels.
3. Customizing tick label appearance and orientation.
4. Adding grid lines for better readability.

Here’s the full example:

import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator, MaxNLocator, FuncFormatter
import numpy as np

# A simple function to format labels as squares of their inputs
def square_formatter(x, pos):
    return f'{int(x**2)}'

# Create a plot
fig, ax = plt.subplots()
x = np.linspace(0, 10, 100)
y = np.sin(x) * 100  # Scaled sine wave

# Plotting the function
ax.plot(x, y, label='100 * sin(x)')

# Setting locators
# X-axis: place a tick every 1 unit
ax.xaxis.set_major_locator(MultipleLocator(1))
# Y-axis: place exactly 5 major ticks
ax.yaxis.set_major_locator(MaxNLocator(5))

# Applying custom formatter
ax.xaxis.set_major_formatter(FuncFormatter(square_formatter))

# Styling ticks
ax.tick_params(axis='x', direction='out', length=6, width=2, colors='blue',
               grid_color='gray', grid_alpha=0.5, labelsize='medium', labelcolor='green', rotation=45)
ax.tick_params(axis='y', direction='inout', length=12, width=2, colors='red',
               grid_alpha=0.5, labelsize='small', labelcolor='purple', rotation=0)

# Enabling grid
ax.grid(True)

# Adding a legend
ax.legend()

# Display the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

Breakdown of the Example:

• Function Definition (square_formatter): This custom function is used to format the x-axis labels. It squares the x-values for the labels, demonstrating how FuncFormatter can be used to apply any custom string format based on the tick values.

• Tick Positioning:

  • The x-axis uses MultipleLocator to place a tick every 1 unit.
  • The y-axis uses MaxNLocator to place exactly 5 ticks, regardless of the data range, ensuring the plot isn’t overcrowded.

• Tick Label Formatting:

  • FuncFormatter is used on the x-axis to format tick labels according to the square_formatter function.

• Tick Styling:

  • Custom colors, lengths, widths, and rotation are set for the ticks and their labels on both axes to enhance readability and aesthetic appeal.

• Grid Lines:

  • Grid lines are enabled to improve the readability of the plot, which is especially useful in plots with variable data ranges or where precision in reading values is needed.

This example demonstrates a practical approach to handling ticks and labels in Matplotlib, providing both functionality and visual improvements to a simple plot. You can adapt and expand upon these techniques based on your specific data visualization needs.

Change Position of an Axis

To move the y-axis to the right side of an Axes object in Matplotlib, you can use the spines attribute of the Axes object to adjust the position of the y-axis and its labels.

Example Code

Here’s an example demonstrating how to move the y-axis to the right side of the plot:

import matplotlib.pyplot as plt
import numpy as np

# Create some data
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Create the plot
fig, ax = plt.subplots()
ax.plot(x, y)

# Move the y-axis to the right
ax.yaxis.set_ticks_position('right')
ax.yaxis.set_label_position('right')
ax.spines['right'].set_position(('outward', 0))  # Move the right spine outward
ax.spines['left'].set_position(('axes', 1.02))  # Hide the left spine (by moving it out of the visible area)

# Hide the left y-axis spine
ax.spines['left'].set_visible(False)

# Set y-axis label
ax.set_ylabel('Amplitude', fontsize=14, fontweight='bold', labelpad=20)

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Detailed Explanation

1. Create the Plot:

   • Generate some data and create a plot using plot.

2. Move the y-axis to the Right:

   • ax.yaxis.set_ticks_position('right'): This moves the y-axis ticks to the right side.
   • ax.yaxis.set_label_position('right'): This moves the y-axis label to the right side.
   • ax.spines['right'].set_position(('outward', 0)): This ensures the right spine (which contains the y-axis) is positioned outward.
   • ax.spines['left'].set_position(('axes', 1.02)): This effectively hides the left spine by moving it out of the visible area.

3. Hide the Left y-axis Spine:

   • ax.spines['left'].set_visible(False): This hides the left spine to ensure it doesn’t interfere with the plot’s appearance.

Example with Customization

Color Bar

Adding a Color Bar

To add a color bar to a plot, you typically need to create a plot with a colormap (e.g., using imshow, contourf, or scatter). Here’s a basic example using imshow:

import matplotlib.pyplot as plt
import numpy as np

# Create some data
data = np.random.rand(10, 10)

# Create the plot
fig, ax = plt.subplots()
cax = ax.imshow(data, cmap='viridis')

# Add the color bar
cbar = fig.colorbar(cax, ax=ax)

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Getting a Color Bar

Sometimes, you might need to access and modify an existing color bar from a plot. Here’s how you can retrieve it:

Accessing the Color Bar

If you have added the color bar to a plot and need to modify it later, you can keep a reference to the Colorbar object:

# Add the color bar and keep a reference to it
cbar = fig.colorbar(cax, ax=ax)
1
2

Modifying an Existing Color Bar

Once you have the Colorbar object, you can modify it as needed:

# Assuming you have a reference to the color bar
cbar.set_label('Updated Intensity')
cbar.set_ticks([0.1, 0.3, 0.5, 0.7, 0.9])
cbar.set_ticklabels(['Very Low', 'Low', 'Medium', 'High', 'Very High'])

# Custom tick formatter
def new_format(x, pos):
    return f'{x:.1%}'
cbar.set_formatter(FuncFormatter(new_format))
1
2
3
4
5
6
7
8
9

Example: Accessing and Updating a Color Bar

Here is a complete example demonstrating how to access and update an existing color bar:

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import FuncFormatter

# Create some data
data = np.random.rand(10, 10)

# Create the plot
fig, ax = plt.subplots()
cax = ax.imshow(data, cmap='viridis')

# Add the color bar and keep a reference to it
cbar = fig.colorbar(cax, ax=ax, orientation='horizontal')

# Update the color bar
cbar.set_label('Updated Intensity')
cbar.set_ticks([0.1, 0.3, 0.5, 0.7, 0.9])
cbar.set_ticklabels(['Very Low', 'Low', 'Medium', 'High', 'Very High'])

# Custom tick formatter
def new_format(x, pos):
    return f'{x:.1%}'
cbar.set_formatter(FuncFormatter(new_format))

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Customizing the Color Bar

Location

You can set the location of the color bar using the location parameter:

cbar = fig.colorbar(cax, ax=ax, location='right')  # Other options: 'left', 'top', 'bottom'
1

Orientation

The color bar can be oriented vertically (default) or horizontally:

cbar = fig.colorbar(cax, ax=ax, orientation='horizontal')
1

Note:

To set the location and orientation of an already-existing color bar in Matplotlib, you typically need to remove the current color bar and add a new one with the desired location and orientation. Matplotlib does not support changing the location and orientation of an existing color bar directly.

Label

You can add a label to the color bar:

cbar.set_label('Intensity')

# Set the label with font size and style 
cbar.set_label('Intensity', fontsize=14, fontweight='bold')
1
2
3
4

Ticks

Customizing the ticks and their labels:

cbar.set_ticks([0.2, 0.4, 0.6, 0.8])
cbar.set_ticklabels(['Low', 'Medium-Low', 'Medium-High', 'High'])

# Set the font size and style for the tick labels
cbar.ax.tick_params(labelsize=12, labelrotation=45)

# Iterate over tick labels to set font size and style
for label in cbar.ax.get_yticklabels():
    label.set_fontsize(12)
    label.set_fontweight('bold')
1
2
3
4
5
6
7
8
9
10

Formatting the Tick Labels

You can format the tick labels using FormatStrFormatter or FuncFormatter from matplotlib.ticker:

from matplotlib.ticker import FormatStrFormatter, FuncFormatter

# Using FormatStrFormatter
cbar.set_formatter(FormatStrFormatter('%.2f'))

# Using FuncFormatter
def custom_format(x, pos):
    return f'{x:.1f} units'
cbar.set_formatter(FuncFormatter(custom_format))
1
2
3
4
5
6
7
8
9

Size and Padding

Adjust the size and padding of the color bar:

# Set the aspect ratio
cbar.ax.set_aspect(20)  # Aspect ratio can be a float

# Set the padding
cbar.ax.get_yaxis().set_ticks_position('right')
cbar.ax.get_yaxis().set_label_position('right')
cbar.ax.tick_params(pad=10)
1
2
3
4
5
6
7

Example: Putting It All Together

Here is a complete example that includes several customizations:

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import FuncFormatter

# Create some data
data = np.random.rand(10, 10)

# Create the plot
fig, ax = plt.subplots()
cax = ax.imshow(data, cmap='viridis')

# Add the color bar with customizations
cbar = fig.colorbar(cax, ax=ax, orientation='horizontal', location='bottom', pad=0.1, aspect=30)
cbar.set_label('Intensity')
cbar.set_ticks([0.2, 0.4, 0.6, 0.8])
cbar.set_ticklabels(['Low', 'Medium-Low', 'Medium-High', 'High'])

# Custom tick formatter
def custom_format(x, pos):
    return f'{x:.1f} units'
cbar.set_formatter(FuncFormatter(custom_format))

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Summary

1. Adding a Color Bar: Create a plot with a colormap and add a color bar using fig.colorbar().
2. Customizing the Color Bar: Customize the color bar’s location, orientation, label, ticks, tick labels, size, and padding.
3. Getting a Color Bar (from Plot): Access and modify an existing color bar by keeping a reference to the Colorbar object and updating its properties as needed.

This guide should provide a comprehensive understanding of how to add, customize, and retrieve color bars in Matplotlib plots.

Bar Plot

The plt.bar() function in Matplotlib is a versatile tool for creating bar charts, which are useful for visualizing data that varies across categories. This function is part of Matplotlib’s pyplot interface, which provides a way to create plots in a manner similar to MATLAB’s plotting interface. Using plt.bar(), you can make vertical bar charts straightforwardly. Here’s a detailed breakdown of how to use plt.bar() and its common parameters.

Basic Functionality of plt.bar()

Syntax:

plt.bar(x, height, width=0.8, bottom=None, align='center', data=None, **kwargs)
1

Parameters:

• x: Sequence of scalars representing the x coordinates of the bars. This typically consists of the range of categories or bin edges.
• height: Scalar or sequence of scalars representing the height(s) of the bars.
• width: Scalar or array-like, optional. The width(s) of the bars (default is 0.8).
• bottom: Scalar or array-like, optional. The y coordinate(s) of the bars bases (default is 0).
• align: {‘center’, ‘edge’}, optional, default: ‘center’. Alignment of the bars to the x coordinates:
  • ‘center’: Centers the base on the x positions.
  • ‘edge’: Aligns the left edges of the bars with the x positions.
• color: Color or sequence of colors for the bars.
• edgecolor: Color or sequence of colors for the bar edges.
• linewidth: The width of the bar edges (if edgecolor is specified).
• tick_label: String or sequence of strings for labeling the x ticks.
• yerr/xerr: Scalar or array-like of shape(N,) or shape(2,N), optional. Adds errorbars to the bar tips. yerr is for vertical bars, xerr is for horizontal bars.
• capsize: Scalar, optional. Determines the width of the error bar caps.

Example Usage:

Here is a basic example of creating a bar chart with plt.bar():

import matplotlib.pyplot as plt

# Categories and their values
categories = ['Category 1', 'Category 2', 'Category 3', 'Category 4']
values = [10, 15, 7, 12]

# Create a bar chart
plt.bar(categories, values, color='blue', edgecolor='black')

# Add title and labels
plt.title('Basic Bar Chart Example')
plt.xlabel('Categories')
plt.ylabel('Values')

# Show the plot
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Bar Plots with Groups

Creating grouped bar charts is a common practice to compare multiple datasets. Here’s how you can plot grouped bars, which involve adjusting the bar positions so they appear next to each other rather than overlapping. You would typically adjust the x positions for the bars and manipulate the width or bottom parameters accordingly.

Example of Grouped Bar Chart:

import matplotlib.pyplot as plt
import numpy as np

# Data setup
categories = ['A', 'B', 'C', 'D']
values1 = [10, 15, 7, 10]
values2 = [5, 3, 9, 11]
x = np.arange(len(categories))  # the label locations
width = 0.35  # the width of the bars

fig, ax = plt.subplots()
bars1 = ax.bar(x - width/2, values1, width, label='Group 1')
bars2 = ax.bar(x + width/2, values2, width, label='Group 2')

# Adding some text for labels, title, and custom x-axis tick labels
ax.set_xlabel('Categories')
ax.set_ylabel('Values')
ax.set_title('Values by group and category')
ax.set_xticks(x)
ax.set_xticklabels(categories)
ax.legend()

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Adding Error Bars

If you want to add error bars to indicate the variability of the data, you can use the yerr parameter:

# Example errors for each bar
errors = [0.5, 1.0, 0.5, 0.8]

plt.bar(categories, values, color='red', yerr=errors, capsize=5)
plt.show()
1
2
3
4
5

Other Common Options

• Bar Color: You can specify the color parameter to change the color of the bars.
• Error Bars: Incorporate error bars into the bar plot by passing an yerr argument with error values.
• Horizontal Bars: Use ax.barh() for horizontal bars if your data labels are lengthy or if you prefer a horizontal layout.
• Stacked Bars: You can create stacked bars by adjusting the bottom parameter of the second and subsequent ax.bar() calls to stack on top of the previous bars.
• Styling: Customize edge color, line width, pattern, and transparency to make the plot communicative and visually appealing.

Example with Error Bars and Custom Colors:

import matplotlib.pyplot as plt
import numpy as np

# Sample data
categories = ['A', 'B', 'C', 'D']
values = [10, 15, 7, 10]
errors = [0.5, 1.0, 0.5, 1.2]  # Example error values

fig, ax = plt.subplots()
ax.bar(categories, values, color='skyblue', yerr=errors, capsize=5)  # Capsize controls the horizontal line width at the error bar tips

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

This introduction covers the basics and some advanced topics in creating bar plots using Matplotlib. You can use these examples as a foundation to explore further customizations and applications of bar plots in data visualization.

Text in the Plot

The Text class in matplotlib is used to handle text in plots. This class allows you to place text in various locations of the plot, customize its appearance, and manage its properties. Here’s a detailed introduction to the Text class and instructions on how to search and set text in a plot using matplotlib:

Introduction to the Text Class

The Text class is part of the matplotlib.text module. It allows you to create and manipulate text objects in your plots. Here are some key attributes and methods associated with the Text class:

• Attributes:

  • text: The string of text you want to display.
  • fontproperties: An instance of FontProperties that controls the font family, size, weight, and other font-related properties.
  • horizontalalignment or ha: Specifies the horizontal alignment of the text (‘center’, ‘right’, ‘left’).
  • verticalalignment or va: Specifies the vertical alignment of the text (‘center’, ‘top’, ‘bottom’, ‘baseline’).
  • rotation: The rotation angle of the text in degrees.
  • fontsize: The size of the font.
  • color: The color of the text.
  • backgroundcolor: The background color of the text.
  • alpha: The transparency of the text (0 is fully transparent, 1 is fully opaque).
  • bbox: A dictionary of bounding box properties (e.g., boxstyle, pad, facecolor).

• Methods:

  • set_text(): Sets the text string.
  • set_position(): Sets the position of the text.
  • set_fontsize(): Sets the font size.
  • set_color(): Sets the text color.
  • set_alpha(): Sets the transparency.
  • set_rotation(): Sets the rotation angle.
  • set_bbox(): Sets the bounding box properties.

Adding Text to a Plot

To add text to a plot in matplotlib, you can use the text() function of the Axes or pyplot module. Here’s how you can do it:

1. Basic Usage:

   import matplotlib.pyplot as plt
   
   plt.plot([1, 2, 3], [4, 5, 6])
   plt.text(2, 5, 'Sample Text')
   plt.show()
   1
   2
   3
   4
   5

2. Customizing Text:

   import matplotlib.pyplot as plt
   
   plt.plot([1, 2, 3], [4, 5, 6])
   plt.text(2, 5, 'Sample Text', fontsize=12, color='red', ha='center', va='bottom', rotation=45)
   plt.show()
   1
   2
   3
   4
   5

3. Using Text Objects:

   import matplotlib.pyplot as plt
   
   fig, ax = plt.subplots()
   ax.plot([1, 2, 3], [4, 5, 6])
   text = ax.text(2, 5, 'Sample Text', fontsize=12, color='blue')
   text.set_fontsize(14)
   text.set_color('green')
   plt.show()
   1
   2
   3
   4
   5
   6
   7
   8

Searching for Text in a Plot

To search and manipulate text objects in a plot, you can use the findobj() method of the Figure or Axes objects. Here’s an example:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])
text = ax.text(2, 5, 'Sample Text', fontsize=12, color='blue')

# Search for text objects in the Axes
for t in ax.findobj(match=plt.Text):
    print(f'Text: {t.get_text()}, Position: {t.get_position()}, Font size: {t.get_fontsize()}, Color: {t.get_color()}')
    if "$" in text.get_text():    
        text.set_visible(False)

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13

Setting Text in a Plot

• Here’s an example that demonstrates how to find a specific text object in a matplotlib plot and then modify its properties:

import matplotlib.pyplot as plt

# Create a plot with multiple text annotations
fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])

# Add multiple text annotations
text1 = ax.text(1, 4, 'First Text', fontsize=12, color='blue')
text2 = ax.text(2, 5, 'Second Text', fontsize=12, color='red')
text3 = ax.text(3, 6, 'Third Text', fontsize=12, color='green')

# Function to find and modify specific text
def find_and_modify_text(ax, search_text, new_text, new_color='black', new_fontsize=14):
    for text_obj in ax.findobj(match=plt.Text):
        if text_obj.get_text() == search_text:
            text_obj.set_text(new_text)
            text_obj.set_color(new_color)
            text_obj.set_fontsize(new_fontsize)
            break

# Find 'Second Text' and modify it
find_and_modify_text(ax, 'Second Text', 'Modified Text', new_color='purple', new_fontsize=16)

plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Explanation of the above code:

Create a Plot with Multiple Text Annotations:
A plot is created with three text annotations: ‘First Text’, ‘Second Text’, and ‘Third Text’.
Find a Specific Text Annotation: A function find_and_modify_text is defined to search for a specific text object in the plot and modify its properties.
Modify the Specific Text Annotation:The function find_and_modify_text is called to find the text object with the text ‘Second Text’ and modify it to ‘Modified Text’, change its color to ‘purple’, and set its font size to 16.

• Here’s a complete example that sets multiple text properties in a plot:

import matplotlib.pyplot as plt

fig, ax = plt.subplots()
ax.plot([1, 2, 3], [4, 5, 6])

# Adding and customizing text
text = ax.text(2, 5, 'Sample Text', fontsize=12, color='blue', ha='center', va='bottom', rotation=45)
text.set_bbox(dict(facecolor='yellow', alpha=0.5, edgecolor='red'))

plt.show()
1
2
3
4
5
6
7
8
9
10

This example demonstrates how to add text to a plot, customize its appearance, and use a bounding box to highlight it. The set_bbox() method is used to create a background color with transparency and an edge color.

These tools and methods provide flexibility in adding and managing text within your matplotlib visualizations, allowing for detailed and customized plots.

Mathematical Expression

In Matplotlib, the expression $\mathregular{...}$ is used within text elements to denote that the text enclosed should be rendered in a regular font style, overriding the default behavior in mathematical expressions, which typically renders in italics. This is particularly useful when integrating mathematical expressions with regular text in annotations, labels, titles, or other textual elements in your plots.

Text Rendering Background

Matplotlib uses a subset of TeX markup to render mathematical expressions. By default, text enclosed in dollar signs $...$ is interpreted as a math expression and rendered using a math font (which renders in italics to distinguish variables). However, sometimes you might want to include non-italicized, regular text within these mathematical expressions, especially when dealing with symbols or text that are not variables but are part of a mathematical annotation.

Usage of $\mathregular{...}$

The \mathregular{...} command within a math expression ensures that the text inside the braces is rendered in a regular, upright font, not in italics. This is especially useful for including regular text or symbols that should not be italicized according to mathematical typesetting conventions.

In Matplotlib, you can easily set subscript and superscript text using the TeX markup syntax within any text string. This functionality is incredibly useful for mathematical labeling and annotation in plots, where you may need to denote powers, indices, or other hierarchical text positioning.

• Superscript: To set a superscript, use the caret ^ symbol followed by the text you want to superscript, enclosed in curly braces {} if it is more than one character long.
• Subscript: To set a subscript, use the underscore _ symbol followed by the text you want to subscript, again enclosed in curly braces {} if it spans more than one character.

Example Usage:

Here’s an example that demonstrates how to include subscripts and superscripts in plot titles, labels, or annotations:

import matplotlib.pyplot as plt

# Create a simple plot
plt.figure()
plt.plot([1, 2, 3, 4, 5], [1, 4, 9, 16, 25])  # y = x^2 plot

# Adding title with superscript
plt.title(r'$y = x^2$')  # Superscript 2 denotes squared

# Adding axes labels with subscript
plt.xlabel(r'$x_1$')  # Subscript 1 on x
plt.ylabel(r'$x_{in}^2$')  # Subscript 'in' and superscript '2' on x

# Annotating a point with both subscript and superscript
plt.annotate(r'$Point\ (x_1^3)$', (3, 9), textcoords="offset points", xytext=(0,10), ha='center')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Key Points to Remember:

• Enclosing Braces: When your subscript or superscript has more than one character, ensure you enclose them in curly braces. For example, x^{10} or x_{in}.
• Raw Strings: Use raw strings (prefix with r) in Python to avoid having to escape backslashes in TeX commands.
• Combining Text: Normal text and TeX expressions can be combined by enclosing the TeX parts in dollar signs $...$ and writing text outside or escaping spaces within TeX using \.

Using subscripts and superscripts effectively can enhance the clarity and informational value of your Matplotlib visualizations, especially when dealing with scientific or mathematical data.

Example Usage

Here’s how you can use $\mathregular{...}$ in Matplotlib to mix regular text with mathematical expressions:

import matplotlib.pyplot as plt

# Example plot
plt.figure()
plt.plot([1, 2, 3], [1, 4, 9])

# Adding a title with mixed italics and regular text
plt.title(r'$\alpha^2 + \beta^2 = \mathregular{constant}$')

# Labeling axes with regular text within a math expression
plt.xlabel(r'$\mathregular{Time (seconds)}$')
plt.ylabel(r'$\mathregular{Distance (meters)}$')

plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

In this example, the r before the string denotes a raw string in Python, which tells Python not to treat backslashes as escape characters. The math expression parts (\alpha, \beta) are italicized, while the text enclosed in \mathregular{...} is rendered in a normal font, matching the surrounding non-mathematical text.

Key Points

• Integration: $\mathregular{...}$ allows seamless integration of regular and mathematical text within annotations in Matplotlib.
• Syntax: Always start with an r (to denote a raw string in Python) when using TeX in Matplotlib to avoid having to escape backslashes.
• Styling: Although \mathregular{} affects the font style, other formatting aspects like font size, color, and additional TeX commands can still be applied outside of \mathregular{} to further customize the appearance.

Using $\mathregular{...}$ in Matplotlib is an effective way to ensure that textual content within mathematical annotations adheres to the appropriate typesetting norms, particularly when differentiating standard text from mathematical variables or expressions.

Documentation

You can explore more customization options in the Matplotlib documentation to adjust things like line width, transparency, label, etc.

With these parameters, you have a lot of flexibility to customize the style of your plots in Matplotlib according to your preferences.