Summary  
This chapter explains how to generate line plots with matplotlib’s plot() function by providing one or two arrays (or pandas Series) to visualize numeric relationships, including customizing line and marker styles and using automatic x-axis indexing when only y-values are supplied.

General domain of usage  
Data visualization

## Applications

**Line plot** is used to depict the relationship between two variables (e.g. **x**, **y**) using straight lines. More formally, it shows the relationship between **continuous** or **ordinal** variables in a continuous data point manner. Moreover, it can show how a certain variable changes with time.

## Creating a Line Plot

Use the familiar `plot()` function from `pyplot` to create line plots. Here's an example that displays a quadratic relationship between two variables:


import matplotlib.pyplot as plt
import numpy as np

data_linear = np.arange(0, 6)
data_squared = data_linear ** 2

# Creating a line plot with specifying x and y
plt.plot(data_linear, data_squared, '-o')
plt.show()

In fact, this code can even be further simplified. Have a look at another example:

import matplotlib.pyplot as plt
import numpy as np
data_squared = np.arange(0, 6) ** 2
# Creating a line plot using only one array
plt.plot(data_squared, '-o')
plt.show()

When only one array (or `pandas.Series()`) like `data_squared` is passed to the `plot()` function, `matplotlib` uses the array values for the y-axis. The x-axis is automatically generated using the element indices — in this case, the numbers from 0 to 5.


import unittest
from unittest.mock import patch
import importlib
import numpy as np

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_plot_function_is_used(self):
        with patch('matplotlib.pyplot.plot') as mock_plot:
            importlib.reload(importlib.import_module("user_code"))
            _dynamic_test(
                self,
                mock_plot.called,
                "`plot()` is used to create the line plot.",
                "`plot()` is not used â make sure to call `plt.plot()`."
            )

    def test_plot_arguments_order(self):
        with patch('matplotlib.pyplot.plot') as mock_plot:
            import user_code
            importlib.reload(importlib.import_module("user_code"))
            x_data = getattr(user_code, 'x_data', None)
            y_data = getattr(user_code, 'y_data', None)

            correct_order = False
            if mock_plot.called:
                args, kwargs = mock_plot.call_args
                correct_order = (
                    np.array_equal(args[0], x_data) and
                    np.array_equal(args[1], y_data)
                )

            _dynamic_test(
                self,
                correct_order,
                "`plot()` is called with `x_data` as x-axis and `y_data` as y-axis in correct order.",
                "`plot()` must be called with `x_data` (x-axis) and `y_data` (y-axis) in correct order."
            )

    def test_plot_style_argument(self):
        with patch('matplotlib.pyplot.plot') as mock_plot:
            importlib.reload(importlib.import_module("user_code"))
            correct_style = False
            if mock_plot.called:
                args, kwargs = mock_plot.call_args
                correct_style = len(args) >= 3 and args[2] == '-o'

            _dynamic_test(
                self,
                correct_style,
                "`plot()` is called with correct style ('-o' - markers and lines).",
                "`plot()` is called with incorrect style."
            )

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


test_line.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.

Line Plot

Applications

Creating a Line Plot

Oplossing