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

Met een begrip van de `matplotlib`-architectuur kun je nu de **eerste plot** maken. Twee gangbare methoden voor het creëren van een plot worden gedemonstreerd:

* De **scripting**-benadering;
* De **objectgeoriënteerde** benadering, waarbij expliciet `Artist`-objecten worden geïnstantieerd.


## Scripting-benadering

Bij deze benadering is het niet nodig om expliciet een `Figure`- en `Axes`-object aan te maken (dit gebeurt automatisch op de achtergrond).

In een 2D-ruimte heeft elk punt **x**- en **y**-coördinaten. Om dit te plotten, importeer je de submodule `pyplot`, gebruik je het alias `plt`, initialiseer je de variabelen `x` en `y`, en roep je de functie `plot()` aan met `x` en `y` als argumenten, samen met `'o'` voor de puntmarkering.



De volgorde van de argumenten is belangrijk!

Opmerking

De plot wordt weergegeven met `plt.show()`: 


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

## Objectgeoriënteerde benadering

Het enige verschil hier is het gebruik van de objectgeoriënteerde benadering: een `Figure`- en `Axes`-object worden aangemaakt met `subplots()`, en de `.plot()`-methode wordt aangeroepen op het `Axes`-object met dezelfde argumenten.


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

De volgende twee regels zijn gelijkwaardig aan `plt.plot()`.

Beide opties blijven gelijkwaardig, zelfs wanneer andere plotfuncties dan `plot()` worden gebruikt. In deze cursus wordt voornamelijk de **scripting-benadering** gevolgd, hoewel het belangrijk is beide benaderingen te begrijpen. Plot nu een punt met de methode van jouw keuze.


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

Beheers de fundamentele vaardigheden van datavisualisatie met behulp van de objectgeoriënteerde benadering in Matplotlib. Leer volledige controle uit te oefenen over elk aspect van uw figuren, van assen en legenda's tot kleuren en stijlen. Maak statische grafieken van professionele kwaliteit, verwerk tijdreeksgegevens en exporteer afbeeldingen met hoge resolutie voor rapporten en publicaties.

Basisplotten

Scripting-benadering

Objectgeoriënteerde benadering

Oplossing