From 46b2dd2f2efea0539e4d8469642b1f4a6e1f316f Mon Sep 17 00:00:00 2001 From: "Marco A. Lopez-Sanchez" Date: Mon, 5 Feb 2024 20:43:06 +0100 Subject: [PATCH] Update Matplotlib_walkthrough.ipynb language improvements --- notebooks/Matplotlib_walkthrough.ipynb | 101 ++++++++++++++----------- 1 file changed, 57 insertions(+), 44 deletions(-) diff --git a/notebooks/Matplotlib_walkthrough.ipynb b/notebooks/Matplotlib_walkthrough.ipynb index 91d7afe..d3a13a0 100644 --- a/notebooks/Matplotlib_walkthrough.ipynb +++ b/notebooks/Matplotlib_walkthrough.ipynb @@ -11,10 +11,10 @@ "Content under [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) License](http://creativecommons.org/licenses/by-nc-sa/4.0/).\n", "\n", "> **Goal**: \n", - "> Learn the basics of the Matplotlib library and use the examples to expand our knowledge of the Python language \n", + "> Learn the basics of the Matplotlib library and extend your knowledge of the Python language through examples.\n", "> \n", "> **What it is?** \n", - "> Matplotlib is the standard data visualization tool in Python. It allows creating static, animated and interactive visualizations. Many other Python visualization tools (e.g. seaborn) are built on top of Matplotlib. See https://matplotlib.org/ \n", + "> Matplotlib is the standard data visualisation tool in Python. It allows the creation of static, animated and interactive visualisations. Many other Python visualisation tools (e.g. seaborn) are built on top of Matplotlib. See https://matplotlib.org/ \n", ">\n", "> **What it is used for?** \n", "> Analize, explore, and show relationships between data.\n", @@ -22,7 +22,7 @@ "> **Useful resources** \n", "> https://matplotlib.org/ (official website) \n", "> https://matplotlib.org/stable/index.html (official documentation website) \n", - "> https://matplotlib.org/cheatsheets/ (official matplolib cheatsheets) \n", + "> https://matplotlib.org/cheatsheets/ (official matplotlib cheatsheets) \n", "> https://matplotlib.org/stable/gallery/index.html (official matplotlib gallery with example plots) \n", "> [Basics of Data Visualisation in Python Using Matplotlib](https://thepythoncodingbook.com/basics-of-data-visualisation-in-python-using-matplotlib/) from \"The Python Coding Book\" \n", "\n", @@ -30,7 +30,7 @@ "\n", "## Making your first plot\n", "\n", - "The first thing to do is to import pyplot, which is the submodule of matplotlib that allows creating figures. By Python standards, this is done in the following way" + "The first thing to do is to import pyplot, the submodule of matplotlib that allows you to create plots. By Python standards, this is done as follows" ] }, { @@ -58,7 +58,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 2, @@ -90,11 +90,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> 🚨 Depending on the Python environment you are using, you may have to call the ``plt.show()`` command to display the figures. This is not necessary for Jupyter notebooks, as by default plots are automatically displayed in the document.\n", + "> 🚨 Depending on the Python environment you are using, you may need to call the ``plt.show()`` command to display the plots. This is not necessary for Jupyter notebooks, as plots are automatically displayed in the document by default.\n", "\n", "## Customising the plot\n", "\n", - "You can customise the plot by adding the type of marker, its size, labels and titles (almost anything you can think of really). For this, you can add different parameters to the built-in functions of the pyplot submodule (e.g. color, markersize, fontsize, etc.) or add new functions (e.g. ``xlabel``, etc.) as in the example below" + "You can customise the plot by adding the marker types, sizes, labels and titles (almost anything you can think of really). You can do this by adding different parameters to the built-in functions of the pyplot submodule (e.g. ``color``, ``markersize``, ``fontsize``, etc.) or by adding new functions (e.g. ``xlabel``, etc.) as in the example below" ] }, { @@ -154,7 +154,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -170,7 +170,8 @@ "rgn = np.random.default_rng()\n", "normal = rgn.standard_normal(size=10000)\n", "\n", - "plt.hist(normal, 50, density=True, facecolor='green', alpha=0.75) # here we use the funtion hist() to plot a histogram of the data\n", + "# plot the data\n", + "plt.hist(normal, 50, density=True, facecolor='green', alpha=0.75) # here we use the funtion hist() to plot a histogram\n", "plt.grid(True) # add a grid\n", "plt.xlabel('some variable', fontsize=20)" ] @@ -180,7 +181,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You can call ``plot()`` or any other plot type (e.g. ``hist()``, ``scatter()``, ``bar()``...) as many times as you want. **By default**, matplolib will keep adding data to the same figure" + "You can call ``plot()`` or any other plot type (e.g. ``hist()``, ``scatter()``, ``bar()``...) as many times as you like **By default**, matplolib will keep adding data to the same figure" ] }, { @@ -191,7 +192,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -218,7 +219,7 @@ "\n", "plt.grid(True)\n", "plt.xlabel('this is label x', fontsize=20)\n", - "plt.legend(fontsize=18) # here we add a legend, note that it uses the labels set within the plot() function!" + "plt.legend(fontsize=18) # add a legend, note that it uses the labels set within the plot() function!" ] }, { @@ -226,26 +227,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "> More abourt markers: https://www.w3schools.com/python/matplotlib_markers.asp\n", + "> More abourt markers: https://matplotlib.org/stable/api/markers_api.html\n", "\n", "# The Matplotlib object-oriented interface\n", "\n", - "Originally Matplotlib was created with an interface miming how MATLAB programming language creates figures. This is called a state-based or MATLAB-like interface and was used in all the examples above. Using this way of creating figures, the main syntax difference between MATLAB and Matplotlib is to add the ``plt.`` before stating the methods (e.g. ``plt.scatter()`` instead of ``scatter()``) but with the key difference that by default Matplotlib will keep adding data/elements to the same figure unless you create a new figure and MATLAB does the opposite. This state-based interface is handy and fine for generating basic graphics quickly, i.e. one-liners, and exploring the data, but if you need to have full control and a deeper understanding of the figure you should use the **object-oriented interface**. Matplotlib strongly promotes the use of this interface so we are going to go deeper into it.\n", + "Matplotlib was designed with an interface that mimics the way the MATLAB programming language creates plots. This is commonly referred to as the state-based or MATLAB-like interface and is what we have used in all the examples above. When using this interface to create plots, the main syntactical difference between MATLAB and Matplotlib is the addition of ``plt.`` before calling the methods (e.g. ``plt.scatter()`` instead of ``scatter()``). Also, by default, Matplotlib continues to add data/elements to the same plot until a new plot is created, whereas MATLAB does the opposite. This state-based interface is handy and fine for quickly generating basic graphics, i.e. one-liners when exploring data, but if you need full control and a deeper understanding of how to generate a plot, **you should use the object-oriented interface**. Matplotlib strongly encourages the use of this interface, so will look at it in more detail.\n", "\n", - "> 🚨 In the past, most Matplotlib users came from MATLAB and used the state-based interface. Due to this, most examples on the internet (apart from the official Matplotlib documentation) are state-based. This trend is fortunately changing. However, when you search for Matplotlib examples on the web you will find examples of both types of interfaces. This has brought a lot of confusion for newcomers, as in the past most tutorials did not explain that these two types of interfaces exist.\n", + "> 🚨 In the past, most Matplotlib users came from MATLAB and used the state-based interface. As a result, most examples on the internet (apart from the official Matplotlib documentation) are state-based. Fortunately, this trend is changing. However, if you search for Matplotlib examples on the web, you will find examples of both types of interfaces. This has caused a lot of confusion for newcomers, as in the past most tutorials did not explain that these two types of interfaces exist.\n", "\n", - "All the main parts of a matplolib figure are depicted in the \"anatomy of a figure\" below.\n", + "All the main parts of a matplolib figure are depicted in the \"Anatomy of a figure\" below.\n", "\n", "![anatomy](https://raw.githubusercontent.com/marcoalopez/Python_course/main/notebooks/imgs/sphx_glr_anatomy_002.webp) \n", "_Figure 1. Anatomy of a Matplotlib plot as depicted in the official Matplotlib documentation_\n", "\n", - "To avoid confusion, we will clarify the elements that may confuse newcomers the most.\n", + "To avoid confusion, we will explain the elements that can confuse newcomers the most.\n", "\n", "- **Figure** is like the canvas that contains all the elements of the final figure.\n", - "- **Axes** is the area where the data will be rendered. You can have from one to many axes as you like per figure.\n", - "- **Axis** the x- and y-axis of a 2D plot. Each axe of the figure can have two or three Axis.\n", + "- **Axes** is the area where the data is rendered. You can have any number of axes per figure.\n", + "- **Axis** are the x- and y-axis of a 2D plot above. Each figure axe can have two (x, y) or three (x, y, z) axis.\n", "\n", - "The first thing to do to create a figure in the OO interface is to call the function ``plt.subplots()`` as follows" + "The first thing to do to create a figure in the OO interface is to call the ``plt.subplots()`` function as follows" ] }, { @@ -274,7 +275,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that the ``plt.subplot()`` returns two different objects, a figure and the axes, in this case one axe." + "Note that the ``plt.subplot()`` returns two different objects, a figure and the axes, in this case an axe." ] }, { @@ -313,7 +314,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 8, @@ -355,7 +356,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 9, @@ -386,7 +387,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let us dwell on some important details by comparing the two figures above. In the first example, the different axes were unpacked using a tuple (e.g. ``(ax_left, ax_right)``), but in the second case all the axes are contained within the object called ``axes``. Let's check" + "Let us dwell on some important details by comparing the two figures above. In the first example, the different axes have been unpacked using a tuple (e.g. ``(ax_left, ax_right)``), but in the second example all the axes are contained in the object called ``axes``. Let's check" ] }, { @@ -415,25 +416,37 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Axes contains a list with two sub-lists which in turn contain each of the axes (each sub-list represents one row with two axes). To access each of them individually, one can use Python indexing. This is precisely what the example is doing using ``axes[1,1].plot``. Specifically, we are indicating that we want to display the data in the axe that corresponds to the list with index 1 and the element with index 1 of such list (remember that Python indexes start from 0). An alternative would be to unpack the different axes in the following way\n", + "Now the ``axes[0,0]`` would have been reassigned as ``ax1``, ``axes[0,1]`` to ``ax2``, and so on. You can do as you prefer, the advantage of the first approach is that it allows you to loop over the axes, saving you a few lines of code in certain cases. We'll see some examples of this later.\n", + "\n", + "So far, we have used different parameters within the subplots function to control different elements of the figure. These are the most important ones to be aware of:\n", + "\n", + " - ``figsize`` the width and height of the figure in inches. By default (6.4, 4.8).\n", + " - ``dpi``: the resolution of the figure in dots per inch. The default is 100.\n", + " - ``ncols, nrows``: the number of columns and rows, respectively.\n", + " - ``sharex, sharey``: Share the x and/or y axis. Bool, the default is false.\n", + " - ``constrained_layout``: Automatically adjusts subplots and decorations such as legends and colour bars to fit optimally into the figure window, while preserving as far as possible the logical layout requested by the user. Bool, the default is false.\n", + "\n", + " > 👉 To control the resolution of the figure in pixels, you need to play with the ``figsize`` and ``dpi`` parameters at the same time.\n", + "\n", + "For complex layouts, Matplotlib offers several options, but one of the simplest and, sadly, underused is the ``plt.subplot_mosaic()`` function, which works as follows\n", "\n", "```python\n", "((ax1, ax2), (ax3, ax4)) = axes\n", "````\n", "\n", - "Now the ``axes[0,0]`` would have been reassigned as ``ax1``, ``axes[0,1]`` to ``ax2``, and so on. You can do as you prefer, the advantage of the first approach is that it allows you to loop over the axes, saving you some code lines in specific cases. We'll see some examples of this later.\n", + "Now the ``axes[0,0]`` would have been reassigned to ``ax1``, ``axes[0,1]`` to ``ax2``, and so on. You can do as you prefer, the advantage of the first approach is that it allows you to loop over the axes, saving you a few lines of code in certain cases. We'll see some examples of this later.\n", "\n", - "So far, we have used different parameters within the subplots function to control different elements of the figure. These are the most important ones you should be aware of:\n", + "So far, we have used different parameters within the subplots function to control different elements of the figure. These are the most important ones to be aware of:\n", "\n", " - ``figsize`` the width and height of the figure in inches. By default (6.4, 4.8).\n", - " - ``dpi``: the resolution of the figure in dots-per-inch. Default is 100.\n", - " - ``ncols, nrows``: number of columns and rows, respectively.\n", - " - ``sharex, sharey``: Share the x and/or y axis. Bool, default is False\n", - " - ``constrained_layout``: automatically adjusts subplots and decorations like legends and colorbars so that they fit in the figure window while still preserving, as best they can, the logical layout requested by the user. Bool, default is False.\n", + " - ``dpi``: the resolution of the figure in dots per inch. The default is 100.\n", + " - ``ncols, nrows``: the number of columns and rows, respectively.\n", + " - ``sharex, sharey``: Share the x and/or y axis. Bool, default is false.\n", + " - ``constrained_layout``: Automatically adjusts subplots and decorations such as legends and color bars to fit optimally into the figure window, while preserving as far as possible the logical layout requested by the user. Bool, default is false.\n", "\n", - " > 👉 To control the resolution of the figure in pixels you must play with the ``figsize`` and ``dpi`` of the figure at the same time.\n", + " > 👉 To control the resolution of the figure in pixels, you need to play with the ``figsize`` and ``dpi`` parameters at the same time.\n", "\n", - " For complex layouts, matplotlib offers several options but one of the simplest and, sadly, underused is the ``plt.subplot_mosaic()`` function that work as follows" + "For complex layouts, matplotlib offers several options, but one of the simplest and, sadly, underused is the ``plt.subplot_mosaic()`` function, which works as follows" ] }, { @@ -470,7 +483,7 @@ "\n", "---\n", "\n", - "Now, let customise a plot using the OO interface" + "Now, let us customise a plot using the OO interface." ] }, { @@ -518,19 +531,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As you can see, it is a matter of adding new elements to specific ``axes`` and the options available to tweak the figure are quite extensive.\n", + "As you can see, it is a matter of adding new elements to specific ``axes`` and the options available for tweaking the figure are quite extensive.\n", "\n", - "By default, matplolib provides more than 20 types of two-dimensional plots plus other types of projections such as polar and three-dimensional, some of them summarised below.\n", + "By default, Matplolib provides more than 20 types of two-dimensional plots, plus other types of projections such as polar and three-dimensional, some of which are summarised below.\n", "\n", "![mpl_cheatsheet](https://raw.githubusercontent.com/marcoalopez/Python_course/c13aa4d2c6ff86842e44baa951fe7f6722446635/notebooks/imgs/mpl_cheatsheet.png) \n", "_Summary of some of the plot types included in the matplolib library as presented in the matplolib cheatsheet here https://matplotlib.org/cheatsheets/. \n", "You may also want to check the official matplotlib gallery https://matplotlib.org/stable/gallery/index.html_\n", "\n", - "We will be using different plot types throughout the different examples contained in the notebooks of this course. Matplotlib, however, will allow you any kind of plot you can think of even if it is not included in the default figure types. This is of course outside the scope of the course, but you will find more information at the end of this notebook in the \"Going further\" section.\n", + "We will use different common plot types throughout the course. However, Matplotlib allows you to create any type of plot you can think of, even if it is not included in the standard plot types. This is beyond the scope of this course, but you can find more information about it at the end of this notebook in the \"Further reading\" section.\n", "\n", "## Save your figure\n", "\n", - "So far, we have never used the object ``fig``. This is normal, as most of the time you will be dealing with axes. An example where you will use this _figure object_ is when you want to save a figure on your hard disk. This is done using the ``savefig()`` method as follows" + "So far, we have never used the object ``fig`` created by ``plt.subplots``. This is normal, as most of the time you will be dealing with axes. One example where you will use this _figure object_ is when you want to save a figure. This is done using the ``savefig()`` method as follows" ] }, { @@ -547,13 +560,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this case, we specify the name of the file ``figure01`` and the format ``.png`` using a string, the resolution in dpi, and a parameter to ensure that no element of the figure is cut. By default, the file will be saved in the same folder where you have the Jupyter notebook, you can specify full or relative addresses without any problem. For example, using ``'figures/figure01.png'`` will create the folder _figures_ and then store de _figure01_ there. As any other functions, the ``savefig()`` function allows you to control a number of features through different parameters, you can see the options here https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.savefig.html\n", + "In this case, we specify the name of the file ``figure01`` and the format ``.png`` using a string, the resolution in dpi, and a parameter to ensure that no element of the figure is cut. By default, the file is saved in the same folder as the Jupyter Notebook, but you can specify full or relative paths without any problem. For example, using ``'figures/figure01.png'`` will create the folder _figures_ and then save de _figure01_ there. As with any other function, the ``savefig()`` allows you to control a number of features through various parameters, you can see the options here https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.savefig.html\n", "\n", "# Matplotlib styles\n", "\n", - "Other than the default style, Matplotlib has different available style sheets to change the default appearance of your figures. You have a list of style sheets here https://matplotlib.org/stable/gallery/style_sheets/style_sheets_reference.html\n", + "Besides the default style, Matplotlib has several style sheets available to change the default appearance of your plots. You can find a list of style sheets here https://matplotlib.org/stable/gallery/style_sheets/style_sheets_reference.html\n", "\n", - "To change the default look of your figures you can do as follows" + "To change the default look of your plots, you can do as follows" ] }, { @@ -564,7 +577,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -620,7 +633,7 @@ "source": [ "# Going further\n", "\n", - "You can use matplolib for just about anything you can think of. A good source of inspiration is the book [Scientific Visualization: Python + Matplolib](https://github.com/rougier/scientific-visualization-book) by Nicolas P. Rougier where you can find impressive examples of what you can do (just take a look at the picture gallery!).\n", + "You can use Matplolib for almost anything you can think of. A good source of inspiration is the book [Scientific Visualization: Python + Matplolib](https://github.com/rougier/scientific-visualization-book) by Nicolas P. Rougier, where you can find impressive examples of what you can do (just take a look at the picture gallery!).\n", "\n", "Some scientific-oriented Python plotting libraries that depends on matplotlib are: \n", "- [Seaborn](https://seaborn.pydata.org/): statistical graphics build on-top of matplotlib. It presents many types of statistical diagrams and can save you many lines of code. \n", @@ -644,7 +657,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Notebook tested in 2024-01-09 using:\n", + "Notebook tested in 2024-02-05 using:\n", "Python 3.10.13 | packaged by Anaconda, Inc. | (main, Sep 11 2023, 13:15:57) [MSC v.1916 64 bit (AMD64)]\n", "Matplotlib 3.8.0\n" ]