{
"cells": [
{
"cell_type": "markdown",
"id": "47b9e4bd",
"metadata": {},
"source": [
"# A.4 The `matplotlib` package for visualization"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "29e67373",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": [
"remove-input"
]
},
"outputs": [],
"source": [
"import numpy as np\n",
"from myst_nb import glue\n",
"%config InlineBackend.rc = {'figure.dpi': 300}\n",
"%config InlineBackend.figure_format = 'svg'"
]
},
{
"cell_type": "markdown",
"id": "fd67ca8a",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
"## Basic graphs\n",
"\n",
" The main package for plotting in Python is called `matplotlib`. It is a comprehensive plotting package that is highly versatile and can be used to make fantastic plots and animations. The [gallery on the `matplotlib` web page](https://matplotlib.org/stable/gallery/index.html) is a great resource to discover many of the `matplotlib` capabilities.\n",
"
Most of `matplotlib`’s plotting capabilities are available in the subpackage `pyplot`, which is commonly renamed as `plt` in the Python community. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "411bd4df",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"id": "ba075881-08ae-419e-b182-19c14f7edc6d",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
"Figures are shown inline in a notebook by default (rather than in a separate window). The following two lines of code compute $\\sin(x)$ for 100 values of $x$ between 0 and $\\pi$, and then plot $\\sin(x)$ vs. $x$."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "d7004e53",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": [
"remove-output"
]
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = np.linspace(0, np.pi, 100)\n",
"plt.plot(x, np.sin(x));"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "6de5076d",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": [
"remove-output",
"remove-input"
]
},
"outputs": [
{
"data": {
"application/papermill.record/image/svg+xml": "\n\n\n",
"application/papermill.record/text/plain": ""
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "fig-sin"
}
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(4, 2.5))\n",
"plt.plot(x, np.sin(x))\n",
"glue(\"fig-sin\", fig, display=False)"
]
},
{
"cell_type": "markdown",
"id": "4231229a",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
"```{glue:figure} fig-sin\n",
":name: fig_sin_A.4\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "9908d028",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
" The plot function has many, many options, as may be seen from the documentation. A more complex graph with multiple lines, labels along the axes, and a legend is shown below. `matplotlib` uses a different color for each line that is plotted. The default colors are called `C0`, `C1`, `C2`, etc. Alternatively, a different color can be specified."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "ed5c95ea",
"metadata": {
"tags": [
"remove-output"
]
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x = np.linspace(0, 2 * np.pi, 200)\n",
"y1 = np.sin(x)\n",
"y2 = np.cos(x)\n",
"plt.plot(x, y1, '--', label='sin(x)') # plotted with default color C0\n",
"plt.plot(x, y2, color='purple', lw=2, label='cos(x)') # linewidth (lw) is 2\n",
"plt.xlabel('x-axis')\n",
"plt.ylabel('y-axis')\n",
"plt.legend(); # selects best spot for legend unless loc is specified"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "f2b9ef3c",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [
{
"data": {
"application/papermill.record/image/svg+xml": "\n\n\n",
"application/papermill.record/text/plain": ""
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "fig-sin-cos"
}
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(4, 2.5))\n",
"plt.plot(x, y1, '--', label='sin(x)') # plotted with default color C0\n",
"plt.plot(x, y2, color='purple', lw=2, label='cos(x)') # linewidth (lw) is 2\n",
"plt.xlabel('x-axis')\n",
"plt.ylabel('y-axis')\n",
"plt.legend(); # selects best spot for legend unless loc is specified\n",
"glue(\"fig-sin-cos\", fig, display=False)"
]
},
{
"cell_type": "markdown",
"id": "7505b529",
"metadata": {},
"source": [
"```{glue:figure} fig-sin-cos\n",
":name: fig_sin_cos_A.4\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "bc0c18bc",
"metadata": {},
"source": [
" Most `matplotlib` functions return a handle to the plot item that is created. For example, the `plt.plot` function returns a list with a handle to the line that is plotted"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "a1f7c56b",
"metadata": {
"tags": [
"remove-output"
]
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]\n"
]
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"a = plt.plot([1, 2, 3], label='hello')\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "eac89b98",
"metadata": {
"tags": [
"remove-input"
]
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "d4701ba0",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [
{
"data": {
"application/papermill.record/image/svg+xml": "\n\n\n",
"application/papermill.record/text/plain": ""
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "fig-plot-hello"
}
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(4, 2.5))\n",
"plt.plot([1, 2, 3], label='hello')\n",
"glue(\"fig-plot-hello\", fig, display=False)"
]
},
{
"cell_type": "markdown",
"id": "e90f333e",
"metadata": {},
"source": [
"```{glue:figure} fig-plot-hello\n",
":name: fig_plot_hello_A.4\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "25e6c721",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
"The cryptic statement such as `[]` is a list with a handle to the memory location of the line that was plotted. For example, the command `plt.xlabel` adds a text object and returns a handle to this object. The properties of the item that the handle refers to can be modified with the `plt.setp` command (although this is not done frequently in this book). In the following example, the `setp` function is used to increase the line width and color of the plotted line."
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "f6b9114d",
"metadata": {
"tags": [
"remove-output"
]
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"a = plt.plot([1, 2, 3])\n",
"plt.setp(a, color='hotpink', lw=4);"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "15c59648",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [
{
"data": {
"application/papermill.record/image/svg+xml": "\n\n\n",
"application/papermill.record/text/plain": ""
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "fig-plot-setp"
}
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(4, 2.5))\n",
"a = plt.plot([1, 2, 3])\n",
"plt.setp(a, color='hotpink', lw=4);\n",
"glue(\"fig-plot-setp\", fig, display=False)"
]
},
{
"cell_type": "markdown",
"id": "eb448ba8",
"metadata": {},
"source": [
"```{glue:figure} fig-plot-setp\n",
":name: fig_plot_setp_A.4\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "bc2fb5d4",
"metadata": {},
"source": [
" Figures can be saved to a file using `plt.savefig(’/mydirectory/myfigure1.png’)` where `mydirectory` is the directory name. Forward slashes must be used to separate directory names. The file type is inferred from the file extension (png, eps, and svg)."
]
},
{
"cell_type": "markdown",
"id": "688c4ea3",
"metadata": {},
"source": [
"## Contour plots\n",
"\n",
" Two-dimensional data can be visualized with a contour plot. For example, consider the following function for the head $h$ as a function of the horizontal coordinates $x$ and $y$\n",
"\n",
"$$\n",
"h = \\frac{2}{\\pi}\\ln\\left( x^2 + y^2 \\right) -0.01x - 5\n",
"$$\n",
"\n",
"A contour plot of the head is created in a window with lower-left corner $(x, y) = (−200,−200)$ and upper-right corner $(x, y) = (400, 200)$. A grid of $(x, y)$ values is defined first using the `np.meshgrid` function, which creates the two-dimensional arrays `x` and `y`. The head is computed at each $(x, y)$ location. Before contouring, a figure is created with `plt.subplot` and using the keyword `aspect=1` to make sure that the horizontal and vertical axes have the same scale (so that a circle looks like a circle rather than an ellipse). The head values are contoured with the `plt.contour` function; 20 head values are contoured."
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "a8e6d659",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": [
"remove-output"
]
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"x, y = np.meshgrid(np.linspace(-200, 400, 100), np.linspace(-200, 200, 100))\n",
"h = 2 / np.pi * np.log(x ** 2 + y ** 2) - 0.01 * x - 5\n",
"plt.subplot(111, aspect=1)\n",
"plt.contour(x, y, h, 20); # draw 20 contour lines"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "783609f8",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": [
"remove-cell"
]
},
"outputs": [
{
"data": {
"application/papermill.record/image/svg+xml": "\n\n\n",
"application/papermill.record/text/plain": ""
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "fig-contour"
}
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(4, 2.5))\n",
"x, y = np.meshgrid(np.linspace(-200, 400, 100), np.linspace(-200, 200, 100))\n",
"h = 2 / np.pi * np.log(x ** 2 + y ** 2) - 0.01 * x - 5\n",
"plt.subplot(111, aspect=1)\n",
"plt.contour(x, y, h, 20); # draw 20 contour lines\n",
"glue(\"fig-contour\", fig, display=False)"
]
},
{
"cell_type": "markdown",
"id": "1ddd95cc",
"metadata": {},
"source": [
"```{glue:figure} fig-contour\n",
":name: fig_contour_A.4\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "06a97073",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
" The head values that are contoured can be specified with a list or an array. First, the minimum and maximum values of the computed head are found with the `np.min` and `np.max` functions."
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "d57129e0",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"min: -4.1046611143428455\n",
"max: 4.18729839195133\n"
]
}
],
"source": [
"print('min:', np.min(h))\n",
"print('max:', np.max(h))"
]
},
{
"cell_type": "markdown",
"id": "5abe3e19",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
"The head is contoured for values from -3 m up to 6 m with steps of 0.5 m (you don't have to be very precise with the min and max; values for which no contour exists will be skipped). The handle that is returned by the `plt.contour` function is stored and passed to the `plt.clabel` function to plot labels along the contours. The format of the labels is specified as `fmt='%.1f'`, which stands for floating point numbers with 1 decimal place."
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "36ecb6f1",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": [
"remove-output"
]
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.subplot(111, aspect=1)\n",
"cs = plt.contour(x, y, h, np.arange(-3, 6, 0.5), colors='C0')\n",
"plt.clabel(cs, fmt='%.1f');"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "53089507",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [
{
"data": {
"application/papermill.record/image/svg+xml": "\n\n\n",
"application/papermill.record/text/plain": ""
},
"metadata": {
"scrapbook": {
"mime_prefix": "application/papermill.record/",
"name": "fig-contour-labels"
}
},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"fig = plt.figure(figsize=(4, 2.5))\n",
"plt.subplot(111, aspect=1)\n",
"cs = plt.contour(x, y, h, np.arange(-3, 6, 0.5), colors='C0')\n",
"plt.clabel(cs, fmt='%.1f')\n",
"glue(\"fig-contour-labels\", fig, display=False)"
]
},
{
"cell_type": "markdown",
"id": "e65af480",
"metadata": {},
"source": [
"```{glue:figure} fig-contour-labels\n",
":name: fig_contour_labels_A.4\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "5f749021",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
" The color of all contour lines is specified as `colors=’C0’`, and the contour lines for negative values are, by default, dashed. This latter behavior can be overridden by specifying the keyword argument `linestyles='-'` of `plt.contour` or by changing the value of the default `matplotlib` parameter `contour.negative_linestyle` (see the `matplotlib` documentation)."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.13.7"
}
},
"nbformat": 4,
"nbformat_minor": 5
}