Summary  
This chapter introduces how to implement code to create simple 2D plots using both the stateful scripting API and the object-oriented API of a plotting library.

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

Master the foundational skills of data visualization using the object-oriented approach in Matplotlib. Learn to control every aspect of your figures, from axes and legends to colors and styles. Create professional-quality static charts, handle time-series data, and export high-resolution graphics for reports and publications.

Basic Plotting

Scipting Approach

Object-oriented Approach

解答