Summary  
This chapter covers two techniques for generating simple 2D plots in matplotlib: the procedural pyplot approach and the object-oriented approach using Figure and Axes objects. It shows how to call the plot() method on either the plt module or an Axes instance and then display the result.  

General domain of usage  
Data visualization

With an understanding of the `matplotlib` architecture, proceed to create the **first plot**. Two common methods for creating a plot are demonstrated:

* The **scripting** approach;
* The **object-oriented** approach, involving explicit instantiation of `Artist` objects.


## Scipting Approach

With this approach there is no need for you to explicitly create `Figure` and `Axes` object (it is done under the hood). 

In 2D space, each point has **x** and **y** coordinates. To plot it, import the `pyplot` submodule, use the `plt` alias, initialize `x` and `y` variables, and call the `plot()` function with `x` and `y` as arguments, along with `'o'` for the point marker.



Note

The plot is displayed with `plt.show()`:


import matplotlib.pyplot as plt
x = 5
y = 4
plt.plot(x, y, 'o')
plt.show()

## Object-oriented Approach

The only difference here is the use of the object-oriented approach: a `Figure` and `Axes` object are created using `subplots()`, and the `.plot()` method is called on the `Axes` object with the same arguments.


import matplotlib.pyplot as plt
x = 5
y = 4
fig, ax = plt.subplots()
ax.plot(x, y, 'o')
plt.show()

The following two lines are equivalent to `plt.plot()`.

Both options remain equivalent even when using other plotting functions instead of `plot()`. The course will mainly follow the **scripting approach**, though understanding both approaches is essential. Now, plot a point using the method of your choice.


import unittest
import importlib
from unittest.mock import patch
import user_code  # Assuming student's solution is in user_code.py


# Helper function to apply your dynamic assertion style
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_import_pyplot(self):
        condition = hasattr(user_code, "plt")
        _dynamic_test(
            self,
            condition,
            "matplotlib.pyplot is imported as plt.",
            "Expected matplotlib.pyplot to be imported as 'plt'."
        )

    def test_assign_x(self):
        x_value = getattr(user_code, "x", None)
        condition = x_value == 10
        _dynamic_test(
            self,
            condition,
            "Variable 'x' is correctly assigned to 10.",
            f"Expected variable 'x' to be 10, but got {x_value}."
        )

    def test_assign_y(self):
        y_value = getattr(user_code, "y", None)
        condition = y_value == 2
        _dynamic_test(
            self,
            condition,
            "Variable 'y' is correctly assigned to 2.",
            f"Expected variable 'y' to be 2, but got {y_value}."
        )

    def test_plot_called_with_correct_args(self):
        with patch("matplotlib.pyplot.plot") as mock_plot, patch("matplotlib.pyplot.show"):
            # Re-import module to trigger plotting code with patched functions
            importlib.reload(user_code)
            try:
                mock_plot.assert_called_with(10, 2, 'o')
                _dynamic_test(
                    self,
                    True,
                    "plt.plot() called with correct arguments (10, 2, 'o').",
                    ""
                )
            except AssertionError as e:
                _dynamic_test(
                    self,
                    False,
                    "",
                    f"plt.plot() was not called with (10, 2, 'o'): {str(e)}"
                )


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


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

Basic Plotting

Scipting Approach

Object-oriented Approach

Ratkaisu