Summary
This chapter explains how to overlay multiple line plots on a single set of axes in Matplotlib—by calling plt.plot() repeatedly, by passing multiple series to a single plt.plot() call, or by plotting an entire DataFrame at once.

General domain of usage
Data visualization

Often, it's necessary to create multiple line plots on a single `Axes` object to compare different trends or patterns. This can be done in two main ways. Here's the first approach.

Here is a sample of average yearly temperatures (in $$\degree$$F) of **Seattle** and **Boston**:

import pandas as pd
url = 'https://content-media-cdn.codefinity.com/courses/47339f29-4722-4e72-a0d4-6112c70ff738/weather_data.csv'
# Loading the dataset with the average yearly temperatures in Boston and Seattle
weather_df = pd.read_csv(url, index_col=0)
print(weather_df.head())

Two line plots will be used to compare data from **Seattle** and **Boston**.

## First Option

Call `plot()` **twice** to draw two separate line plots on the same `Axes`.
The **Series indices** (years) automatically become the x-axis values for both lines.

import matplotlib.pyplot as plt
import pandas as pd
weather_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/47339f29-4722-4e72-a0d4-6112c70ff738/weather_data.csv', index_col=0)
# Calling the plot() function for each of the line plots
plt.plot(weather_df['Boston'], '-o')
plt.plot(weather_df['Seattle'], '-o')
plt.show()

## Second Option

Here `plot()` is called **once**. Because **both series have markers**, `matplotlib` treats them as **two separate plots**, again using their indices for the x-axis.

If no markers are given, `plot()` draws **only one line**, using the **first Series as x** and the **second as y**.

import matplotlib.pyplot as plt
import pandas as pd
weather_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/47339f29-4722-4e72-a0d4-6112c70ff738/weather_data.csv', index_col=0)
# Calling the plot() function once for two line plots
plt.plot(weather_df['Boston'], '-o', weather_df['Seattle'], '-o')
plt.show()

## Third Option

You can also pass the entire DataFrame to `plot()`.
Each **column** becomes a separate line, and the DataFrame’s **index** is used for the x-axis.
This is a quick way to visualize multiple time series or features without calling `plot()` repeatedly.


import matplotlib.pyplot as plt
import pandas as pd
weather_df = pd.read_csv('https://content-media-cdn.codefinity.com/courses/47339f29-4722-4e72-a0d4-6112c70ff738/weather_data.csv', index_col=0)
# Calling the plot() function for whole DataFrame
plt.plot(weather_df, '-o')
plt.show()


Feel free to explore even more about line plots with <a href="https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html" target="_blank"><svg width="1em" height="1em" viewBox="0 0 30 32" fill="none" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#098f67" style="stroke: var(--color1, #098f67)" stroke-linejoin="miter" stroke-linecap="round" stroke-miterlimit="4" stroke-width="2.4156" d="M17.289 17.305v0c-1.754 1.754-4.597 1.754-6.351 0l-7.76-7.759c-1.755-1.755-1.755-4.601 0-6.356v0c1.753-1.753 4.595-1.756 6.351-0.005l6.208 6.187"></path><path fill="none" stroke="#098f67" style="stroke: var(--color1, #098f67)" stroke-linejoin="miter" stroke-linecap="round" stroke-miterlimit="4" stroke-width="2.4156" d="M12.504 13.97v0c1.754-1.754 4.597-1.754 6.351 0l7.762 7.762c1.754 1.754 1.754 4.597 0 6.351v0c-1.754 1.754-4.597 1.754-6.351 0l-5.953-5.953"></path></svg> <code>plot()</code></a> function documentation.

Study More

import unittest
from unittest.mock import patch
import importlib
import user_code  # User's solution file


# Helper for clean pass/fail messages
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    def test_plot_called_twice(self):
        with patch("matplotlib.pyplot.plot") as mock_plot:
            importlib.reload(user_code)
            condition = mock_plot.call_count == 2
            _dynamic_test(
                self,
                condition,
                "`plt.plot()` is called twice.",
                f"Expected `plt.plot()` to be called twice, but it was called {mock_plot.call_count} time(s)."
            )

    def test_first_plot_with_data_linear(self):
        with patch("matplotlib.pyplot.plot") as mock_plot:
            importlib.reload(user_code)
            args = mock_plot.call_args_list[0][0] if mock_plot.call_args_list else []
            expected = getattr(user_code, 'data_linear', None)
            condition = len(args) == 1 and (args[0] == expected).all()
            _dynamic_test(
                self,
                condition,
                "`plt.plot()` is first called with `data_linear`.",
                f"First call to `plt.plot()` was not with `data_linear`, got {args}."
            )

    def test_second_plot_with_data_squared_and_format(self):
        with patch("matplotlib.pyplot.plot") as mock_plot:
            importlib.reload(user_code)
            args = mock_plot.call_args_list[1][0] if len(mock_plot.call_args_list) > 1 else []
            expected = getattr(user_code, 'data_squared', None)
            condition = (
                len(args) == 2 and
                (args[0] == expected).all() and
                args[1] == '-o'
            )
            _dynamic_test(
                self,
                condition,
                "`plt.plot()` is second called with `data_squared` and '-o'.",
                f"Second call to `plt.plot()` did not use `data_squared` or '-o', got {args}."
            )


if __name__ == '__main__':
    unittest.main()


test_multiple_line_plots.py

Learn how to explore and communicate data through visual analysis. The course covers creating common plots, customizing visualizations, and using statistical charts to examine data distributions, relationships, and patterns. Exploratory data analysis techniques are applied to identify trends, anomalies, and insights in real-world datasets.

Multiple Line Plots

First Option

Second Option

Third Option

Soluzione