From 5d7358e696e17b0660a7861905852d9fc4bd7873 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 14 Oct 2021 14:05:34 -0600 Subject: [PATCH 01/16] up to animation included --- _toc.yml | 1 + core/matplotlib/more-matplotlib.ipynb | 369 ++++++++++++++++++++++++++ 2 files changed, 370 insertions(+) create mode 100644 core/matplotlib/more-matplotlib.ipynb diff --git a/_toc.yml b/_toc.yml index 156c0c7c2..81ae1bb2d 100644 --- a/_toc.yml +++ b/_toc.yml @@ -36,6 +36,7 @@ parts: - file: core/matplotlib sections: - file: core/matplotlib/matplotlib + - file: core/matplotlib/animating-with-matplotlib - file: core/cartopy sections: - file: core/cartopy/cartopy diff --git a/core/matplotlib/more-matplotlib.ipynb b/core/matplotlib/more-matplotlib.ipynb new file mode 100644 index 000000000..d32c0a7fc --- /dev/null +++ b/core/matplotlib/more-matplotlib.ipynb @@ -0,0 +1,369 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0d9101ce-fe22-4708-b2bb-272f7de7689a", + "metadata": {}, + "source": [ + "
\"Matplotlib
" + ] + }, + { + "cell_type": "markdown", + "id": "58f82a4c-99b2-4434-bd0e-601506d80bf2", + "metadata": {}, + "source": [ + "# More Matplotlib" + ] + }, + { + "cell_type": "markdown", + "id": "f9acd874-04a8-4c90-90d3-a312325dc0c1", + "metadata": {}, + "source": [ + "---\n", + "## Overview\n", + "We will cover creating more advanced plots with the Matplotlib library.\n", + "\n", + "1. Create a histogram\n", + "1. Create a pie chart\n", + "1. Create and save an animated plot" + ] + }, + { + "cell_type": "markdown", + "id": "0af21ea8-8ae1-492c-8d1d-3b85705cb08a", + "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": "eedd472e-cfa1-40c4-9e04-df945bc08251", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "ca47660b-738e-4309-b6dc-3ef8061ed38e", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "markdown", + "id": "bd8908c3-6205-4a02-8ff0-17402a85f784", + "metadata": {}, + "source": [ + "The same as before, we are going to import matplotlib's `pyplot` interface as `plt`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "aa52a857-80de-46c8-9ea9-38aec508cc18", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "dac8e38d-d364-4e63-94f8-78748bd10f32", + "metadata": {}, + "source": [ + "## Histograms\n" + ] + }, + { + "cell_type": "markdown", + "id": "b4b83329-89c5-4ce7-a05f-fa5075e80c63", + "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": "3c4d00bc-004f-4674-98ea-5d3beef9397b", + "metadata": {}, + "outputs": [], + "source": [ + "npts = 2500\n", + "nbins = 15\n", + "\n", + "# Generate random points from a normal distribution\n", + "np.random.seed(0)\n", + "x = np.random.normal(size=npts)" + ] + }, + { + "cell_type": "markdown", + "id": "f46dc699-2acb-4586-adef-44c33595dad7", + "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": "430a0ffb-5a15-4e5f-b670-d9c1db50cd94", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Make histogram\n", + "plt.hist(x, bins=nbins, density=True)\n", + "plt.title('1D histogram')\n", + "plt.xlabel('Data')\n", + "plt.ylabel('Probability');" + ] + }, + { + "cell_type": "markdown", + "id": "8bad0231-3ac8-4ee3-b3f8-b3b69b2bb436", + "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": "1ace046d-8733-4936-9122-8e3866014e43", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Generate a second random array\n", + "y = np.random.normal(size=npts)\n", + "\n", + "# Make a 2D histogram\n", + "plt.hist2d(x, y, bins=nbins);" + ] + }, + { + "cell_type": "markdown", + "id": "2c99884c-8746-418b-aa3e-07394d39dc69", + "metadata": {}, + "source": [ + "## Pie Charts" + ] + }, + { + "cell_type": "markdown", + "id": "2c517ba4-02ec-4f8a-af77-c0835f10c34a", + "metadata": {}, + "source": [ + "Matplotlib can also be used to plot pie charts with `plt.pie`. The most basic implementation is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cb5c36c3-3664-4a94-81dc-1f4edd3ae999", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAU2UlEQVR4nO3de3RcZb3G8e/OJE2atkzatCFprusIJVsZLBSxJW3DTYEVOVDhHISlFD2ACuo5srQEb8wRwegRy0VupVgjAnJAgWK8naXSKxcpSIeyB5E2LXdaSm+UXrJnnz/2BEJN2lxm9u/de36ftbK6Cu28T7v65N0z797va3meh1LKPEXSAZRS/dNyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShtJyKmUoLadShiqWDqAOIBkfBzQCDX2+GoF6YBxQ0vvV4xXtPGT3L+JAT/ZrL/A28BrwKvBKPz++3t3R5gb5R1KDY+lBRoZIxquAWUALcAjvFbJisC+R8azN/7L7zglDHNkFngOeAFZlv/7W3dH29hBfR+WYllNKMt6EX8bZ2R8PG+lLDrOc/b4UkOa9wi7r7mh7Kgevq4ZAyxmUZPwDwEm8V8b6XA+Rw3L250XgN8Bi4M/dHW178jSOytJy5lMyPh44GzgPmJHv4fJczr62A3/EL2pXd0fbmwGMWXC0nLmWjBcDp+IX8jSgNKihAyxnXy7wZ+AW4EH9cCl3tJy5kowfhV/Ic4AqiQhC5ezrJeA2YEF3R9trgjkiQcs5Esl4CTAX+AqQEE5jQjl77QXuB27q7mhbIh0mrLScw5GMlwEXAPPIwwc7w2VQOftaA/wPcEd3R1tGOkyYaDmHwi/lxcDXgWrhNP/E0HL2egb4ZndH22LpIGGh5RyMZDwGnA8kgTrRLPtheDl7rQDauzvalksHMZ2W80CS8TnAVYAtHeVAQlLOXl3A5d0dbSnpIKbScg4kGa8HFgIfl44yWCErJ/h3It0BXNrd0bZZOoxp9KmU/iTjF+C/RwpNMUOqCP/T7meb2rvOEM5iHJ05+0rG6/DX6U6RjjIcIZw593UX8GWdRX06c/ZKxj+HP1uGspgRcS46i75LZ85kvBZ/tjxVOspIRWDm7KvgZ9HCnjmT8c/gL5KHvpgRdC7wTFN713TpIFIKs5zJeBHJ+I+AnwNx6ThqQDXAw03tXedJB5FQeJe1yXg58AtgjnSUXIvYZe2+fgzMK6SnXgpr5kzGa4AlRLCYBeBSoKupvatCOkhQCqecyfgRwGPA0dJR1LCdDDzW1N414i1dwqAwypmMnwosx6AnSNSwTcEv6EnSQfIt+uVMxi8BHsLfRlJFQxz4TVN712nSQfIp2uVMxq8CfgLEpKOonCsFftXU3nWmdJB8iW45k/F5wDekY6i8KgHuaWrvOkc6SD5Es5z+jes/kI6hAhED7mhq7zpLOkiuRa+cyfiZ+DvBqcIRA+6K2nvQaJUzGT8RuBN9j1mISoB7o/QpbnTKmYwfAzxAgPvEKuOUAvdFZR00GuVMxj8I/BYYKx1FiYsDi6NwJ1H4y5mMN+AfDVApHUUZYwpwd1N7V6jf3oS7nMl4Kf7mxbXSUZRxTgF+KB1iJMJdTpgPHCUdQhnr0jA/bhbecibjnwK+KB1DGW9BU3vXR6VDDEc4y5mMTwEWSMdQoVAK3N/U3hW651xDV85EZ2LU1Kb62xfFx62WzqJCowa4QTrEUIWunMCVrmXN/PGE8S2frK1e8bZl7ZAOpELh3LDt6heqciY6E63A13p//vyoUS2zGus2rSotdQRjqfC4OUyXt6EpZ6IzUYq/heX7Mu+1rKbza6o+8N3K8Us8KLANkdQQVROiy9vQlBO4DDi03/9jWaPuPWhc6wn1tas2xoo2BhtLhUxoLm9DUc5EZ+IDwOUH+nWbimNHn1hfy+/GlK8KIJYKr1Bc3oainPi7GZQN5hd6ljVp3qTKoz5/8KQle/3jz5XaVzVwjXSIAzG+nInOxFkM9fwSy7JWlo9undlY9/zakuL1+UmmQu68pvauhHSI/TG6nInORDlw7XB//86iog+eXltTeVv8oBW5S6Uiogi4WjrE/hhdTuBLjPSmdssae/2EipY5tdUrdljW9tzEUhHxiab2rpnSIQZibDkTnYlxwLxcvd4//DXRzU+UlT6bq9dUkdAhHWAgxpYT+Ao5fkazx7IaP1tddegVEyc8rGuiKqvF1L2HjDzIKNGZOAjoBsbna4yJPe6qe155rb7KdavyNUbQIn6QUT49A3y4u6MtIx2kL1Nnzq+Sx2ICbCqOTTupfrLVNab8iXyOo0LhcODT0iH2ZVw5E52JOH45886zrEntkyqnXVhdtWQP7AliTGWsnH2+kSvGlRP4LEEeaGtZ1qOjy1pnNta98EJJcXdg4yrTfKipvatVOkRfRpUz0ZmwENrd4J2iIvuM2pqJt1TommgBu1g6QF9GlRM4EX/nNBmWNfbG8RUtp9fW6JpoYZrT1N5VLR2il2nlNOI719pRJS2zGuveerysdI10FhWoEuBC6RC9jClnojNRC/yrdI5ePZbV8B/VVVO+NXGCPidaWC4yZb9bY8oJXIRpZ5xYVsmD48a2HtdQ+9Trsdjr0nFUIOowZJIwqZzG7i+6ORY76mP1k2OLx5b/VTqLCoQRW64aUc5EZ2Ia0CSdY388y5r4zYmVR3+uumqprolG3gkmPIxtRDmBcBwdblnWX0eXzZ7ZWLf27yUl66TjqLyJAW3SIbScw/BOUVHzmbXVVTdVxJdLZ1F5I/6+U7ycic7E4UiubQ6XZY25eXx85mm1NSu3W9Y26Tgq505uau8aJRlAvJzAWdIBRqJ7VMmxsxvrtj5aVvqMdBaVU+OA4yUDmFDO06UDjFSPZdVfWF3V/I2JlUsyYNRjR2pERC9tRcuZ6EyMBz4smSFnLKv4oXFjWo9rqH36tVjsNek4KidEH8KWnjlnApZwhpx6KxY78uP1k0seGDvmceksasTqm9q7pkoNLl3O2cLj54VnWZXfnlR5zPn+muhu6TxqRGZJDSxdTrE/eBBWjS6b3dJY1/1cScla6Sxq2I6WGlisnNk9aSN/ZPyuoqLDzqqtrr5B10TDaprUwJIz5wz8R3Siz7LKF4yPz/xEXc0j24qsrdJx1JA0N7V3lUsMLFlOscsFKetLSmbMbqjbvrKsLCWdRQ1aDJgqMbBkOW3BscW4llX3+epJ9mWTdE00REQubbWcEiyr+Ldjx7S2NtSufjUWe1U6jjogkas8yXI2C45thC2x2NST6yeX/lrXRE1XODNnojMxGThIYmzTeJY14YpJlcecV1O1dLfFLuk8ql/NEluXSM2chXtJO4Cnyspmz2yo25AeVfKCdBb1T2JA4Md2SJXzMKFxjbarqGjKv02urrlufHyZdBb1TyYHPaBUOeuExjWfZZUvrIjPOrWu5tGtRUVbpOOod9UEPaBUOScJjRsaL5WUTG9tqH172eiy1dJZFFBAM+dEoXFDxbWs2osPnvShr+uaqAkKZubUcg6WZcV+P3ZM6+yG2tWvFOuaqKCCmTn1snaItsZiU0+pm1x277gxj0lnKVA6c6qBeZY1/rsTKz/66ZqDdU00eNEvZ/aYv7yeWh11T5eVzm5pqHvx2VEl/5DOUkACfzJFYuYsERo3UnYXFR169uTq2h+Pr1gqnaVABP54o0RJzDqsKMwsa/SiioNmn1I3WddE86846AG1nBHwcknx9NaG2p3/Vz7mOeksERZ4OQMfkIjttmeK4r3E3a6Derre+Npm6SxR5FlF2+gI9vgUiXK6AmNG2pSXvPQVd7mlJW60N0wT5WW2Bz2kRDl7BMaMrM/9wV1y8pPeDAtEz/UoAIH/u9VyhlT8bW9TxyJ3XeV2WqWzFIi9QQ8Y+AdCqbmpDLAl6HGjZLqTefLWG1y3cjsfkc5SQAJ/Ly8xcwJsAiqExg6toozXM+++zPIjX/BaLf1gLWibgh5QspyHCI0dSjVvehu+/zN3e/kejpPOUqAKppwbhcYNpdMezaz49F8yCQsapLMUsMD/zUrOnOoAyvZ4O668w/1b4xvMlM6iCmfm1HIewGEves537nbLSlwtpiEKppyvCI1rPs/zLvhDZunHntK1S8ME/qC7VDn1HtB+xHd4G3+wyF0/YYeuXRooHfSAUuUM/A9quhlOZtV/PpipL/IK74CnENgJbAh6UKlyrgfeAUYLjW+MmOvtvezezMoPr/Nm69qlsZ6z044X9KAiDz1n7xIq+EvbyW966396rfv81HV6U4HhHIlBpWZO8C9tpwqOL+r0RzIrzn04c4QFjdJZ1AGJvA2TLKfIdyNpZXu8Hd/rdJ9u2ESLdBY1aAU3cz4pOLaI5hc95zt3ueXFGS1myDwlMahkOVcAHoXwXsvzvIt+l1l64tPesZbARlFqRF6x047IyW9iu+Cl5qbeAp6RGj8oFTu8jbfe4D550tNeqxYzlMROfJPeojLS2zq2rMk8cctPXMa/LXMyssoJsX+jkpe14H9XukQ4Q84Vu96ey/4388gR3bp2GQFiM6d0OSM3c9Zt9Lqv6nTfGb1Xb8GLgM0IvvUSvaxNzU29CkTmSIE5KzMrrlnoThy9F1s6i8qJ5RJ3BvWSnjkBFgOXSocYidG7ve3f+7m7ul7XLqNmseTg0h8IAfxKOsBIfHC99+zt17qbtZiR4wIPSgYwYeZ8BP/5zsAPJx0Rz/O+8NvM0uNX69plRC2x047opgDiM2dqbsoDfi2dYyjGb/feWHCD++QJq3XtMsLEr+jEy5kl/hcxWLOeyTxx80/cogpdu4wyD7hfOoQJl7XgryW9AVRJBxlIsevtufyezCOHr9e1ywKw0k47gW9Lsi8jZs7U3JQL3COdYyB1G711P53vrk2s1+cuC8Sd0gHAkHJm3SwdoD9nLs8sv2ahW1W2l2bpLCoQ24FfSIcAg8qZmptygIelc/QavcvbNn9Bz8qzl2VmWjBGOo8KzB122gn8uL/+GFPOrJukAwAc3p1Zc/t17tbaNzlWOosKnBH/BsGcD4R63Y+/P2iNyOie513clVnSmvJmWub93aj8W2qnnTXSIXoZNXOm5qZ6gNskxp6wzXv9tuvdp45LecdpMQuWMbMmGFbOrFuB3UEO2JrK/PWmG93i+E6OCnJcZZSXMexmGOPKmZqbegVYGMRYxa6354o73SWX/CbzkSKoDGJMZayr7bQT+OnV+2NcObOuBnblc4D6N7x1P53vrvvQBk+fu1QbCGhCGAojy5mdPW/N1+v/+1J3+Y9ud6vK9nJYvsZQoXKVnXb2SIfYl8kffHwfuBAoz9ULlu/ytl7V6a6p3azH6ql3rQMWSYfoj5EzJ0Bqbup1cvjpWWJdJrXwOnd77WZdu1Tvc6Vp7zV7mTxzAvwAuAg4aLgvYHle5pKHMstmrfFadIlE7eM54OfSIQZieZ7YFimDkuhMfBm4fji/t3Kb91rHIvfV+E6OzHEsFQ0n2WnnT9IhBmLsZW0fNzGMoxuOW515/MYb3RItphrAL00uJoRg5gRIdCaOwd/O5IDfTIp7vN3f/qX7mP0is/OfTIXUNqDZhGc29ycMMyepuanHgQUH+nWNr3svLJrvdmsx1QF8y/RiQrg+ILkc+CQD7JbwqSXusjkrvWlWDpdeVCQ9iWH30A4kFJe1vRKdiXOAu/r+tzHveFuv7nSfrXmLGUKxVHj0ADPstPOEdJDBCMVlba/U3NTdwN29Pz9ibSa18Hp3uxZTDdJ/h6WYEK7L2l5ftDLe9C8/lNnQ8qw304KYdCAVCivw7zoLjVBd1vb6y3T72OotLEWLqQZnC3CknXa6hXMMSagua3sd/6izEviOdA4VGp8NWzEhpOXM+j7wR+kQynjX22nnAekQwxHacmaPZjsHeF46izLWn4GvSYcYrlC+5+zLabYPxb97SHcyUH2l8ZdNtkgHGa7Qzpy97LTzPDAHMO5hWSVmI9AW5mJCBMoJYKedZcAF0jmUEXYDZ9hpZ610kJGKRDkB7LRzB/Bd6RxKlAecb6edldJBciEy5QSw084V5HHvIWW8S+2080vpELkSqXJmfREtaCH6qp12rpUOkUuRK2d2iUULWlgiV0yIYDlBC1pgIllMiGg54X0FvUU6i8qbyBYTIlxOeLegFwNXSmdRObUHmBvlYkIE7hAaLKfZ/gz+lvujpLOoEdkMfNJOO0ukg+RbwZQTwGm2Z+GfAaq3+oXT8/h3/hTE/dSRvqzdV/ZOounA36WzqCFbin+vbEEUEwqsnAB22vkHMAP4vXQWNWi3AR+z086b0kGCVFCXtX05zbYFXIp/3KC+DzXTFuBCO+3cJx1EQsGWs5fTbE/D3zTsUOks6n1WAOfaaWeDdBApBXdZuy877awCjsLgA20KTAZ/6au1kIsJOnO+j9Nsfwq4jgE2rlZ593f8y9il0kFMUPAzZ1/ZJxoOw7+rKCMcp5Dswt+w7Qgt5nt05hyA02wfg19SPaUsv34PfMlOOy9IBzGNlnM/nGY7hn/73/cYwQG+ql8vA/9VqJ/EDoaWcxCcZnsiMA+4BD0oaaQ2AT8EbrTTzk7pMCbTcg6B02wfDLQDXwDKhOOEzWbgGvx9ZHdIhwkDLecwOM32ZOAbwIXoDQwHshWYD8y308426TBhouUcgWxJL8Iv6WThOKZ5DrgZ+JmddrZKhwkjLWcOOM12MXAG/odHx8umEdUDLAZustPOn6TDhJ2WM8ecZtvGf096LjBROE5Q1gOdwAI77bwsHSYqtJx5kp1NTwDOxp9VJ4gGyr2XgPuAe+y086h0mCjScgYgu146Czgd+ARwiGyiYfGA1cBDwAPZe5JVHmk5BTjNdg1+WWcBs4HDMe9Wyr3AKvyHnJcBK+y085ZspMKi5TSA02xXAC3ANKAZsIEpBHfDwzbAwT+ZywEeBx7TmwRkaTkNlX0YvBG/rM34SzUT+/mqAKwBXiaDv/i/qZ+vF8mW0U47r+brz6GGT8sZctkSD3RJnMluD6pCSMuplKFM+xBCKZWl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQyl5VTKUFpOpQz1/6bl1syJ15EKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = np.array([25, 15, 20, 40])\n", + "plt.pie(data);" + ] + }, + { + "cell_type": "markdown", + "id": "10db5d8a-0fd6-462a-bf0a-dc2c637c9f46", + "metadata": {}, + "source": [ + "Note that the data provided to the pie chart does not have to add up to 100. Any numbers provided will be normalized by default, although this can be turned off by setting `normalize=False`.\n", + "\n", + "Let's do a more complicated example." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "96deefab-a218-4764-8609-f05a35c69e1d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "labels = ['Red', 'Blue', 'Yellow', 'Pink', 'Green']\n", + "sizes = [1, 3, 5, 7, 9]\n", + "\n", + "# use explode to separate one slice from the rest\n", + "explode = (0, 0, 0, 0.1, 0) # will separate the only the pink slice\n", + "\n", + "# specify colors to match labels\n", + "colors = ['red', 'blue', 'yellow', 'pink', 'green']\n", + "\n", + "plt.pie(sizes, labels=labels, explode=explode, colors=colors, autopct='%1.1f%%');" + ] + }, + { + "cell_type": "markdown", + "id": "9188f879-c15d-49df-a15a-4b5e42eaf854", + "metadata": {}, + "source": [ + "## Animation" + ] + }, + { + "cell_type": "markdown", + "id": "df8806dd-c6c1-46ff-b245-b3a2784a74bb", + "metadata": {}, + "source": [ + "From matplotlib's animation interface, there are two basic tools, `FuncAnimation` and `T" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "ca74ac2c-9129-4123-966b-a66ff005dba2", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.animation import FuncAnimation" + ] + }, + { + "cell_type": "markdown", + "id": "8bcb81d5-fa22-4d8e-865c-4e74980e02ff", + "metadata": {}, + "source": [ + "### Geoscience Animation Example" + ] + }, + { + "cell_type": "markdown", + "id": "41a8ffa7-ba97-431c-8cfd-26eacd294bab", + "metadata": {}, + "source": [ + "For this section, we're going to roughly follow an example from the [GeoCAT-examples gallery](https://geocat-examples.readthedocs.io/en/latest/gallery/index.html), [NCL_animate_1](https://geocat-examples.readthedocs.io/en/latest/gallery/Animations/NCL_animate_1.html#sphx-glr-gallery-animations-ncl-animate-1-py)." + ] + }, + { + "cell_type": "markdown", + "id": "ac25c39c-0cc2-4e4a-a54f-a38283f8bd89", + "metadata": {}, + "source": [ + "We're going to pull data from a repository called [geocat-datafiles](https://github.com/NCAR/geocat-datafiles). " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "05dfb4c8-178a-4c00-8b52-7360a2d921ad", + "metadata": {}, + "outputs": [], + "source": [ + "import cartopy.crs as ccrs\n", + "import geocat.datafiles as gdf\n", + "import xarray as xr" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "8cea9d81-fef5-408c-99ea-ddfd1f9f4cd1", + "metadata": {}, + "outputs": [], + "source": [ + "# Open a netCDF data file using xarray default engine and load the data into xarrays\n", + "ds = xr.open_dataset(gdf.get(\"netcdf_files/meccatemp.cdf\"), decode_times=False)\n", + "\n", + "# Pull out surface temperature Dataarray from xarray Dataset\n", + "tas = ds.t" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "157fb2d4-8936-4e94-8bf0-11ac3835e33f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6d2bdde5f01860e2dc9e7a8d399c5edbdb99e256 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 14 Oct 2021 15:59:47 -0600 Subject: [PATCH 02/16] add ffmpeg to env --- environment.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/environment.yml b/environment.yml index 7517ce504..5579e6013 100644 --- a/environment.yml +++ b/environment.yml @@ -1,6 +1,7 @@ name: pythia-book-dev channels: - conda-forge + - ncar dependencies: - python=3.8 - jupyter-book @@ -15,3 +16,4 @@ dependencies: - pyproj - pythia-datasets - scipy + - ffmpeg From cfdd5921b04b21ee2f9467b91c129ba68d676ce6 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 14 Oct 2021 16:00:32 -0600 Subject: [PATCH 03/16] base animation done --- core/matplotlib/more-matplotlib.ipynb | 189 +++++++++++++++++++++++++- 1 file changed, 186 insertions(+), 3 deletions(-) diff --git a/core/matplotlib/more-matplotlib.ipynb b/core/matplotlib/more-matplotlib.ipynb index d32c0a7fc..e5fd6b4bb 100644 --- a/core/matplotlib/more-matplotlib.ipynb +++ b/core/matplotlib/more-matplotlib.ipynb @@ -273,12 +273,12 @@ "id": "df8806dd-c6c1-46ff-b245-b3a2784a74bb", "metadata": {}, "source": [ - "From matplotlib's animation interface, there are two basic tools, `FuncAnimation` and `T" + "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": 29, + "execution_count": 31, "id": "ca74ac2c-9129-4123-966b-a66ff005dba2", "metadata": {}, "outputs": [], @@ -286,12 +286,195 @@ "from matplotlib.animation import FuncAnimation" ] }, + { + "cell_type": "markdown", + "id": "06d2efc7-79b1-410f-9dd7-ac6653977f12", + "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": "e7a9047d-5d77-4434-952c-0a3f3ffa4f42", + "metadata": {}, + "source": [ + "For this example, let's create an animated sine wave." + ] + }, + { + "cell_type": "markdown", + "id": "199a8ee5-0ce0-489b-ad13-c1f98dc536af", + "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": "6533c4b6-f46b-477c-b09b-c300b67eae6c", + "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." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "c3ce416e-e24f-41e0-a2db-35c1789f865b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "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": "0f40b357-ced1-4907-8d8e-b7ea06756661", + "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": 85, + "id": "56073721-541c-4845-8ae2-a9ab5321addd", + "metadata": {}, + "outputs": [], + "source": [ + "def animate(i):\n", + "\n", + " # create a range to plot the sine function over\n", + " x = np.linspace(0, 2 * np.pi, 250)\n", + "\n", + " # create appropriate sine function for index\n", + " y = np.sin(2 * np.pi * (x - 0.1 * i))\n", + "\n", + " # assign the data to the line object\n", + " line.set_data(x, y)\n", + "\n", + " return (line,)" + ] + }, + { + "cell_type": "markdown", + "id": "31ca6ec7-9053-43c9-a0f8-54ad1f426263", + "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": 86, + "id": "90ec3d3e-af75-4b6e-a4ca-fe94eb1badb8", + "metadata": {}, + "outputs": [], + "source": [ + "anim = FuncAnimation(fig, animate, init_func=init, frames=200, interval=20, blit=True)" + ] + }, + { + "cell_type": "markdown", + "id": "4e65256b-4f8e-4412-8257-721f73c10e69", + "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": 90, + "id": "30d65783-d106-43dd-876d-18ddf6efe4fe", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "unknown file extension: .m4v", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2214\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2215\u001b[0;31m \u001b[0mformat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEXTENSION\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mext\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2216\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: '.m4v'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 344\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 345\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 346\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 347\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36m_repr_html_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrcParams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'animation.html'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1410\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'html5'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1411\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_html5_video\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1412\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'jshtml'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1413\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_jshtml\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36mto_html5_video\u001b[0;34m(self, embed_limit)\u001b[0m\n\u001b[1;32m 1350\u001b[0m \u001b[0mbitrate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrcParams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'animation.bitrate'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1351\u001b[0m fps=1000. / self._interval)\n\u001b[0;32m-> 1352\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwriter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mwriter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1353\u001b[0m \u001b[0;31m# Now open and base64 encode.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1354\u001b[0m \u001b[0mvid64\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbase64\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencodebytes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_bytes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(self, filename, writer, fps, dpi, codec, bitrate, extra_args, metadata, extra_anim, savefig_kwargs, progress_callback)\u001b[0m\n\u001b[1;32m 1175\u001b[0m \u001b[0mprogress_callback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe_number\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal_frames\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1176\u001b[0m \u001b[0mframe_number\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1177\u001b[0;31m \u001b[0mwriter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrab_frame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0msavefig_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1178\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1179\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/contextlib.py\u001b[0m in \u001b[0;36m__exit__\u001b[0;34m(self, type, value, traceback)\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtype\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 120\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 121\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 122\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36msaving\u001b[0;34m(self, fig, outfile, dpi, *args, **kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0;32myield\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfinish\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36mfinish\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfinish\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 540\u001b[0;31m self._frames[0].save(\n\u001b[0m\u001b[1;32m 541\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave_all\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mappend_images\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_frames\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 542\u001b[0m duration=int(1000 / self.fps), loop=0)\n", + "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2215\u001b[0m \u001b[0mformat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEXTENSION\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mext\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2216\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2217\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"unknown file extension: {ext}\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2219\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mSAVE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: unknown file extension: .m4v" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from matplotlib import rc\n", + "\n", + "rc('animation', html='html5')\n", + "\n", + "anim" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "4eb02613-a99b-4be7-bf5a-4135d18d77c0", + "metadata": {}, + "outputs": [], + "source": [ + "anim.save('animate.gif', writer='pillow');" + ] + }, { "cell_type": "markdown", "id": "8bcb81d5-fa22-4d8e-865c-4e74980e02ff", "metadata": {}, "source": [ - "### Geoscience Animation Example" + "## Geoscience Animation Example" ] }, { From 9fbb2d97b093ebafa915ac83e83976dc1b95ba2b Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 14 Oct 2021 16:02:05 -0600 Subject: [PATCH 04/16] redo outputs --- core/matplotlib/more-matplotlib.ipynb | 1859 ++++++++++++++++++++++++- 1 file changed, 1825 insertions(+), 34 deletions(-) diff --git a/core/matplotlib/more-matplotlib.ipynb b/core/matplotlib/more-matplotlib.ipynb index e5fd6b4bb..997797905 100644 --- a/core/matplotlib/more-matplotlib.ipynb +++ b/core/matplotlib/more-matplotlib.ipynb @@ -200,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "id": "cb5c36c3-3664-4a94-81dc-1f4edd3ae999", "metadata": {}, "outputs": [ @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 6, "id": "96deefab-a218-4764-8609-f05a35c69e1d", "metadata": {}, "outputs": [ @@ -278,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 7, "id": "ca74ac2c-9129-4123-966b-a66ff005dba2", "metadata": {}, "outputs": [], @@ -325,7 +325,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 8, "id": "c3ce416e-e24f-41e0-a2db-35c1789f865b", "metadata": {}, "outputs": [ @@ -366,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 9, "id": "56073721-541c-4845-8ae2-a9ab5321addd", "metadata": {}, "outputs": [], @@ -396,7 +396,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 10, "id": "90ec3d3e-af75-4b6e-a4ca-fe94eb1badb8", "metadata": {}, "outputs": [], @@ -414,39 +414,1830 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 11, "id": "30d65783-d106-43dd-876d-18ddf6efe4fe", "metadata": {}, "outputs": [ - { - "ename": "ValueError", - "evalue": "unknown file extension: .m4v", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2214\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2215\u001b[0;31m \u001b[0mformat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEXTENSION\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mext\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2216\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: '.m4v'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 344\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 345\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 346\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 347\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36m_repr_html_\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrcParams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'animation.html'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1410\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'html5'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1411\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_html5_video\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1412\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'jshtml'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1413\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_jshtml\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36mto_html5_video\u001b[0;34m(self, embed_limit)\u001b[0m\n\u001b[1;32m 1350\u001b[0m \u001b[0mbitrate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmpl\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrcParams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'animation.bitrate'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1351\u001b[0m fps=1000. / self._interval)\n\u001b[0;32m-> 1352\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwriter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mwriter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1353\u001b[0m \u001b[0;31m# Now open and base64 encode.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1354\u001b[0m \u001b[0mvid64\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbase64\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencodebytes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_bytes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(self, filename, writer, fps, dpi, codec, bitrate, extra_args, metadata, extra_anim, savefig_kwargs, progress_callback)\u001b[0m\n\u001b[1;32m 1175\u001b[0m \u001b[0mprogress_callback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe_number\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal_frames\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1176\u001b[0m \u001b[0mframe_number\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1177\u001b[0;31m \u001b[0mwriter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrab_frame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0msavefig_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1178\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1179\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/contextlib.py\u001b[0m in \u001b[0;36m__exit__\u001b[0;34m(self, type, value, traceback)\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mtype\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 120\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 121\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 122\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36msaving\u001b[0;34m(self, fig, outfile, dpi, *args, **kwargs)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0;32myield\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfinish\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36mfinish\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 539\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfinish\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 540\u001b[0;31m self._frames[0].save(\n\u001b[0m\u001b[1;32m 541\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msave_all\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mappend_images\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_frames\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 542\u001b[0m duration=int(1000 / self.fps), loop=0)\n", - "\u001b[0;32m~/opt/anaconda3/envs/pythia-book-dev/lib/python3.8/site-packages/PIL/Image.py\u001b[0m in \u001b[0;36msave\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2215\u001b[0m \u001b[0mformat\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEXTENSION\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mext\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2216\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2217\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"unknown file extension: {ext}\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2218\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2219\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mSAVE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: unknown file extension: .m4v" - ] - }, { "data": { + "text/html": [ + "" + ], "text/plain": [ - "" + "" ] }, - "execution_count": 90, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -461,7 +2252,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 12, "id": "4eb02613-a99b-4be7-bf5a-4135d18d77c0", "metadata": {}, "outputs": [], @@ -495,7 +2286,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 13, "id": "05dfb4c8-178a-4c00-8b52-7360a2d921ad", "metadata": {}, "outputs": [], @@ -507,7 +2298,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 14, "id": "8cea9d81-fef5-408c-99ea-ddfd1f9f4cd1", "metadata": {}, "outputs": [], From 2b975c1694ce2b05fe91a6df4be63f7fba9488cf Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 28 Oct 2021 11:04:40 -0600 Subject: [PATCH 05/16] change title --- _toc.yml | 2 +- ...ynb => matplotlib-additional-topics.ipynb} | 45 +------------------ 2 files changed, 3 insertions(+), 44 deletions(-) rename core/matplotlib/{more-matplotlib.ipynb => matplotlib-additional-topics.ipynb} (99%) diff --git a/_toc.yml b/_toc.yml index 81ae1bb2d..a0b89a642 100644 --- a/_toc.yml +++ b/_toc.yml @@ -36,7 +36,7 @@ parts: - file: core/matplotlib sections: - file: core/matplotlib/matplotlib - - file: core/matplotlib/animating-with-matplotlib + - file: core/matplotlib/matplotlib-additonal-topics-1 - file: core/cartopy sections: - file: core/cartopy/cartopy diff --git a/core/matplotlib/more-matplotlib.ipynb b/core/matplotlib/matplotlib-additional-topics.ipynb similarity index 99% rename from core/matplotlib/more-matplotlib.ipynb rename to core/matplotlib/matplotlib-additional-topics.ipynb index 997797905..8b052cfbf 100644 --- a/core/matplotlib/more-matplotlib.ipynb +++ b/core/matplotlib/matplotlib-additional-topics.ipynb @@ -2,7 +2,6 @@ "cells": [ { "cell_type": "markdown", - "id": "0d9101ce-fe22-4708-b2bb-272f7de7689a", "metadata": {}, "source": [ "
\"Matplotlib
" @@ -10,7 +9,6 @@ }, { "cell_type": "markdown", - "id": "58f82a4c-99b2-4434-bd0e-601506d80bf2", "metadata": {}, "source": [ "# More Matplotlib" @@ -18,7 +16,6 @@ }, { "cell_type": "markdown", - "id": "f9acd874-04a8-4c90-90d3-a312325dc0c1", "metadata": {}, "source": [ "---\n", @@ -32,7 +29,6 @@ }, { "cell_type": "markdown", - "id": "0af21ea8-8ae1-492c-8d1d-3b85705cb08a", "metadata": {}, "source": [ "## Prerequisites\n", @@ -46,7 +42,6 @@ }, { "cell_type": "markdown", - "id": "eedd472e-cfa1-40c4-9e04-df945bc08251", "metadata": {}, "source": [ "---" @@ -54,7 +49,6 @@ }, { "cell_type": "markdown", - "id": "ca47660b-738e-4309-b6dc-3ef8061ed38e", "metadata": {}, "source": [ "## Imports" @@ -62,7 +56,6 @@ }, { "cell_type": "markdown", - "id": "bd8908c3-6205-4a02-8ff0-17402a85f784", "metadata": {}, "source": [ "The same as before, we are going to import matplotlib's `pyplot` interface as `plt`." @@ -71,7 +64,6 @@ { "cell_type": "code", "execution_count": 1, - "id": "aa52a857-80de-46c8-9ea9-38aec508cc18", "metadata": {}, "outputs": [], "source": [ @@ -81,7 +73,6 @@ }, { "cell_type": "markdown", - "id": "dac8e38d-d364-4e63-94f8-78748bd10f32", "metadata": {}, "source": [ "## Histograms\n" @@ -89,7 +80,6 @@ }, { "cell_type": "markdown", - "id": "b4b83329-89c5-4ce7-a05f-fa5075e80c63", "metadata": {}, "source": [ "To make a 1D histogram, we're going to generate a single vector of numbers.\n", @@ -100,7 +90,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "3c4d00bc-004f-4674-98ea-5d3beef9397b", "metadata": {}, "outputs": [], "source": [ @@ -114,7 +103,6 @@ }, { "cell_type": "markdown", - "id": "f46dc699-2acb-4586-adef-44c33595dad7", "metadata": {}, "source": [ "Finally, make a histogtam using `plt.hist`. Here, specifying `density=True` changes the y-axis to be probability instead of count. " @@ -123,7 +111,6 @@ { "cell_type": "code", "execution_count": 3, - "id": "430a0ffb-5a15-4e5f-b670-d9c1db50cd94", "metadata": {}, "outputs": [ { @@ -149,7 +136,6 @@ }, { "cell_type": "markdown", - "id": "8bad0231-3ac8-4ee3-b3f8-b3b69b2bb436", "metadata": {}, "source": [ "Similarly, we can make a 2D histrogram by generating a second random array and using `plt.hist2d`." @@ -158,7 +144,6 @@ { "cell_type": "code", "execution_count": 4, - "id": "1ace046d-8733-4936-9122-8e3866014e43", "metadata": {}, "outputs": [ { @@ -184,7 +169,6 @@ }, { "cell_type": "markdown", - "id": "2c99884c-8746-418b-aa3e-07394d39dc69", "metadata": {}, "source": [ "## Pie Charts" @@ -192,7 +176,6 @@ }, { "cell_type": "markdown", - "id": "2c517ba4-02ec-4f8a-af77-c0835f10c34a", "metadata": {}, "source": [ "Matplotlib can also be used to plot pie charts with `plt.pie`. The most basic implementation is shown below." @@ -201,7 +184,6 @@ { "cell_type": "code", "execution_count": 5, - "id": "cb5c36c3-3664-4a94-81dc-1f4edd3ae999", "metadata": {}, "outputs": [ { @@ -222,7 +204,6 @@ }, { "cell_type": "markdown", - "id": "10db5d8a-0fd6-462a-bf0a-dc2c637c9f46", "metadata": {}, "source": [ "Note that the data provided to the pie chart does not have to add up to 100. Any numbers provided will be normalized by default, although this can be turned off by setting `normalize=False`.\n", @@ -233,7 +214,6 @@ { "cell_type": "code", "execution_count": 6, - "id": "96deefab-a218-4764-8609-f05a35c69e1d", "metadata": {}, "outputs": [ { @@ -262,7 +242,6 @@ }, { "cell_type": "markdown", - "id": "9188f879-c15d-49df-a15a-4b5e42eaf854", "metadata": {}, "source": [ "## Animation" @@ -270,7 +249,6 @@ }, { "cell_type": "markdown", - "id": "df8806dd-c6c1-46ff-b245-b3a2784a74bb", "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)." @@ -279,7 +257,6 @@ { "cell_type": "code", "execution_count": 7, - "id": "ca74ac2c-9129-4123-966b-a66ff005dba2", "metadata": {}, "outputs": [], "source": [ @@ -288,7 +265,6 @@ }, { "cell_type": "markdown", - "id": "06d2efc7-79b1-410f-9dd7-ac6653977f12", "metadata": {}, "source": [ "`FuncAnimation` creates animations by repeatedly calling a function. Using this method involves three main steps:\n", @@ -300,7 +276,6 @@ }, { "cell_type": "markdown", - "id": "e7a9047d-5d77-4434-952c-0a3f3ffa4f42", "metadata": {}, "source": [ "For this example, let's create an animated sine wave." @@ -308,7 +283,6 @@ }, { "cell_type": "markdown", - "id": "199a8ee5-0ce0-489b-ad13-c1f98dc536af", "metadata": {}, "source": [ "### Step 1: Initial State\n", @@ -317,7 +291,6 @@ }, { "cell_type": "markdown", - "id": "6533c4b6-f46b-477c-b09b-c300b67eae6c", "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." @@ -326,7 +299,6 @@ { "cell_type": "code", "execution_count": 8, - "id": "c3ce416e-e24f-41e0-a2db-35c1789f865b", "metadata": {}, "outputs": [ { @@ -357,7 +329,6 @@ }, { "cell_type": "markdown", - "id": "0f40b357-ced1-4907-8d8e-b7ea06756661", "metadata": {}, "source": [ "### Step 2: Animation Progression Function\n", @@ -367,7 +338,6 @@ { "cell_type": "code", "execution_count": 9, - "id": "56073721-541c-4845-8ae2-a9ab5321addd", "metadata": {}, "outputs": [], "source": [ @@ -387,7 +357,6 @@ }, { "cell_type": "markdown", - "id": "31ca6ec7-9053-43c9-a0f8-54ad1f426263", "metadata": {}, "source": [ "### Step 3: Using `FuncAnimation`\n", @@ -397,7 +366,6 @@ { "cell_type": "code", "execution_count": 10, - "id": "90ec3d3e-af75-4b6e-a4ca-fe94eb1badb8", "metadata": {}, "outputs": [], "source": [ @@ -406,7 +374,6 @@ }, { "cell_type": "markdown", - "id": "4e65256b-4f8e-4412-8257-721f73c10e69", "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." @@ -415,7 +382,6 @@ { "cell_type": "code", "execution_count": 11, - "id": "30d65783-d106-43dd-876d-18ddf6efe4fe", "metadata": {}, "outputs": [ { @@ -2253,7 +2219,6 @@ { "cell_type": "code", "execution_count": 12, - "id": "4eb02613-a99b-4be7-bf5a-4135d18d77c0", "metadata": {}, "outputs": [], "source": [ @@ -2262,7 +2227,6 @@ }, { "cell_type": "markdown", - "id": "8bcb81d5-fa22-4d8e-865c-4e74980e02ff", "metadata": {}, "source": [ "## Geoscience Animation Example" @@ -2270,7 +2234,6 @@ }, { "cell_type": "markdown", - "id": "41a8ffa7-ba97-431c-8cfd-26eacd294bab", "metadata": {}, "source": [ "For this section, we're going to roughly follow an example from the [GeoCAT-examples gallery](https://geocat-examples.readthedocs.io/en/latest/gallery/index.html), [NCL_animate_1](https://geocat-examples.readthedocs.io/en/latest/gallery/Animations/NCL_animate_1.html#sphx-glr-gallery-animations-ncl-animate-1-py)." @@ -2278,7 +2241,6 @@ }, { "cell_type": "markdown", - "id": "ac25c39c-0cc2-4e4a-a54f-a38283f8bd89", "metadata": {}, "source": [ "We're going to pull data from a repository called [geocat-datafiles](https://github.com/NCAR/geocat-datafiles). " @@ -2287,7 +2249,6 @@ { "cell_type": "code", "execution_count": 13, - "id": "05dfb4c8-178a-4c00-8b52-7360a2d921ad", "metadata": {}, "outputs": [], "source": [ @@ -2299,7 +2260,6 @@ { "cell_type": "code", "execution_count": 14, - "id": "8cea9d81-fef5-408c-99ea-ddfd1f9f4cd1", "metadata": {}, "outputs": [], "source": [ @@ -2313,7 +2273,6 @@ { "cell_type": "code", "execution_count": null, - "id": "157fb2d4-8936-4e94-8bf0-11ac3835e33f", "metadata": {}, "outputs": [], "source": [] @@ -2321,7 +2280,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -2335,7 +2294,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.8.5" } }, "nbformat": 4, From de594dc3b114a3103cf8f9f801456e08c0edf3c6 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 28 Oct 2021 11:09:12 -0600 Subject: [PATCH 06/16] rename --- ...ditional-topics.ipynb => matplotlib-additional-topics-1.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename core/matplotlib/{matplotlib-additional-topics.ipynb => matplotlib-additional-topics-1.ipynb} (100%) diff --git a/core/matplotlib/matplotlib-additional-topics.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb similarity index 100% rename from core/matplotlib/matplotlib-additional-topics.ipynb rename to core/matplotlib/matplotlib-additional-topics-1.ipynb From 3137782c9aff421b8445e0f7e5b2740ed56c9d89 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 28 Oct 2021 11:18:52 -0600 Subject: [PATCH 07/16] rename --- _toc.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_toc.yml b/_toc.yml index a0b89a642..5a6071dc5 100644 --- a/_toc.yml +++ b/_toc.yml @@ -36,7 +36,7 @@ parts: - file: core/matplotlib sections: - file: core/matplotlib/matplotlib - - file: core/matplotlib/matplotlib-additonal-topics-1 + - file: core/matplotlib/matplotlib-additional-topics-1 - file: core/cartopy sections: - file: core/cartopy/cartopy From 7fa57064a280f7d784d83d66f8ab626fd6e12d39 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 28 Oct 2021 11:26:00 -0600 Subject: [PATCH 08/16] rename notebook and wrap up edits --- .../matplotlib-additional-topics-1.ipynb | 101 +++++++++--------- 1 file changed, 48 insertions(+), 53 deletions(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index 8b052cfbf..07250c89b 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "3d9564ec", "metadata": {}, "source": [ "
\"Matplotlib
" @@ -9,13 +10,15 @@ }, { "cell_type": "markdown", + "id": "e9eb4444", "metadata": {}, "source": [ - "# More Matplotlib" + "# Additional Topics Part 1: Histograms, Pie Charts, and Animation" ] }, { "cell_type": "markdown", + "id": "cba92e3a", "metadata": {}, "source": [ "---\n", @@ -29,6 +32,7 @@ }, { "cell_type": "markdown", + "id": "56c73537", "metadata": {}, "source": [ "## Prerequisites\n", @@ -42,6 +46,7 @@ }, { "cell_type": "markdown", + "id": "4440f2b1", "metadata": {}, "source": [ "---" @@ -49,6 +54,7 @@ }, { "cell_type": "markdown", + "id": "0702fe7b", "metadata": {}, "source": [ "## Imports" @@ -56,6 +62,7 @@ }, { "cell_type": "markdown", + "id": "148180d5", "metadata": {}, "source": [ "The same as before, we are going to import matplotlib's `pyplot` interface as `plt`." @@ -64,6 +71,7 @@ { "cell_type": "code", "execution_count": 1, + "id": "d16d139c", "metadata": {}, "outputs": [], "source": [ @@ -73,6 +81,7 @@ }, { "cell_type": "markdown", + "id": "7310773f", "metadata": {}, "source": [ "## Histograms\n" @@ -80,6 +89,7 @@ }, { "cell_type": "markdown", + "id": "a5ea8056", "metadata": {}, "source": [ "To make a 1D histogram, we're going to generate a single vector of numbers.\n", @@ -90,6 +100,7 @@ { "cell_type": "code", "execution_count": 2, + "id": "df424130", "metadata": {}, "outputs": [], "source": [ @@ -103,6 +114,7 @@ }, { "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. " @@ -111,6 +123,7 @@ { "cell_type": "code", "execution_count": 3, + "id": "dfd7c0cc", "metadata": {}, "outputs": [ { @@ -136,6 +149,7 @@ }, { "cell_type": "markdown", + "id": "84fb255f", "metadata": {}, "source": [ "Similarly, we can make a 2D histrogram by generating a second random array and using `plt.hist2d`." @@ -144,6 +158,7 @@ { "cell_type": "code", "execution_count": 4, + "id": "4ed3325e", "metadata": {}, "outputs": [ { @@ -169,6 +184,7 @@ }, { "cell_type": "markdown", + "id": "dd5a6bca", "metadata": {}, "source": [ "## Pie Charts" @@ -176,6 +192,7 @@ }, { "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." @@ -184,6 +201,7 @@ { "cell_type": "code", "execution_count": 5, + "id": "9399feaa", "metadata": {}, "outputs": [ { @@ -204,6 +222,7 @@ }, { "cell_type": "markdown", + "id": "e747e452", "metadata": {}, "source": [ "Note that the data provided to the pie chart does not have to add up to 100. Any numbers provided will be normalized by default, although this can be turned off by setting `normalize=False`.\n", @@ -214,6 +233,7 @@ { "cell_type": "code", "execution_count": 6, + "id": "fa9ecaec", "metadata": {}, "outputs": [ { @@ -242,6 +262,7 @@ }, { "cell_type": "markdown", + "id": "c516ce4b", "metadata": {}, "source": [ "## Animation" @@ -249,6 +270,7 @@ }, { "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)." @@ -257,6 +279,7 @@ { "cell_type": "code", "execution_count": 7, + "id": "3879e346", "metadata": {}, "outputs": [], "source": [ @@ -265,6 +288,7 @@ }, { "cell_type": "markdown", + "id": "a31e17ed", "metadata": {}, "source": [ "`FuncAnimation` creates animations by repeatedly calling a function. Using this method involves three main steps:\n", @@ -276,6 +300,7 @@ }, { "cell_type": "markdown", + "id": "e1abc210", "metadata": {}, "source": [ "For this example, let's create an animated sine wave." @@ -283,6 +308,7 @@ }, { "cell_type": "markdown", + "id": "5455b9de", "metadata": {}, "source": [ "### Step 1: Initial State\n", @@ -291,14 +317,18 @@ }, { "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." + "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": [ { @@ -329,6 +359,7 @@ }, { "cell_type": "markdown", + "id": "679981fb", "metadata": {}, "source": [ "### Step 2: Animation Progression Function\n", @@ -338,6 +369,7 @@ { "cell_type": "code", "execution_count": 9, + "id": "c5b606e2", "metadata": {}, "outputs": [], "source": [ @@ -357,6 +389,7 @@ }, { "cell_type": "markdown", + "id": "6ef0f128", "metadata": {}, "source": [ "### Step 3: Using `FuncAnimation`\n", @@ -366,6 +399,7 @@ { "cell_type": "code", "execution_count": 10, + "id": "8ecb3760", "metadata": {}, "outputs": [], "source": [ @@ -374,6 +408,7 @@ }, { "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." @@ -382,6 +417,7 @@ { "cell_type": "code", "execution_count": 11, + "id": "b464c460", "metadata": {}, "outputs": [ { @@ -2200,7 +2236,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 11, @@ -2216,71 +2252,30 @@ "anim" ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "anim.save('animate.gif', writer='pillow');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Geoscience Animation Example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For this section, we're going to roughly follow an example from the [GeoCAT-examples gallery](https://geocat-examples.readthedocs.io/en/latest/gallery/index.html), [NCL_animate_1](https://geocat-examples.readthedocs.io/en/latest/gallery/Animations/NCL_animate_1.html#sphx-glr-gallery-animations-ncl-animate-1-py)." - ] - }, { "cell_type": "markdown", + "id": "8be86c41-2ac0-4385-8b3f-70cf0139b19e", "metadata": {}, "source": [ - "We're going to pull data from a repository called [geocat-datafiles](https://github.com/NCAR/geocat-datafiles). " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "import cartopy.crs as ccrs\n", - "import geocat.datafiles as gdf\n", - "import xarray as xr" + "### Saving an Animation\n", + "\n", + "To save an animation, use `anim.save()` as shown below." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, + "id": "6a1693bd", "metadata": {}, "outputs": [], "source": [ - "# Open a netCDF data file using xarray default engine and load the data into xarrays\n", - "ds = xr.open_dataset(gdf.get(\"netcdf_files/meccatemp.cdf\"), decode_times=False)\n", - "\n", - "# Pull out surface temperature Dataarray from xarray Dataset\n", - "tas = ds.t" + "anim.save('animate.gif', writer='pillow');" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2294,7 +2289,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.12" } }, "nbformat": 4, From 7ea90f0cb4987e1cb88d453e486769dba9c1c0c2 Mon Sep 17 00:00:00 2001 From: anissa111 Date: Thu, 28 Oct 2021 11:26:23 -0600 Subject: [PATCH 09/16] restore original env file --- environment.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/environment.yml b/environment.yml index 5579e6013..b45ca975a 100644 --- a/environment.yml +++ b/environment.yml @@ -1,7 +1,6 @@ name: pythia-book-dev channels: - conda-forge - - ncar dependencies: - python=3.8 - jupyter-book From 4c946c78cd1b279f0dd1245835b83cefe45e42c0 Mon Sep 17 00:00:00 2001 From: Julia Kent Date: Tue, 22 Feb 2022 12:19:42 -0700 Subject: [PATCH 10/16] add summary section --- .../matplotlib-additional-topics-1.ipynb | 60 +++++++++++++------ core/matplotlib/matplotlib.ipynb | 2 +- 2 files changed, 43 insertions(+), 19 deletions(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index 07250c89b..dbf25aff6 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -23,11 +23,10 @@ "source": [ "---\n", "## Overview\n", - "We will cover creating more advanced plots with the Matplotlib library.\n", "\n", - "1. Create a histogram\n", - "1. Create a pie chart\n", - "1. Create and save an animated plot" + "1. Histograms\n", + "1. Pie Charts\n", + "1. Animation" ] }, { @@ -94,7 +93,7 @@ "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." + "We'll generate these numbers using NumPy's normal distribution random number generator. For demonstration purposes, we've specified the random seed for reproducability." ] }, { @@ -107,7 +106,6 @@ "npts = 2500\n", "nbins = 15\n", "\n", - "# Generate random points from a normal distribution\n", "np.random.seed(0)\n", "x = np.random.normal(size=npts)" ] @@ -128,7 +126,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -140,7 +138,6 @@ } ], "source": [ - "# Make histogram\n", "plt.hist(x, bins=nbins, density=True)\n", "plt.title('1D histogram')\n", "plt.xlabel('Data')\n", @@ -163,7 +160,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAPGklEQVR4nO3df6jd9X3H8dfr3tzcY2L8hdFETdfKnExEFO7c1o6tq9mWlaLrRlnd2ArduPiHzMIGdg1UuiJsCGWwDbaAsg5sS5mVlkapylqcsFhTSV1sorOuzkRnNBo15pf33vf+uMcR7U3uOff7fed73yfPB1y4597L67y/N/e+8r3f8zmf44gQAKCusa4HAAA0Q5EDQHEUOQAUR5EDQHEUOQAUt6KLO13pyehpdRd3DZzWbKfksvrt1HhTr70SEWvf+/FOiryn1fpFX9fFXZ82PD6elh2zs2nZyDU22UvJnTt6JCUX7/ZQ/OtzC32cSysAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUFwnux8iX+YOhVk7K3rFREpuxZ35sr7HFb8XWBxn5ABQHEUOAMVR5ABQHEUOAMU1LnLbPdvft/1D20/a/kIbgwEABtPGqpWjkj4SEQdtT0h6xPb9EbGthWwAwCIaF3nMv3z2wf7Nif4bL6kNAKdIK9fIbY/b3iFpn6QHI+LRBb5m2vZ229vf1tE27hYAoJaKPCJmI+JqSZdIutb2lQt8zZaImIqIqQlNtnG3AAC1vGolIg5I+p6kTW3mAgBOrI1VK2ttn9N//wxJGyXtbpoLABhMG6tW1kv6su1xzf/H8PWI+HYLuQCAAbSxauUJSde0MAsAYAnY/bBj1XYSlPJ20PNkzoPgY5O9lNxU4zlPunZKqqTZuazkvJ+3pN+9zJ1HT4Sn6ANAcRQ5ABRHkQNAcRQ5ABRHkQNAcRQ5ABRHkQNAcRQ5ABRHkQNAcRQ5ABRHkQNAcRQ5ABRHkQNAcRQ5ABQ3UtvYZm1LKeVtTZm2desFa1NyJWns2LGc4JUrc3LnErcVPZL0QuKrVqXEzu17OSU3a9tdKff3elRwRg4AxVHkAFAcRQ4AxVHkAFBc4yK3vcH2d23vsv2k7VvaGAwAMJg2Vq3MSPrziHjc9hpJP7D9YET8qIVsAMAiGp+RR8SLEfF4//03Je2SdHHTXADAYFpdR277/ZKukfToAp+bljQtST3lrJEFgNNRaw922j5T0j2SPhMRb7z38xGxJSKmImJqQjlPggGA01ErRW57QvMlfndEfKONTADAYNpYtWJJd0raFRFfaj4SAGAYbZyRf0jSH0n6iO0d/bePtpALABhA4wc7I+IRSW5hFgDAEozU7oeZxiZ7KbmemEjJzTR70fkpuW+9L2c106EL83bPW/VSzs6Kq144kpI7du7qlFw/uzclN9PcoUNdj9AanqIPAMVR5ABQHEUOAMVR5ABQHEUOAMVR5ABQHEUOAMVR5ABQHEUOAMVR5ABQHEUOAMVR5ABQHEUOAMVR5ABQXGfb2Hq8/a1FvSJvS1j3cl5n9Mgv/VxKrmcjJVeSXvzQypTcY2fnzDx75kxKriQd3pvzK/TG+3K2m1237a2U3BXrL0jJlSS//GpKLtvYAgCWDYocAIqjyAGgOIocAIprpcht32V7n+2dbeQBAAbX1hn5P0va1FIWAGAIrRR5RDwsKWeNEADgpE7ZOnLb05KmJamnVafqbgFg5J2yBzsjYktETEXE1IRynlwDAKcjVq0AQHEUOQAU19byw69K+g9Jl9veY/tP2sgFACyulQc7I+LGNnIAAMPrbPfDDHNHj6RlrzgzZze63p7XU3L/98Pnp+RK0tHz5lJyz770QEruB9f/d0quJM1c3f4unpL08NarU3IPr+ul5CorV9KaVw+k5I5N5syc2UMnwjVyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4jrZxtZjY/Jk+6/b6dmc7VUlSeeenRJ76NJzUnJXvhkpuZJ01TU528J+bsPWlNxfmJxIyZWk33/2upTcI5ceTck99GLO6+Wu2TuTkitJ6uXMnHUWO7ePbWwBAEOiyAGgOIocAIqjyAGguFaK3PYm20/Zfsb2Z9vIBAAMpnGR2x6X9A+SflvSFZJutH1F01wAwGDaOCO/VtIzEfFsRByT9DVJN7SQCwAYQBtFfrGk54+7vaf/sXexPW17u+3tx+LUr7MEgFHVRpF7gY/91LNRImJLRExFxNRK91q4WwCA1E6R75G04bjbl0h6oYVcAMAA2ijyxyRdZvsDtldK+qSkb7WQCwAYQOO9ViJixvbNkr4jaVzSXRHxZOPJAAADaWXTrIi4T9J9bWQBAIbTye6HsuWJhB3p8ja5U7y8PyX3yAcvTMl9e/VCj0G3Y+fe9Sm5f7D3T1NyN5z/WkquJO1/a3VO8OHxnNwkZ/zkQF74kZydIOdefzMld2wycTHHCRb88RR9ACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4ihyACiOIgeA4jrZxjZmZzV38GAXd71k4xdekJJ79tOHUnKPrp1MyZWkQ0+vSsn1TEqsfrIu73uhM3OGXv3jnF/NNXuTvskVjeecx84dyvmdPhnOyAGgOIocAIqjyAGgOIocAIprVOS2P2H7SdtztqfaGgoAMLimZ+Q7Jf2upIdbmAUAsASN1jhFxC5JsvNesR0AcHKnbB257WlJ05LUU846ZAA4HS1a5LYfkrRugU9tjohvDnpHEbFF0hZJOsvnxcATAgBOatEij4iNp2IQAMDSsPwQAIpruvzw47b3SPplSVttf6edsQAAg2q6auVeSfe2NAsAYAk62f1Qmt8BsW1jk73WM98xt/+1lNwVq85Iyc107u6cK3JvXZiTe9ZzeVcQZ3o5Oyue819HU3Inf/xSSq7eOpyTK2nucE521i6FHh9PyZUknWDzSq6RA0BxFDkAFEeRA0BxFDkAFEeRA0BxFDkAFEeRA0BxFDkAFEeRA0BxFDkAFEeRA0BxFDkAFEeRA0BxFDkAFNfZNrYZYubtrkcY3rFjKbErnn0hJVeSzn1lTU5uSqrSvseSpJUrU2Lj5f05uSmpuTwxkZObtN1sxhbdi+GMHACKo8gBoDiKHACKa/riy3fY3m37Cdv32j6npbkAAANqekb+oKQrI+IqSU9L+svmIwEAhtGoyCPigYh45+VAt0m6pPlIAIBhtHmN/NOS7m8xDwAwgEXXkdt+SNK6BT61OSK+2f+azZJmJN19kpxpSdOS1NOqJQ0LAPhpixZ5RGw82edtf0rSxyRdFxEnfL5BRGyRtEWSzvJ5FZ+XAADLUqNndtreJOlWSb8WEYfaGQkAMIym18j/XtIaSQ/a3mH7H1uYCQAwhEZn5BHxs20NAgBYGp7ZCQDFjdTuh5mydjSb+Z89Kbljk72UXEmK/a+m5HpF0i53vcmUXEmKt5N23JydS4nN+l7MHTyYkpupi10Ks3BGDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUBxFDgDFUeQAUNxIbWM7SttSNjV39EjXIywfid+KmMnZxjbtZ5mfi5HEGTkAFEeRA0BxFDkAFNeoyG1/0fYTtnfYfsD2RW0NBgAYTNMz8jsi4qqIuFrStyV9vvlIAIBhNCryiHjjuJurJUWzcQAAw2q8/ND27ZL+WNLrkn79JF83LWlaknpa1fRuAQB9i56R237I9s4F3m6QpIjYHBEbJN0t6eYT5UTEloiYioipCU22dwQAcJpb9Iw8IjYOmPUVSVsl3dZoIgDAUJquWrnsuJvXS9rdbBwAwLCaXiP/a9uXS5qT9Jykm5qPBAAYRqMij4jfa2sQAMDS8MxOAChupHY/RG1ZO/5V3BVzbLKXksuumKOJM3IAKI4iB4DiKHIAKI4iB4DiKHIAKI4iB4DiKHIAKI4iB4DiKHIAKI4iB4DiKHIAKI4iB4DiKHIAKI4iB4DiHBGn/k7tlzX/ikLvdb6kV07xONlG8Zik0TwujqmGUTwmabDj+pmIWPveD3ZS5Cdie3tETHU9R5tG8Zik0TwujqmGUTwmqdlxcWkFAIqjyAGguOVW5Fu6HiDBKB6TNJrHxTHVMIrHJDU4rmV1jRwAMLzldkYOABgSRQ4AxS27Irf9RdtP2N5h+wHbF3U9U1O277C9u39c99o+p+uZmrL9CdtP2p6zXXopmO1Ntp+y/Yztz3Y9Txts32V7n+2dXc/SFtsbbH/X9q7+z94tXc/UlO2e7e/b/mH/mL6wpJzldo3c9lkR8Ub//T+TdEVE3NTxWI3Y/k1J/xYRM7b/RpIi4taOx2rE9s9LmpP0T5L+IiK2dzzSktgel/S0pN+QtEfSY5JujIgfdTpYQ7Z/VdJBSf8SEVd2PU8bbK+XtD4iHre9RtIPJP1O5X8r25a0OiIO2p6Q9IikWyJi2zA5y+6M/J0S71staXn9T7MEEfFARMz0b26TdEmX87QhInZFxFNdz9GCayU9ExHPRsQxSV+TdEPHMzUWEQ9LerXrOdoUES9GxOP999+UtEvSxd1O1UzMO9i/OdF/G7rzll2RS5Lt220/L+kPJX2+63la9mlJ93c9BP7fxZKeP+72HhUvh9OB7fdLukbSox2P0pjtcds7JO2T9GBEDH1MnRS57Yds71zg7QZJiojNEbFB0t2Sbu5ixmEtdkz9r9ksaUbzx7XsDXJMI8ALfKz8X4GjzPaZku6R9Jn3/AVfUkTMRsTVmv9L/VrbQ18KW9H6VAOIiI0DfulXJG2VdFviOK1Y7Jhsf0rSxyRdF8vtgYkTGOLfqbI9kjYcd/sSSS90NAsW0b+OfI+kuyPiG13P06aIOGD7e5I2SRrqQepld2nF9mXH3bxe0u6uZmmL7U2SbpV0fUQc6noevMtjki6z/QHbKyV9UtK3Op4JC+g/MHinpF0R8aWu52mD7bXvrGKzfYakjVpC5y3HVSv3SLpc8ysinpN0U0Ts7XaqZmw/I2lS0v7+h7aNwEqcj0v6O0lrJR2QtCMifqvToZbI9kcl/a2kcUl3RcTt3U7UnO2vSvqw5rdGfUnSbRFxZ6dDNWT7VyT9u6T/1Hw/SNLnIuK+7qZqxvZVkr6s+Z+9MUlfj4i/GjpnuRU5AGA4y+7SCgBgOBQ5ABRHkQNAcRQ5ABRHkQNAcRQ5ABRHkQNAcf8HYGaPKyNewn4AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -195,18 +192,20 @@ "id": "35bc61ba", "metadata": {}, "source": [ - "Matplotlib can also be used to plot pie charts with `plt.pie`. The most basic implementation is shown below." + "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). \n", + "\n", + "Typically, you'll see examples where all of the values in the array 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 by default, although this can be turned off by setting `normalize=False`." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "9399feaa", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -225,8 +224,6 @@ "id": "e747e452", "metadata": {}, "source": [ - "Note that the data provided to the pie chart does not have to add up to 100. Any numbers provided will be normalized by default, although this can be turned off by setting `normalize=False`.\n", - "\n", "Let's do a more complicated example." ] }, @@ -238,7 +235,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -333,7 +330,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -2259,7 +2256,7 @@ "source": [ "### Saving an Animation\n", "\n", - "To save an animation, use `anim.save()` as shown below." + "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." ] }, { @@ -2271,6 +2268,33 @@ "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](matplotlib-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": { @@ -2289,7 +2313,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.8.10" } }, "nbformat": 4, 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." ] }, { From f78f8d1303d77826e2c6e503c410c36cf00d269f Mon Sep 17 00:00:00 2001 From: Julia Kent Date: Tue, 22 Feb 2022 12:24:56 -0700 Subject: [PATCH 11/16] fix link --- core/matplotlib/matplotlib-additional-topics-1.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index dbf25aff6..a1fec3d9e 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -2288,7 +2288,7 @@ "\n", "\n", "## What's Next\n", - "[More plotting functionality](matplotlib-additional-topics-2) such as annotations, equation rendering, and colormaps.\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", From 42b8a0bd170983bef1169f6a97710f06079c25df Mon Sep 17 00:00:00 2001 From: Julia Kent <46687291+jukent@users.noreply.github.com> Date: Tue, 22 Feb 2022 12:25:52 -0700 Subject: [PATCH 12/16] fix link --- core/matplotlib/matplotlib-additional-topics-1.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index dbf25aff6..a1fec3d9e 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -2288,7 +2288,7 @@ "\n", "\n", "## What's Next\n", - "[More plotting functionality](matplotlib-additional-topics-2) such as annotations, equation rendering, and colormaps.\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", From 20a44c94425b24e6f4562a26e9f47d736de5008d Mon Sep 17 00:00:00 2001 From: Julia Kent <46687291+jukent@users.noreply.github.com> Date: Tue, 22 Feb 2022 12:29:50 -0700 Subject: [PATCH 13/16] rm comments --- core/matplotlib/matplotlib-additional-topics-1.ipynb | 7 ------- 1 file changed, 7 deletions(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index a1fec3d9e..080de3849 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -172,10 +172,8 @@ } ], "source": [ - "# Generate a second random array\n", "y = np.random.normal(size=npts)\n", "\n", - "# Make a 2D histogram\n", "plt.hist2d(x, y, bins=nbins);" ] }, @@ -248,10 +246,8 @@ "labels = ['Red', 'Blue', 'Yellow', 'Pink', 'Green']\n", "sizes = [1, 3, 5, 7, 9]\n", "\n", - "# use explode to separate one slice from the rest\n", "explode = (0, 0, 0, 0.1, 0) # will separate the only the pink slice\n", "\n", - "# specify colors to match labels\n", "colors = ['red', 'blue', 'yellow', 'pink', 'green']\n", "\n", "plt.pie(sizes, labels=labels, explode=explode, colors=colors, autopct='%1.1f%%');" @@ -372,13 +368,10 @@ "source": [ "def animate(i):\n", "\n", - " # create a range to plot the sine function over\n", " x = np.linspace(0, 2 * np.pi, 250)\n", "\n", - " # create appropriate sine function for index\n", " y = np.sin(2 * np.pi * (x - 0.1 * i))\n", "\n", - " # assign the data to the line object\n", " line.set_data(x, y)\n", "\n", " return (line,)" From e8e8a8d3eca8adbefce93650cd3e8bb6286483ca Mon Sep 17 00:00:00 2001 From: Julia Kent Date: Tue, 22 Feb 2022 14:31:07 -0700 Subject: [PATCH 14/16] normalize=false --- .../matplotlib-additional-topics-1.ipynb | 60 ++++++++++++++----- 1 file changed, 46 insertions(+), 14 deletions(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index a1fec3d9e..6c01efffe 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -192,9 +192,7 @@ "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). \n", - "\n", - "Typically, you'll see examples where all of the values in the array 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 by default, although this can be turned off by setting `normalize=False`." + "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). " ] }, { @@ -215,8 +213,40 @@ } ], "source": [ - "data = np.array([25, 15, 20, 40])\n", - "plt.pie(data);" + "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([.25, .20, .40])\n", + "plt.pie(x, normalize=False);" ] }, { @@ -224,18 +254,22 @@ "id": "e747e452", "metadata": {}, "source": [ - "Let's do a more complicated example." + "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": 6, + "execution_count": 11, "id": "fa9ecaec", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -245,14 +279,12 @@ } ], "source": [ - "labels = ['Red', 'Blue', 'Yellow', 'Pink', 'Green']\n", - "sizes = [1, 3, 5, 7, 9]\n", + "colors = ['red', 'blue', 'yellow', 'pink', 'green']\n", + "labels = [c.capitalize() for c in colors]\n", "\n", - "# use explode to separate one slice from the rest\n", - "explode = (0, 0, 0, 0.1, 0) # will separate the only the pink slice\n", + "sizes = [1, 3, 5, 7, 9]\n", + "explode = (0, 0, 0, 0.1, 0)\n", "\n", - "# specify colors to match labels\n", - "colors = ['red', 'blue', 'yellow', 'pink', 'green']\n", "\n", "plt.pie(sizes, labels=labels, explode=explode, colors=colors, autopct='%1.1f%%');" ] From f66bc4d92bc5a2fe8ed760cc248b3cce5f02c2a7 Mon Sep 17 00:00:00 2001 From: Julia Kent Date: Tue, 22 Feb 2022 14:31:34 -0700 Subject: [PATCH 15/16] missing ` --- core/matplotlib/matplotlib-additional-topics-1.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index 6c01efffe..347f6e711 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -2315,7 +2315,7 @@ "metadata": {}, "source": [ "## Summary\n", - "* matplotlib` supports additional plot types. Here we covered histograms and scatter plots.\n", + "* `matplotlib` supports additional plot types. Here we covered histograms and scatter plots.\n", "* You can animate your plots.\n", "\n", "\n", From 274cb98a2a8caae2e13dbf1532978ea9eee6f96d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 22 Feb 2022 21:34:22 +0000 Subject: [PATCH 16/16] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- core/matplotlib/matplotlib-additional-topics-1.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/matplotlib/matplotlib-additional-topics-1.ipynb b/core/matplotlib/matplotlib-additional-topics-1.ipynb index b6895b35d..921097e74 100644 --- a/core/matplotlib/matplotlib-additional-topics-1.ipynb +++ b/core/matplotlib/matplotlib-additional-topics-1.ipynb @@ -243,7 +243,7 @@ } ], "source": [ - "x = np.array([.25, .20, .40])\n", + "x = np.array([0.25, 0.20, 0.40])\n", "plt.pie(x, normalize=False);" ] },