Area Plot and Bar Plot with Matplotlib

This documentation provides a comprehensive guide to creating and customizing Area Plots and Bar Plots using Matplotlib in Python.

Area Plot

An area plot is a type of graph that fills the space below a line with color, making it useful for visualizing trends, cumulative data, and comparisons over time. Matplotlib provides two primary functions for creating area plots:

• fill_between(): Fills the area between two curves.
• stackplot(): Creates stacked area plots for multiple datasets.

1. Creating an Area Plot Using fill_between()

The fill_between() function is used to fill the region between two horizontal curves.

Syntax:

plt.fill_between(x, y1, y2=0, where=None, interpolate=False, step=None, **kwargs)

Key Parameters:

• x: X-coordinates of data points.
• y1: Y-coordinates of the first curve.
• y2: Y-coordinates of the second curve (defaults to 0).
• where: A boolean array that specifies where to fill. Filling is done only where the where condition is true.
• interpolate: If True, the boundary between fill regions will be interpolated.
• step: Defines the type of step for the filling ('pre', 'post', 'mid').
• **kwargs: Additional keyword arguments for customization (e.g., color, alpha, label).

Example: Filling the Area Between Two Curves

import matplotlib.pyplot as plt
import numpy as np

# Generate sample data
x = np.linspace(0, 5, 100)
y1 = x**2
y2 = x

# Fill the area between y1 and y2
plt.fill_between(x, y1, y2, color='skyblue', alpha=0.4, label='Filled Area')

# Plot the curves
plt.plot(x, y1, label='y=x^2')
plt.plot(x, y2, label='y=x')

# Add labels, title, and legend
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Fill Between Example')
plt.legend()

# Display the plot
plt.show()

Output:

This code generates an area plot with a sky-blue shaded region between the curves $y=x^2$ and $y=x$.

2. Creating a Stacked Area Plot Using stackplot()

The stackplot() function is used to create stacked area plots, where the areas of multiple datasets are stacked on top of each other.

Syntax:

plt.stackplot(x, *args, labels=(), colors=None, baseline='zero', alpha=1, **kwargs)

Key Parameters:

• x: X-coordinates of data points.
• *args: Y-coordinates for multiple datasets. Each argument should be a sequence of y-values corresponding to the x-values.
• labels: A list of labels for each dataset, used in the legend.
• colors: A list of custom colors for each dataset.
• baseline: Defines the stacking behavior. Can be 'zero' (default), 'sym' (symmetric), or a callable.
• alpha: Transparency level for the filled areas.
• **kwargs: Additional keyword arguments for customization.

Example: Creating a Stacked Area Plot

import matplotlib.pyplot as plt
import numpy as np

# Generate sample data
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.exp(-0.1 * x) * np.sin(x)

# Create a stacked area plot
plt.stackplot(x, y1, y2, y3, labels=['Sin(x)', 'Cos(x)', 'Exp(-0.1*x)*Sin(x)'], alpha=0.7)

# Add labels, title, and legend
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Stacked Area Plot Example')
plt.legend(loc='upper left')

# Display the plot
plt.show()

Output:

This code displays a stacked area plot, illustrating the cumulative contribution of three different functions over the x-axis.

3. Creating a Gradient-Filled Area Plot

By setting interpolate=True in fill_between(), you can create a smooth gradient-filled area plot.

Example: Filling the Area Under a Curve with a Gradient

import numpy as np
import matplotlib.pyplot as plt

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

# Fill the area under the curve with a gradient
plt.fill_between(x, y, color='purple', interpolate=True, alpha=0.6)

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

# Display the plot
plt.show()

Output:

This example shows a smooth gradient-filled area plot under a sine curve.

4. Creating a Percentage Stacked Area Plot

A percentage stacked area plot is useful for showing how the proportions of different categories change over time.

Example: Visualizing Energy Source Composition Over Time

import matplotlib.pyplot as plt

# Define years
years = [2010, 2012, 2014, 2016, 2018]

# Define percentage contributions of energy sources
coal = [40, 35, 30, 25, 20]
natural_gas = [30, 25, 20, 18, 15]
renewable_energy = [15, 20, 25, 30, 35]
nuclear = [15, 20, 25, 27, 30]

# Create a percentage stacked area plot
plt.stackplot(years, coal, natural_gas, renewable_energy, nuclear,
              labels=['Coal', 'Natural Gas', 'Renewable Energy', 'Nuclear'],
              colors=['#1f78b4', '#33a02c', '#a6cee3', '#fdbf6f'],
              alpha=0.7, baseline='zero')

# Add labels, title, and legend
plt.xlabel('Years')
plt.ylabel('Percentage of Total Energy Consumption')
plt.title('Energy Source Composition Over Time')
plt.legend(loc='upper left')

# Display the plot
plt.show()

Output:

This code generates a percentage stacked area plot that visualizes the changing composition of energy sources over several years.

5. Creating an Area Plot with Annotations

Annotations can be added to highlight specific points or trends within an area plot.

Example: Highlighting Key Points in a Monthly Sales Trend

import numpy as np
import matplotlib.pyplot as plt

# Simulate monthly sales data
months = np.arange(1, 13)
sales = np.array([10, 15, 12, 18, 25, 30, 28, 35, 32, 28, 20, 15])

# Create an area plot
plt.fill_between(months, sales, color='lightblue', alpha=0.7, label='Monthly Sales')

# Add annotations for significant points
plt.annotate('Sales Peak', xy=(8, 35), xytext=(9, 38),
             arrowprops=dict(facecolor='black', shrink=0.05),
             fontsize=9, ha='center')

plt.annotate('Lowest Sales', xy=(11, 20), xytext=(10, 23),
             arrowprops=dict(facecolor='black', shrink=0.05),
             fontsize=9, ha='center')

# Add labels, title, and legend
plt.xlabel('Months')
plt.ylabel('Sales (in units)')
plt.title('Monthly Sales Trend with Annotations')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.5)

# Display the plot
plt.show()

Output:

This example produces an area plot of monthly sales with annotations pointing to the peak and lowest sales periods.

Use Cases for Area Plots

• Time-Series Analysis: Visualizing trends over time, such as stock prices, temperature changes, or website traffic.
• Comparative Analysis: Showing cumulative contributions of multiple datasets, useful for understanding parts-to-whole relationships.
• Scientific and Engineering Applications: Representing experimental results, simulation outputs, and mathematical functions.
• Business and Financial Data: Tracking sales, revenue, expenses, and market trends.

Customization Options for Area Plots

• Color and Transparency: Modify fill colors and alpha values for visual clarity and emphasis.
• Line Styles and Markers: Customize the border lines and markers on the curves for enhanced detail.
• Grid and Background: Add grid lines or adjust background colors for better data alignment and readability.
• Logarithmic Scale: Utilize logarithmic scaling for axes when dealing with data that spans several orders of magnitude.

Bar Plot

A bar graph is a graphical representation of data using rectangular bars to compare different categories. The height or length of each bar corresponds to the value it represents. Matplotlib's bar() and barh() functions are versatile for creating various types of bar graphs.

1. Creating a Basic Vertical Bar Graph

The plt.bar() function creates vertical bars.

Syntax:

plt.bar(x, height, width=0.8, align='center', color=None, label=None, **kwargs)

Key Parameters:

• x: The x-coordinates of the bars (can be positions or category names).
• height: The heights of the bars.
• width: The width of the bars (default is 0.8).
• align: Alignment of the bars on the x-axis ('center' or 'edge').
• color: Custom color for the bars.
• label: Label for the bar group, used in the legend.
• **kwargs: Additional keyword arguments for customization.

Example: Creating a Basic Vertical Bar Graph

import matplotlib.pyplot as plt

# Define categories and values
categories = ['Category A', 'Category B', 'Category C']
values = [15, 24, 30]

# Create a vertical bar graph
plt.bar(categories, values, color='skyblue', edgecolor='black')

# Add labels and title
plt.xlabel('Categories')
plt.ylabel('Values')
plt.title('Basic Vertical Bar Graph')
plt.grid(axis='y', linestyle='--', alpha=0.5)

# Display the plot
plt.show()

Output:

This code displays a vertical bar graph showing the values for three distinct categories.

2. Creating a Horizontal Bar Graph

The plt.barh() function creates horizontal bars.

Syntax:

plt.barh(y, width, height=0.8, align='center', color=None, label=None, **kwargs)

Key Parameters:

• y: The y-coordinates of the bars (can be positions or category names).
• width: The lengths (widths) of the bars.
• height: The height of the bars.
• align: Alignment of the bars on the y-axis ('center' or 'edge').
• color: Custom color for the bars.
• label: Label for the bar group.
• **kwargs: Additional keyword arguments for customization.

Example: Creating a Horizontal Bar Graph

import matplotlib.pyplot as plt

# Define categories and values
categories = ['Category X', 'Category Y', 'Category Z']
values = [40, 28, 35]

# Create a horizontal bar graph
plt.barh(categories, values, color=['green', 'orange', 'blue'], edgecolor='grey')

# Add labels and title
plt.xlabel('Values')
plt.ylabel('Categories')
plt.title('Horizontal Bar Graph with Color Customization')
plt.grid(axis='x', linestyle='--', alpha=0.5)

# Display the plot
plt.show()

Output:

This code generates a horizontal bar graph with each bar colored differently.

3. Creating a Grouped Bar Graph

Grouped bar graphs are used to compare multiple datasets side-by-side for each category.

Example: Comparing Two Groups Using a Grouped Bar Graph

import matplotlib.pyplot as plt
import numpy as np

# Define categories and values for two groups
categories = ['Category A', 'Category B', 'Category C']
values1 = [15, 24, 30]
values2 = [20, 18, 25]

# Define bar width and positions
bar_width = 0.35
x_positions = np.arange(len(categories))

# Create grouped bar graph
plt.bar(x_positions - bar_width/2, values1, bar_width, label='Group 1', color='skyblue', edgecolor='black')
plt.bar(x_positions + bar_width/2, values2, bar_width, label='Group 2', color='orange', edgecolor='black')

# Add labels, title, and legend
plt.xlabel('Categories')
plt.ylabel('Values')
plt.title('Grouped Bar Graph')
plt.xticks(x_positions, categories) # Set category labels at the center of groups
plt.legend()
plt.grid(axis='y', linestyle='--', alpha=0.5)

# Display the plot
plt.show()

Output:

This example displays a grouped bar graph, allowing for a direct comparison of 'Group 1' and 'Group 2' across each category.

4. Creating a Stacked Bar Graph

Stacked bar graphs show how a total is divided into parts.

Example: Stacking Bars to Show Total Values

import matplotlib.pyplot as plt

# Define categories and values for two groups
categories = ['Category A', 'Category B', 'Category C']
values1 = [15, 24, 30]
values2 = [20, 18, 25]

# Create stacked bar graph
plt.bar(categories, values1, label='Group 1', color='skyblue', edgecolor='black')
plt.bar(categories, values2, bottom=values1, label='Group 2', color='orange', edgecolor='black') # Stack Group 2 on top of Group 1

# Add labels, title, and legend
plt.xlabel('Categories')
plt.ylabel('Values')
plt.title('Stacked Bar Graph')
plt.legend()
plt.grid(axis='y', linestyle='--', alpha=0.5)

# Display the plot
plt.show()

Output:

This code generates a stacked bar graph, illustrating the cumulative values of 'Group 1' and 'Group 2' for each category.

5. Dynamically Updating a Bar Graph

Matplotlib's animation module can be used to create dynamically updating bar graphs, often used to visualize real-time data or simulations.

Example: Animating Bar Heights in Real-Time

import numpy as np
from matplotlib import animation, pyplot as plt

# Set figure size for better visibility
plt.rcParams["figure.figsize"] = [7.50, 3.50]
plt.rcParams["figure.autolayout"] = True

# Create figure and axes
fig, ax = plt.subplots()

# Define initial data and colors
initial_heights = [1, 4, 3, 2, 6, 7, 3]
colors = ['red', 'yellow', 'blue', 'green', 'purple', 'orange', 'cyan']
bars = ax.bar(range(len(initial_heights)), initial_heights, facecolor='green', alpha=0.75)
ax.set_ylim(0, 10) # Set y-axis limit

# Function to update bar heights for animation
def animate(frame):
    # Randomly select a bar and update its height and color
    bar_index = np.random.randint(0, len(bars))
    new_height = np.random.randint(1, 10)
    bars[bar_index].set_height(new_height)
    bars[bar_index].set_facecolor(colors[np.random.randint(0, len(colors))])
    return bars # Return the iterable of artists updated

# Create animation
# frames=100 means the animation will run for 100 frames
# interval=200 means each frame will be displayed for 200 milliseconds
ani = animation.FuncAnimation(fig, animate, frames=100, interval=200, blit=False)

# Display the plot
plt.title('Dynamically Updating Bar Graph')
plt.show()

Output:

This code displays a bar graph where the heights and colors of the bars update dynamically over time, simulating real-time data changes.

Use Cases for Bar Graphs

• Comparative Analysis: Comparing sales, revenue, performance metrics, or counts across different categories.
• Time-Series Data: Tracking monthly, yearly, or quarterly trends in business or scientific data.
• Market Share Representation: Visualizing market share distribution among competitors.
• Survey Results: Displaying poll results, customer feedback, or demographic distributions.
• Frequency Distributions: Showing the frequency of occurrences for different data points.

Customization Options for Bar Graphs

• Color and Transparency: Modify bar colors (color) and alpha values for better visual distinction and readability.
• Bar Width and Alignment: Adjust width and align parameters to control the appearance and spacing of bars.
• Grid and Background: Add grid lines (plt.grid()) or adjust background colors for improved data alignment.
• Logarithmic Scale: Use logarithmic scaling for axes (plt.yscale('log') or plt.xscale('log')) when dealing with data spanning wide ranges.
• Edge Color and Line Style: Customize the edgecolor and linewidth of bars for added definition.
• Error Bars: Add error bars to represent uncertainty or variability in the data.