Matplotlib is a popular data visualization library that allows developers to create and display charts, graphs, and other visualizations of data. With Matplotlib, you can customize a variety of features such as colors, fonts, and line styles to make the visualizations stand out and convey the intended message to the audience.
Setting Background Color in Matplotlib
One of the most effective ways to make your visualizations look professional and visually appealing is to set the background color of the plot. There are several ways to set the background color in Matplotlib, which we will discuss below.
Using set_facecolor() function
To set the background color of the entire plot, you can use the set_facecolor() function. This function takes a color as an argument and sets the background color of the plot to that color.
For example, the following code sets the background color of the plot to light gray:
import matplotlib.pyplot as plt
fig = plt.figure()
fig.set_facecolor('lightgrey')Setting Background Color Using Color Name
If you want to use a predefined color, you can specify the color by name. Matplotlib supports a wide range of color names that can be used to set the background color of the plot.
For example, the following code sets the background color of the plot to yellow:
import matplotlib.pyplot as plt
fig = plt.figure()
fig.set_facecolor('yellow')Setting Background Color Using Hex Color Code
If you want to use a specific color that is not predefined, you can use a hex color code to specify the color. To use a hex color code, you need to specify the color code in the format #RRGGBB, where RR is the red component, GG is the green component, and BB is the blue component of the color.
For example, the following code sets the background color of the plot to dark green:
import matplotlib.pyplot as plt
fig = plt.figure()
fig.set_facecolor('#006400')Setting Background Color of Specific Subplot
If you want to set the background color of a specific subplot, you can use the tight_layout() function. The tight_layout() function adjusts the positions of the subplots so that there is no overlap.
To set the background color of a specific subplot, you can first create the subplot using the add_subplot() function and then use the set_facecolor() function to set the background color of the subplot. For example, the following code sets the background color of the first subplot to light blue:
import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(221)
ax1.set_facecolor('lightblue')
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(223)
ax4 = fig.add_subplot(224)Creating the Matplotlib Plot
Once you have set the background color of the plot, you can start creating the plot itself. Creating a scatterplot in Matplotlib involves defining the figure and axis, defining the arrays for plotting, and creating the scatterplot.
Defining Figure and Axis
The first step in creating a scatterplot is to define the figure and axis. The figure is the top-level container that holds the plot and all the subplots.
The axis is the area inside the figure where the plot is drawn. To define the figure and axis, you can use the subplots() function, which returns both the figure and axis.
For example, the following code defines a figure with one axis:
import matplotlib.pyplot as plt
fig, ax = plt.subplots()Defining Arrays for Plotting
The next step is to define the arrays for plotting. In a scatterplot, you have two sets of data: the x-axis data and the y-axis data.
You can define the arrays for these data using NumPy, a popular numerical computing library for Python. For example, the following code defines two arrays for plotting:
import numpy as np
x = np.array([1, 2, 3, 4, 5])
y = np.array([10, 20, 30, 40, 50])Creating Scatterplot
Finally, you can create the scatterplot using the scatter() function. The scatter() function takes the x-axis data and y-axis data as arguments and plots them as points on the axis.
By default, the scatter() function plots the points in blue color. However, you can customize the color, size, and shape of the points using various parameters of the scatter() function.
For example, the following code creates a scatterplot with red points:
import numpy as np
import matplotlib.pyplot as plt
x = np.array([1, 2, 3, 4, 5])
y = np.array([10, 20, 30, 40, 50])
fig, ax = plt.subplots()
ax.scatter(x, y, color='red')Conclusion
In this article, we looked at how to set the background color in Matplotlib and how to create a scatterplot. Setting the background color of the plot can make the visualizations look more professional and visually appealing.
Creating a scatterplot involves defining the figure and axis, defining the arrays for plotting, and creating the scatterplot using the scatter() function. With these techniques, you can create beautiful and informative scatterplots that convey the intended message to the audience.
Displaying the Matplotlib Plot
After creating the Matplotlib plot, the final step is to display the plot.
To display the plot, you can use the plt.show() function. The plt.show() function is a blocking function, which means that the code execution is blocked until the user closes the plot window.
The plt.show() function should be called only once per script, and it should be called after all the plotting commands have been issued. For example, the following code displays a scatterplot:
import numpy as np
import matplotlib.pyplot as plt
x = np.array([1, 2, 3, 4, 5])
y = np.array([10, 20, 30, 40, 50])
fig, ax = plt.subplots()
ax.scatter(x, y, color='red')
plt.show()When you run this code, a new window will pop up showing the scatterplot. You can interact with this window by resizing the window, saving the image, or closing the window.
The plt.show() function can also be used to display multiple plots in the same window. To display multiple plots, you need to create multiple axes objects and then plot the data on each axis.
For example, the following code creates four scatterplots in the same window:
import numpy as np
import matplotlib.pyplot as plt
x1 = np.array([1, 2, 3, 4, 5])
y1 = np.array([10, 20, 30, 40, 50])
x2 = np.array([2, 4, 6, 8, 10])
y2 = np.array([20, 40, 60, 80, 100])
x3 = np.array([3, 6, 9, 12, 15])
y3 = np.array([30, 60, 90, 120, 150])
x4 = np.array([4, 8, 12, 16, 20])
y4 = np.array([40, 80, 120, 160, 200])
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8, 8))
ax[0, 0].scatter(x1, y1, color='red')
ax[0, 1].scatter(x2, y2, color='blue')
ax[1, 0].scatter(x3, y3, color='green')
ax[1, 1].scatter(x4, y4, color='purple')
plt.show()In this code, we create four scatterplots in a 2×2 grid using the subplots() function. We then use the scatter() function to plot the data on each axis.
Finally, we call the plt.show() function to display the four scatterplots in the same window. It is important to note that the plt.show() function is a blocking function.
This means that the code execution is blocked until the user closes the plot window. If you are developing interactive programs, this can be a problem because the program will be unresponsive until the user closes the plot window.
To avoid this problem, you can use the plt.ion() function to turn on the interactive mode. In interactive mode, the plt.show() function does not block the code execution, and the plot window is updated automatically when new data is added to the plot.
For example, the following code turns on the interactive mode and updates the scatterplot automatically:
import numpy as np
import matplotlib.pyplot as plt
plt.ion()
x = np.array([1, 2, 3, 4, 5])
y = np.array([10, 20, 30, 40, 50])
fig, ax = plt.subplots()
ax.scatter(x, y, color='red')
for i in range(10):
y = [val+5 for val in y] # add 5 to each y value
ax.clear() # clear the plot
ax.scatter(x, y, color='red') # plot the updated data
plt.pause(0.5) # pause for 0.5 secondsIn this code, we turn on the interactive mode using the plt.ion() function. We then create a scatterplot and plot the data on the axis.
We then create a loop that updates the data and redraws the scatterplot every 0.5 seconds using the clear() and scatter() functions. The plt.pause() function is used to pause the code execution for 0.5 seconds in each iteration.
Conclusion
In this section, we learned how to display the Matplotlib plot using the plt.show() function. The plt.show() function is the final step in creating the plot, and it displays the plot in a new window.
We also learned how to display multiple plots in the same window using the subplots() function. Finally, we learned how to use the plt.ion() function to turn on interactive mode, which allows us to update the plot automatically without blocking the code execution.
In this article, we explored how to set the background color in Matplotlib and how to create a scatterplot. We learned that setting the background color of the plot can make the visualizations look more professional and visually appealing.
We also learned how to create a scatterplot, which involves defining the figure and axis, defining the arrays for plotting, and creating the scatterplot using the scatter() function. Finally, we learned how to display the Matplotlib plot using the plt.show() function.
It is important to note that the plt.show() function is a blocking function, and the plt.ion() function can be used to turn on interactive mode. By following these steps, we can create beautiful and informative visualizations that effectively communicate the intended message to the audience.