01.11 Data Visualization with Matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Data Visualization with Matplotlib<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Basic-plot-commands\" data-toc-modified-id=\"Basic-plot-commands-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Basic plot commands</a></span></li><li><span><a href=\"#Exercise-1\" data-toc-modified-id=\"Exercise-1-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Exercise 1</a></span></li><li><span><a href=\"#Exercise-2\" data-toc-modified-id=\"Exercise-2-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Exercise 2</a></span></li><li><span><a href=\"#The-plot-window-&quot;hack&quot;-in-Spyder\" data-toc-modified-id=\"The-plot-window-&quot;hack&quot;-in-Spyder-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>The plot window \"hack\" in <em>Spyder</em></a></span></li><li><span><a href=\"#The-plot-window-&quot;hack&quot;-in-Jupyter\" data-toc-modified-id=\"The-plot-window-&quot;hack&quot;-in-Jupyter-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>The plot window \"hack\" in <em>Jupyter</em></a></span></li><li><span><a href=\"#Exercise-3\" data-toc-modified-id=\"Exercise-3-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Exercise 3</a></span></li><li><span><a href=\"#Further-readings\" data-toc-modified-id=\"Further-readings-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Further readings</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous chapter we have created our first _NumPy_ arrays (`np.array()`, `np.arange()`). We also learned and applied functions that can be used to analyze these arrays (e.g. `np.mean()`, `np.std()`, `np.sum()`...). Arrays are the common structure in which scientific data is handled in _Python_, _MATLAB_ © and many other programming languages and analysis tools. \n",
    "\n",
    "But what we still miss so far is a method to visualize data, i.e., arrays. Pure _Python_ has no build-in visualization capabilities, but packages like _Matplotlib_ overcome this problem: [matplotlib.org](https://matplotlib.org/stable/index.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Info:</b> It is worth visiting the Matplotlib website (follow link above). The website has many good examples that cover many areas of application:\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure class=\"image\">\n",
    "  <img src=\"img/Matplotlib3.png\" alt=\"NumPy Logo\" style=\"width: 100%;\">\n",
    "  <figcaption>Screenshot of the <a href=\"https://matplotlib.org/stable/index.html\">Matplotlib website</a>. (own screenshot)</figcaption>\n",
    "</figure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic plot commands\n",
    "\n",
    "We start with an easy example and create two arrays `x` any `y`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt # imports most relevant\n",
    "                                # Matplotlib commands\n",
    "\"\"\"if you're working on Google Colab, uncomment the next line:\"\"\"\n",
    "# from google.colab import files \n",
    "\n",
    "# create two NumPy arrays:\n",
    "dx = 1     # step-size\n",
    "length = 2 # length of the x-array\n",
    "\n",
    "x = np.arange(0, length * np.pi, dx) # =length·π\n",
    "y = np.sin(x) # our \"signal\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now plot the _x_-array against the _y_-array via shortest way with Matplotlib (with single-line command, should work in the most _Python_ IDE):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y, '-.', lw=5, label=\"Signal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x+1, y, '-.', lw=5, label=\"Signal\", c=\"cyan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x-1, y, '-d', lw=2, label=\"Signal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.plot(x, y, '-.', lw=5, label=\"Signal\")\n",
    "plt.plot(x+1, y, '-.', lw=5, label=\"Signal\", c=\"cyan\")\n",
    "plt.plot(x-1, y, '-d', lw=2, label=\"Signal\", c=\"pink\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the single-line command is handy and quick, we have options to get some more control over the plot layout and the plot figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(1) # gives us control over the plot window (in Spyder)\n",
    "                    # e.g. open several different plot windows\n",
    "                    # (just change the number in parentheses)\n",
    "fig.clf()           # clears any previous plot in the figure (in Spyder)\n",
    "plt.plot(x,y, label=\"Signal\", lw=3.75) \n",
    "plt.show()          # finalizes the plot (sometimes necessary in Spyder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output still looks the same, so let's add some details such as axis labels, a title and a legend:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(76)\n",
    "fig.clf()\n",
    "\n",
    "plt.plot(x,np.cos(x), label=\"Cosine\", lw=3) \n",
    "plt.plot(x,np.sin(x), \"--\", label=\"Sine\", lw=3) \n",
    "\n",
    "# axis labels and title:\n",
    "plt.xlabel(\"x (distance in radians)\")\n",
    "plt.ylabel(\"y (sin(x))\")\n",
    "plt.title(\"Our first signal\")\n",
    "\n",
    "# shows a legend (best location determined by Matplotlib):\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.tight_layout() # removes unnecessary white space on the figure (in Spyder)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As the plot is gone as soon as we close the figure window, we usually want to save our figure, e.g., as a PDF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig(\"my_plot.pdf\", dpi=120)\n",
    "\"\"\"if you're working on Google Colab, uncomment the next line:\"\"\"\n",
    "# files.download(\"my_plot.pdf\")\n",
    "# or, if you didn't use the fig = plt.figure(1) command (e.g. in Jupyter):\n",
    "# plt.savefig(\"my_plot.pdf\", dpi=120)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(76)\n",
    "fig.clf()\n",
    "\n",
    "plt.plot(x,np.cos(x), label=\"Cosine\", lw=3) \n",
    "plt.plot(x,np.sin(x), \"--\", label=\"Sine\", lw=3) \n",
    "\n",
    "# axis labels and title:\n",
    "plt.xlabel(\"x (distance in radians)\")\n",
    "plt.ylabel(\"y (sin(x) o r cos(x))\", fontweight=\"bold\")\n",
    "plt.title(\"Our first signal\", fontsize=26,\n",
    "          fontweight=\"bold\")\n",
    "\n",
    "# shows a legend (best location determined by Matplotlib):\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.tight_layout() # removes unnecessary white space on the figure (in Spyder)\n",
    "#plt.show()\n",
    "fig.savefig(\"my_plot.tif\", dpi=120)\n",
    "\"\"\"if you're working on Google Colab, uncomment the next line:\"\"\"\n",
    "# files.download(\"my_plot.pdf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the file extension specified in the file name, Matplotlib can automatically determine in which file format the plot should be saved (e.g. \".pdf\" is saved as PDF, \".png\" is saved as PNG, \".jpg\" is saved as JPG)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Info:</b> The statement \"my_plot.pdf\" in the fig.savefig-command creates a PDF (with a resolution of 120 dpi) into the folder, in which your have saved (and executed) your Python script. It is also possible, to define any other path to save the PDF, e.g., \"My_Plots/my_plot.pdf\" or \"/Users/user/Python/my_plot.pdf\". \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "1. Put the NumPy array definitions and the extended Matplotlib commands from above into a script. \n",
    "2. Run the script. \n",
    "3. Vary the step-size `dx`\n",
    "and array-length `length` and re-run the script (repeat this several times if you like to)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 1 here (or create a Python script in Spyder):\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "1. Extend your script from Exercise 3 from the _NumPy_ chapter by _Matplotlib_ commands, so that it\n",
    "    - plots the `time` array vs. the `y` array.\n",
    "    - plots the `time` array vs. the `y_noisy` array (just add another `plt.plot()` command).\n",
    "    - plots the `time` array vs. the `y_denoised_3`.\n",
    "    - plots the `time` array vs. the `y_denoised_6`.\n",
    "2. Add _x_- and _y_-labels and a title to your plot. \n",
    "3. Add a legend to your plot.\n",
    "4. Save your plot as a PDF and as a PNG (also here, just add another `fig.savefig()` command).\n",
    "5. Search on the web for the _Matplotlib_ documentation of the `matplotlib.pyplot.legend` command (note, that due to our import `import matplotlib.pyplot as plt`, this is the full written command-name of our `plt.legend()`). In this documentation, find the argument, that defines the location of the legend. Place the legend to the upper left corner.\n",
    "6. [Choose some colors](https://matplotlib.org/stable/gallery/color/named_colors.html)  that suit your taste and change the color of the plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Previous solution from Exercise 3 from the NumPy chapter:\n",
    "import numpy as np\n",
    "from scipy.ndimage import gaussian_filter1d\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# %% NUMPY: DEFINE SOME DATA WITH NOISE\n",
    "\n",
    "# create data arrays:\n",
    "time = np.arange(0,5, 0.1)\n",
    "y = np.exp(time)\n",
    "\n",
    "# add some noise:\n",
    "y_noisy = y.copy()\n",
    "y_noisy = y_noisy  + np.random.randn(len(time))*10\n",
    "\n",
    "# apply filters:\n",
    "y_denoised_3 = gaussian_filter1d(y_noisy, 3)\n",
    "y_denoised_6 = gaussian_filter1d(y_noisy, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 2 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 2:\n",
    "# %% Plotting\n",
    "\n",
    "fig=plt.figure(1) \n",
    "fig.clf()\n",
    "\n",
    "plt.plot(time, y, label ='raw signal', lw=5, color='y')\n",
    "plt.plot(time, y_noisy, label = 'noisy signal')\n",
    "plt.plot(time, y_denoised_3, \n",
    "         label = 'filter with $\\sigma$=3')\n",
    "plt.plot(time, y_denoised_6,      \n",
    "         label = 'filter with $\\sigma_y^5$=6', c='m') \n",
    "\n",
    "plt.xlabel('time [s]')\n",
    "plt.ylabel('signal')\n",
    "plt.title('Signal vs. noisy signal vs. filtered signal')\n",
    "\n",
    "#plt.legend(loc='best')\n",
    "plt.legend(loc='upper left')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "fig.savefig('my_signal_plot.pdf', dpi=120)\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The statement `$\\sigma$` enables the LaTex interpretation within the labeling command (works also in title and other text annotations)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above multi-line plot commands can also be packed into a single-line command (but with fewer adjustment possibilities):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Single-line solution:\n",
    "plt.plot(time, y, '-r', \n",
    "         time, y_noisy, \n",
    "         time, y_denoised_3, \n",
    "         time, y_denoised_6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib commands can grow big very quickly. It's therefore often usefull to plug these commands into a function definition, in order to keep your script readable and especially when you need to repeat your plot command(s) several times within your script."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The plot window \"hack\" in _Spyder_\n",
    "Prior to _Spyder_ 4.x, any plot was displayed in its own separate plot window. The advantage of these windows was, that they were interactive (to a certain degree), i.e., you could zoom in out without sacrificing resolution. Also, you could pick coordinates, which is sometimes helpful to explore your data. \n",
    "\n",
    "If you want to get rid of the new but static internal plot window, change the following settings in _Spyder_: \n",
    "\n",
    "``` \n",
    "Preferences > IPython console > Graphics > Graphics backend > Backend: Automatic\n",
    "```\n",
    "\n",
    "<figure class=\"image\">\n",
    "  <img src=\"img/MatplotlibHack.png\" alt=\"Matplotlib 'Hack'\" style=\"width: 100%;\">\n",
    "  <figcaption>Matplotlib 'Hack', to enable separate stand-alone plot-windows. (own screenshot)</figcaption>\n",
    "</figure>\n",
    "\n",
    "This enables an interactive, stand-alone plot/figure window for each plot you make. \n",
    "\n",
    "**Hint**: In order to overcome having too many plot windows opened, e.g., emerging from a _for_-loop, you can address each plot window by the `plt.figure(any_numer)` command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The plot window \"hack\" in _Jupyter_\n",
    "In case you want to have an interactive stand-alone plot window using a _Jupyter_ notebook, type the following command once into a code cell of your notebook:\n",
    "\n",
    "~~~py\n",
    "%matplotlib qt\n",
    "~~~\n",
    "\n",
    "After executing that cell, all your further plots will be opened in their own stand-alone window. If you want to turn back to inline plots within your notebook, comment the above command (or remove it) and re-run the cell once with the following command:\n",
    "\n",
    "~~~py\n",
    "# %matplotlib qt\n",
    "%matplotlib inline\n",
    "~~~\n",
    "\n",
    "Many thanks to [Miguel](https://github.com/amgfernandes)  for this  handy trick 😊.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Magic commands:</b> The two commands shown above, that are initialized by the `%` sign, are so-called <i>IPython Magic Commands</i>. There even more of these very useful commands available, just check out this <a href =\"https://ipython.readthedocs.io/en/stable/interactive/magics.html?highlight=magic%20commands\">documentation website</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternative backends (instead of \"qt\"): \n",
    "Key backend: 'gtkagg' is not a valid value for backend; supported values are ['GTK3Agg', 'GTK3Cairo', 'MacOSX', 'nbAgg', 'Qt4Agg', 'Qt4Cairo', 'Qt5Agg', 'Qt5Cairo', 'TkAgg', 'TkCairo', 'WebAgg', 'WX', 'WXAgg', 'WXCairo', 'agg', 'cairo', 'pdf', 'pgf', 'ps', 'svg', 'template']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "\n",
    "\n",
    "1. Create a new script and define the following _NumPy_ arrays as dummy data arrays:\n",
    "```\n",
    "    np.random.seed(1)\n",
    "    Group_A = np.random.randn(10) * 10 + 5\n",
    "    Group_B = np.random.randn(10) * 10 + 2\n",
    "```\n",
    "2. Plot the averages of `Group_A` and `Group_B` in a bar-plot in figure 1:\n",
    "    - use the plot command `plt.bar([1, 2], [\"Mean of Group A\", \"Mean of Group B\"])`. Hint: `\"Mean of Group A\"` and `\"Mean of Group B\"` are just placeholders! Replace this with the according _NumPy_ averaging command.\n",
    "    - define the x-tick labels via `plt.xticks([1,2], labels=[\"A\", \"B\"])`\n",
    "    - add appropriate _x_- and _y_-labels and a title to your plot. \n",
    "    - save your plot as a PDF.\n",
    "3. Plot the values of `Group_A` and `Group_B`, respectively, in a boxplot in figure 2:\n",
    "    - set the figure aspect ratio to 5x6 via `fig=plt.figure(2, figsize=(5,6))`\n",
    "    - use the plot command `plt.boxplot([Group_A, Group_B])`\n",
    "    - define the x-tick labels via `plt.xticks([1,2], labels=[\"A\", \"B\"])`\n",
    "    - add appropriate _x_- and _y_-labels and a title to your plot. \n",
    "    - save your plot as a PDF.\n",
    "4.  Same as 3., but now use the command `plt.violinplot([Group_A, Group_B], showmedians=True)` to plot the values in figure 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 3.1 here:\n",
    "\n",
    "# Generate some random dummy data:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 3.1\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Generate some random dummy data:\n",
    "np.random.seed(1)\n",
    "Group_A = np.random.randn(10)*10+5\n",
    "Group_B = np.random.randn(10)*10+2\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 3.2 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 3.2\n",
    "fig=plt.figure(1)\n",
    "fig.clf()\n",
    "\n",
    "plt.bar([1, 2], [Group_A.mean(), Group_B.mean()])\n",
    "\n",
    "plt.xticks([1, 2], labels=[\"A\", \"B\"])\n",
    "plt.xlabel(\"Groups\")\n",
    "plt.ylabel(\"measurements\")\n",
    "plt.title(\"Bar-plot of group averages\")\n",
    "\n",
    "plt.tight_layout\n",
    "plt.show()\n",
    "fig.savefig(\"barplot.pdf\", dpi=120)\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 3.3 here:\n",
    "# Solution 3.3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 3.3\n",
    "fig=plt.figure(2, figsize=(5,6))\n",
    "fig.clf()\n",
    "\n",
    "x_ticks_A = np.ones(len(Group_A))\n",
    "x_ticks_B = np.ones(len(Group_B))\n",
    "\n",
    "plt.boxplot([Group_A, Group_B])\n",
    "\n",
    "plt.xticks([1,2], labels=[\"A\", \"B\"])\n",
    "plt.xlabel(\"Groups\")\n",
    "plt.ylabel(\"measurements\")\n",
    "plt.title(\"Boxplot diagram\")\n",
    "plt.tight_layout\n",
    "plt.show()\n",
    "fig.savefig(\"boxlot.pdf\", dpi=120)\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your solution 3.4 here:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "<summary><strong>Toggle solution</strong></summary>\n",
    "\n",
    "```python\n",
    "# Solution 3.4\n",
    "fig=plt.figure(3, figsize=(5,6))\n",
    "fig.clf()\n",
    "\n",
    "plt.violinplot([Group_A, Group_B], showmedians=True)\n",
    "#plt.boxplot([Group_A, Group_B])\n",
    "\n",
    "plt.xticks([1,2], labels=[\"A\", \"B\"])\n",
    "plt.xlabel(\"Groups\")\n",
    "plt.ylabel(\"measurements\")\n",
    "plt.title(\"Violin plot\")\n",
    "plt.tight_layout\n",
    "plt.ylim(-40, 40)\n",
    "plt.show()\n",
    "fig.savefig(\"violinplot.pdf\", dpi=120)\n",
    "``` \n",
    "<script src=\"https://gist.github.com/username/a39a422ebdff6e732753b90573100b16.js\"></script>\n",
    "</details>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further readings\n",
    "In this course, we can not go too far into depth of the topics of each chapter. This is also the case in this chapter. The power and functions of _Matplotlib_ are incredible, we only touched a few aspects of them. If you want to explore its full potential, as already stated at the beginning of this chapter, visit the  [_Matplotlib_ website](https://matplotlib.org/stable/index.html), which contains many good examples and an excellent documentation. For example, explore more\n",
    "\n",
    "* [linestyles, markerstyles and colors](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html). This documentation page also contains a list of additional `pyplot` (`plt.plot()`) arguments like\n",
    "    * `alpha` (adjusting opacity of the plotted line)\n",
    "    * `color`, `c` (define the color of a plotted line)\n",
    "    * `label` (gives your line a name, that the `plt.legend()` then uses to show it in a legend)\n",
    "    * `linestyle`, `ls` (defines the linestyle)\n",
    "    * `linewdth`, `lw`(defines the linewidth)\n",
    "    * `marker` (defines the marker style)\n",
    "    * `markeredgecolor`, `mec` and `markerfacecolor`, `mfc` (defines the color of the chosen marker)\n",
    "    * `markersize`, `ms` (defines the size of the chosen marker)\n",
    "* about [adjusting the legend](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html)\n",
    "* and [colors](https://matplotlib.org/stable/gallery/color/named_colors.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fcd80e42880>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example:\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot([1,2,3,4], [1,4,9,16], ls='-', marker=\"o\", \n",
    "         label=\"my line A\")\n",
    "plt.plot([1,2,3,4], [1,3,5,9], ls='-', marker=\"s\",\n",
    "         label=\"my line B\", markersize=10, c=\"r\")\n",
    "plt.plot([1,2,3,4], [1,6,8,12], ls=\"\" ,marker=\"d\",\n",
    "         label=\"my line B\", markersize=10, c=\"c\")\n",
    "#plt.plot([1,2,3,4], [1,4,9,16], 'ro', label=\"my line A\")\n",
    "#plt.plot([1,2,3,4], [1,3,5,9], 'go', label=\"my line B\")\n",
    "plt.axis([0, 6, 0, 20])\n",
    "plt.legend()\n",
    "#plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fcd78243d60>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example:\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot([1,2,3,4], [1,4,9,16], 'r-', label=\"my line A\")\n",
    "plt.plot([1,2,3,4], [1,3,5,9], 'g-o', label=\"my line B\")\n",
    "# similar to:\n",
    "#plt.plot([1,2,3,4], [1,3,5,9], ls='--', c=\"g\", \n",
    "#         label=\"my line B\", marker=\"o\")\n",
    "plt.axis([0, 6, 0, 20])\n",
    "plt.legend()\n",
    "#plt.show()"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "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.16"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Data Visualization with Matplotlib",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "4dbe93ddc4bed5499d29720f38f7446a34b15f2f3201b881b9bf1c1a4baa393f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}