Matplotlib Plotting Tips: Enhance Your Visualizations
As a data scientist, you understand the importance of creating visually compelling visualizations that can effectively convey complex data. However, creating these charts can be challenging.
Fortunately, Matplotlib is a powerful data visualization library that simplifies the visualization process. In this article, we’ll explore some tips and tricks to take your data visualizations to the next level.
Changing the Size of the Plot
By default, Matplotlib plots are created in a fixed size. However, there may be instances where you need to make your plot bigger or smaller.
Fortunately, there’s a simple function that lets you customize the size of your plot. To do this, use the figsize
parameter within the figure()
function:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 100)
y = x ** 2
# Plotting figure with a smaller size
plt.figure(figsize=(4, 3))
plt.plot(x, y)
plt.show()
# Plotting figure with a larger size
plt.figure(figsize=(8, 6))
plt.plot(x, y)
plt.show()
By using the figsize
parameter, you can create charts that fit your specific needs. Be aware that this function modifies the aspect ratio of your plot, so ensure that it does not distort the representation of your data.
Adding Annotations
Sometimes data visualizations aren’t enough to communicate your message. Fortunately, annotating important points in your chart enables you to provide additional information to your audience.
Matplotlib provides two useful functions for annotating plots.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 100)
y = x ** 2
# Plotting the line
plt.plot(x, y)
# Adding annotation to the plot
plt.annotate('Minimum Value', xy=(2.5, 5),
xytext=(3, 30),
arrowprops=dict(facecolor='black', shrink=0.05))
plt.show()
The above code adds a text annotation labeled ‘Minimum Value’ to the point (2.5,5) on the graph. The xytext
parameter dictates where the annotated text will be displayed.
The arrowprops
parameter allows you to add arrows in the annotation that connect the point of interest with a related note. These annotations provide additional clarity, which makes the plot more meaningful to the viewer.
Adding Watermarks to the Plot
Sometimes you may need to add a watermark to your plot, especially in instances where you would like to protect the intellectual property and brand image. To add watermarks to your plots, you can use the text()
function to add a watermark as text by either creating an image watermark or text-based watermark.
import matplotlib.pyplot as plt
import numpy as np
# Adding watermark to the plot
fig, ax = plt.subplots()
ax.plot(np.arange(5))
ax.text(0.5, 0.5, 'Confidential', alpha=0.2,
fontsize=50, color='gray',
ha='center', va='center', rotation='30')
plt.show()
With the above code, you can produce a watermark-based text that says ‘Confidential’ over the plot with 20% translucence, font size of 50, color gray, with a rotation of 30 degrees.
Usage of the Figure Function to Change the Size
We earlier learned that we can use the figsize
parameter to modify the size of plots. Another easy way to change the figure size of a Matplotlib plot is through the figure()
function, which allows you to specify the dimensions of your plot using the figsize
parameter.
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 5, 100)
y = x ** 2
# Plotting a figure with a specified size
plt.figure(figsize=(10, 5))
plt.plot(x, y)
plt.show()
# Plotting a figure with normal size
plt.figure()
plt.plot(x, y)
plt.show()
In the above code, changing the figsize
parameter changes the size of the created figure. In the second plot, since we didn’t add the figsize
parameter in the figure()
function, the figure size uses the default plot size.
Examples of Normal-Sized and Smaller-Sized Plots
Sometimes it is best to use a smaller plot, especially when there are more data points than the figure can accommodate. One way of reducing the size of the plot is by using the subplots_adjust()
function, which reduces the size of the plot’s axes.
import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator
# Generating a smaller plot example
fig, ax = plt.subplots(figsize=(3, 3))
ax.plot([0, 1, 2], [1, 2, 3])
# Setting the number of ticks on the x and y axis
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(1))
# Adding the grid
ax.grid()
plt.show()
Sometimes, the opposite happens, and a plot instance will have too much white space that you need to adjust in the opposite direction. To do this, you can use the tight_layout()
function.
import matplotlib.pyplot as plt
import numpy as np
# Generating a plot with excess whitespace
fig, ax = plt.subplots()
x = np.random.randn(1000)
y = np.random.randn(1000)
hb = ax.hexbin(x, y, gridsize=50)
fig.colorbar(hb, ax=ax)
plt.show()
# Replotting with tight layout
fig, ax = plt.subplots()
x = np.random.randn(1000)
y = np.random.randn(1000)
hb = ax.hexbin(x, y, gridsize=50)
fig.colorbar(hb, ax=ax)
plt.tight_layout()
plt.show()
By calling the tight_layout()
function, Matplotlib adjusts the plot size dynamically based on the elements within it. As a result, the second plot is a compressed version of the initial plot.
Conclusion
We learn that there is a broad range of Matplotlib tips to enhance your visualization quality and create informative visualizations for data scientists. Changing the plot size, adding annotations, watermarks, and adjusting subplots are only a few of the options.
Hopefully, these tips demonstrate ways to improve your Matplotlib plotting practice’s effectiveness, enabling you to create attractive, informative visualizations for your audience. Expanding on our previous article on Matplotlib Plotting Tips, let’s delve into the specifics of adding annotations and watermarks to your Matplotlib plots.
Annotations and watermarks offer ways to add extra context and information to the visualization, increasing its effectiveness in communicating information.
Adding Annotations using the Text Function
Annotations are an excellent way to enhance your visualization storytelling. They help to highlight significant events, trends, or data points by calling attention to them in a visible, informative way.
Matplotlib provides the text()
function that enables you to add annotations onto your plot. Using the text()
function can be relatively simple; you specify the location of the text, its string value, and font size.
import matplotlib.pyplot as plt
x = [1, 2, 3, 4]
y = [50, 60, 55, 70]
plt.plot(x, y)
plt.text(2.5,60,'Highest point',fontsize=12,color='red')
plt.show()
In the code above, we plot a simple line chart and add a text annotation above the highest point on the chart. The text()
function takes three parameters: the x and y coordinate where the text will be placed, and the text string itself.
Additionally, we specified the font size of the string and its color to red.
Adding Annotations using the Annotate Function
Matplotlib also provides an alternative to the text()
function for adding annotations, the annotate()
function. While the text()
function places a string at the specified location, the annotate()
function allows you to overlay an arrow in the text area, highlighting specific features of a plot.
Here’s an example of annotate()
, in which we connect two points with some additional information.
import matplotlib.pyplot as plt
x = [1, 2, 3, 4]
y = [50, 60, 55, 70]
plt.plot(x, y)
plt.annotate("Compare increase and decrease", xy=(1.6, 56),
xytext=(3, 58),
arrowprops=dict(facecolor='black', shrink=0.1))
plt.show()
With the above code, we added an arrow that begins at point (1.6, 56) with a tip at point (3, 58) above the line.
It uses arrowprops
to define the properties of the arrow.
Text-based Watermark
Watermarks in data visualizations communicate the ownership of the plots generated by others, adding copyright details and branding the visualization. Matplotlib provides several options to add a Watermark to your visualization.
The first one is text-based, where you can add text over the plot with a lower opacity to make it look like a watermark.
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots()
ax.plot(np.arange(5))
ax.text(0.5, 0.5, 'CONFIDENTIAL', alpha=0.2,
fontsize=50, color='gray',
ha='center', va='center', rotation='30')
plt.show()
With this code, we generate a plot on which we add a text watermark. In doing so, we defined alpha
to be 0.2
to decrease the watermark’s opacity, making it less intrusive.
We further defined the horizontal and vertical alignment to be in the center of the plot, making it more aesthetically pleasing.
Image-based Watermark
Another form of watermark that can be added to Matplotlib visualizations is an image-based watermark. In this case, an image overlaid on the plot that delivers a watermark.
You can consider this type of watermark if the text-based watermark seems too simple.
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.offsetbox import (OffsetImage,AnnotationBbox)
fig, ax = plt.subplots()
x=np.linspace(0,10,20)
y=np.sin(x)
ax.plot(x,y)
imscatter(x=0.8,y=0.8,image_path=r'C:/logo.png',ax=ax,zoom=0.1)
plt.show()
In the above code, we overlaid an image-based watermark over the plot. The imscatter()
function takes an image loaded from its file path, and we positioned it at the lower right of the plot.
We further set the zoom parameter to 0.1
so that the watermark’s size remains proportional to the plot size, and it is less intrusive.
Conclusion
Annotations and watermarks are essential tools for communicating information effectively through data visualizations. While the text()
function provides a simple form of annotation, the annotate()
function offers a more flexible and elegant way of highlighting important features in a plot.
In contrast, text-based watermarks domain simple form branding the visualizations we generate. Still, image-based watermarks allow us to personalize our watermark further.
Understanding the different ways of using these Matplotlib features will help produce visualizations that are clear and easy to read while conveying all the desired information effectively. In conclusion, adding annotations and watermarks is essential in enhancing the effectiveness of data visualizations.
Annotations implemented through the text()
and annotate()
functions, provide an elegant method of calling attention to specific chart features. Watermarks, on the other hand, protect the brand’s intellectual property and contribute a layer of customization to the visualizations.
Text-based and image-based watermarks provide flexibility in branding the visualizations. By understanding how to use these Matplotlib functions, you can create data visualizations that capture the viewer’s attention, effectively communicate data insights, and promote brand identity.
Remember to use them wisely to prevent obscuring chart features and providing a professional and personalized chart.