diff --git a/_toc.yml b/_toc.yml index 9e3599416..160d0c1e4 100644 --- a/_toc.yml +++ b/_toc.yml @@ -43,6 +43,7 @@ parts: - file: core/matplotlib sections: - file: core/matplotlib/matplotlib + - file: core/matplotlib/matplotlib-additional-topics-1 - file: core/cartopy sections: - file: core/cartopy/cartopy diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb new file mode 100644 index 000000000..921097e74 --- /dev/null +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -0,0 +1,2348 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3d9564ec", + "metadata": {}, + "source": [ + "
\"Matplotlib
" + ] + }, + { + "cell_type": "markdown", + "id": "e9eb4444", + "metadata": {}, + "source": [ + "# Additional Topics Part 1: Histograms, Pie Charts, and Animation" + ] + }, + { + "cell_type": "markdown", + "id": "cba92e3a", + "metadata": {}, + "source": [ + "---\n", + "## Overview\n", + "\n", + "1. Histograms\n", + "1. Pie Charts\n", + "1. Animation" + ] + }, + { + "cell_type": "markdown", + "id": "56c73537", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "| Concepts | Importance | Notes |\n", + "| --- | --- | --- |\n", + "| [NumPy basics](../numpy/numpy-basics) | Necessary | |\n", + "| [Matplotlib basics](./matplotlib) | Necessary | |\n", + "\n", + "* **Time to Learn**: 30 minutes" + ] + }, + { + "cell_type": "markdown", + "id": "4440f2b1", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "0702fe7b", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "markdown", + "id": "148180d5", + "metadata": {}, + "source": [ + "The same as before, we are going to import matplotlib's `pyplot` interface as `plt`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d16d139c", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "7310773f", + "metadata": {}, + "source": [ + "## Histograms\n" + ] + }, + { + "cell_type": "markdown", + "id": "a5ea8056", + "metadata": {}, + "source": [ + "To make a 1D histogram, we're going to generate a single vector of numbers.\n", + "\n", + "We'll generate these numbers using NumPy's normal distribution random number generator. For demonstration purposes, we've specified the random seed for reproducability." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "df424130", + "metadata": {}, + "outputs": [], + "source": [ + "npts = 2500\n", + "nbins = 15\n", + "\n", + "np.random.seed(0)\n", + "x = np.random.normal(size=npts)" + ] + }, + { + "cell_type": "markdown", + "id": "32b9f3bd", + "metadata": {}, + "source": [ + "Finally, make a histogtam using `plt.hist`. Here, specifying `density=True` changes the y-axis to be probability instead of count. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dfd7c0cc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(x, bins=nbins, density=True)\n", + "plt.title('1D histogram')\n", + "plt.xlabel('Data')\n", + "plt.ylabel('Probability');" + ] + }, + { + "cell_type": "markdown", + "id": "84fb255f", + "metadata": {}, + "source": [ + "Similarly, we can make a 2D histrogram by generating a second random array and using `plt.hist2d`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4ed3325e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "y = np.random.normal(size=npts)\n", + "\n", + "plt.hist2d(x, y, bins=nbins);" + ] + }, + { + "cell_type": "markdown", + "id": "dd5a6bca", + "metadata": {}, + "source": [ + "## Pie Charts" + ] + }, + { + "cell_type": "markdown", + "id": "35bc61ba", + "metadata": {}, + "source": [ + "Matplotlib can also be used to plot pie charts with `plt.pie`. The most basic implementation is shown below. The input to `plt.pie` is a 1-D array of wedge \"sizes\" (e.g. percent values). " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9399feaa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.array([25, 15, 20, 40])\n", + "plt.pie(x);" + ] + }, + { + "cell_type": "markdown", + "id": "1cec2e20", + "metadata": {}, + "source": [ + "Typically, you'll see examples where all of the values in the array `x` will sum to 100, but the data provided to the pie chart does NOT have to add up to 100. Any numbers provided will be normalized to `sum(x)==1` by default, although this can be turned off by setting `normalize=False`.\n", + "\n", + "If you set `normalize=False` and the values of `x` do not sum to 1 AND are less than 1, a partial pie will be plotting. If the values sum to larger than 1, a `ValueError` will be raised." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "be883e4e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.array([0.25, 0.20, 0.40])\n", + "plt.pie(x, normalize=False);" + ] + }, + { + "cell_type": "markdown", + "id": "e747e452", + "metadata": {}, + "source": [ + "Let's do a more complicated example.\n", + "\n", + "Here we create a pie chart with various sizes associated with each color. Labels are derived by capitalizing each color in the array `colors`.\n", + "\n", + "More interesting is the `explode` input, which allows you to offset each wedge by a fraction of the radius. In this example, each wedge is not offset except for the pink (3rd index)." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fa9ecaec", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "colors = ['red', 'blue', 'yellow', 'pink', 'green']\n", + "labels = [c.capitalize() for c in colors]\n", + "\n", + "sizes = [1, 3, 5, 7, 9]\n", + "explode = (0, 0, 0, 0.1, 0)\n", + "\n", + "\n", + "plt.pie(sizes, labels=labels, explode=explode, colors=colors, autopct='%1.1f%%');" + ] + }, + { + "cell_type": "markdown", + "id": "c516ce4b", + "metadata": {}, + "source": [ + "## Animation" + ] + }, + { + "cell_type": "markdown", + "id": "46c1acfc", + "metadata": {}, + "source": [ + "From matplotlib's animation interface, there is one main tool, `FuncAnimation`. See matplotlib's full animation documentation [here](https://matplotlib.org/stable/api/animation_api.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3879e346", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.animation import FuncAnimation" + ] + }, + { + "cell_type": "markdown", + "id": "a31e17ed", + "metadata": {}, + "source": [ + "`FuncAnimation` creates animations by repeatedly calling a function. Using this method involves three main steps:\n", + "\n", + "1. Create an initial state of the plot\n", + "1. Make a function that can \"progress\" the plot to the next frame of the animation\n", + "1. Create the animation using FuncAnimation" + ] + }, + { + "cell_type": "markdown", + "id": "e1abc210", + "metadata": {}, + "source": [ + "For this example, let's create an animated sine wave." + ] + }, + { + "cell_type": "markdown", + "id": "5455b9de", + "metadata": {}, + "source": [ + "### Step 1: Initial State\n", + "In the initial state step, we will define a function called `init` that will define the initial state of the animation plot. Note that this function is technically optional. An example later will omit this explicit initialization step. " + ] + }, + { + "cell_type": "markdown", + "id": "1037bb3b", + "metadata": {}, + "source": [ + "First, we'll define a figure and axes, then create a line with `plt.plot`. To create the initialization function, we set the line's data to be empty and then return the line.\n", + "\n", + "Note that this cell will display empty axes in jupyter notebooks." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3feef13d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_xlim(0, 2 * np.pi)\n", + "ax.set_ylim(-1.5, 1.5)\n", + "\n", + "(line,) = ax.plot([], [])\n", + "\n", + "\n", + "def init():\n", + " line.set_data([], [])\n", + " return (line,)" + ] + }, + { + "cell_type": "markdown", + "id": "679981fb", + "metadata": {}, + "source": [ + "### Step 2: Animation Progression Function\n", + "For each frame in the animation, we need to create a function that takes an index and returns the desired frame in the animation. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c5b606e2", + "metadata": {}, + "outputs": [], + "source": [ + "def animate(i):\n", + "\n", + " x = np.linspace(0, 2 * np.pi, 250)\n", + "\n", + " y = np.sin(2 * np.pi * (x - 0.1 * i))\n", + "\n", + " line.set_data(x, y)\n", + "\n", + " return (line,)" + ] + }, + { + "cell_type": "markdown", + "id": "6ef0f128", + "metadata": {}, + "source": [ + "### Step 3: Using `FuncAnimation`\n", + "The last step is to feed the parts we created to `FuncAnimation`. Note that when using this function, it is important to save the output to a variable, even if you do not intent to use it later, because otherwise it is at risk of being collected by Python's garbage collector." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8ecb3760", + "metadata": {}, + "outputs": [], + "source": [ + "anim = FuncAnimation(fig, animate, init_func=init, frames=200, interval=20, blit=True)" + ] + }, + { + "cell_type": "markdown", + "id": "cbc69df4", + "metadata": {}, + "source": [ + "To show the animation in this jupyter notebook, we need to set the rc parameter for animation to `html5`, instead of the default, which is none." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b464c460", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from matplotlib import rc\n", + "\n", + "rc('animation', html='html5')\n", + "\n", + "anim" + ] + }, + { + "cell_type": "markdown", + "id": "8be86c41-2ac0-4385-8b3f-70cf0139b19e", + "metadata": {}, + "source": [ + "### Saving an Animation\n", + "\n", + "To save an animation, use `anim.save()` as shown below. The inputs are teh file location (`animate.gif`) and the writer used to save the file. Here the animation writer chosen is Pillow, a library for image processing in Python." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6a1693bd", + "metadata": {}, + "outputs": [], + "source": [ + "anim.save('animate.gif', writer='pillow');" + ] + }, + { + "cell_type": "markdown", + "id": "85b884b1-4db7-4d9d-9563-79750dbcfc67", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "076b1bf3", + "metadata": {}, + "source": [ + "## Summary\n", + "* `matplotlib` supports additional plot types. Here we covered histograms and scatter plots.\n", + "* You can animate your plots.\n", + "\n", + "\n", + "## What's Next\n", + "[More plotting functionality](additional-topics-2) such as annotations, equation rendering, and colormaps.\n", + "\n", + "## Additional Resources\n", + "- [Plot Types Cheat Sheet](https://lnkd.in/dD5fE8V)\n", + "- [Matplotlib Documentation: Basic Pie Charts](https://matplotlib.org/stable/gallery/pie_and_polar_charts/pie_features.html)\n", + "- [Matplotlib Documentation: Histograms](https://matplotlib.org/stable/gallery/statistics/hist.html)" + ] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/core/matplotlib/matplotlib.ipynb b/core/matplotlib/matplotlib.ipynb index 40cb2f4c8..d88212b7a 100644 --- a/core/matplotlib/matplotlib.ipynb +++ b/core/matplotlib/matplotlib.ipynb @@ -832,7 +832,7 @@ "metadata": {}, "source": [ "## What's Next?\n", - "In the next notebook, we will cover more plotting functionality such as histograms, pie charts, and animation" + "[More plotting functionality](matplotlib-additional-topics-1) such as histograms, pie charts, and animation." ] }, { diff --git a/environment.yml b/environment.yml index b9acbeb4e..3f6318405 100644 --- a/environment.yml +++ b/environment.yml @@ -15,6 +15,7 @@ dependencies: - pythia-datasets - python=3.8 - scipy + - ffmpeg - sqlalchemy<1.4 - xarray - pip: