python_essentials_III_session_02_colab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# Session 2\n",
    "\n",
    "## NumPy, Matplotlib and Pandas\n",
    "\n",
    "The core of Python includes the basic features of the language. All other features are included in separate packages (called libraries or toolboxes in other programming languages). During this session we will have a first look at arrays and dataframes, create some simple graphs and fit a line through some data.\n",
    "\n",
    "The package for creating and manipulating arrays is called `numpy`. The `numpy` package also includes a set of very useful functions, including basic mathematical functions (`cos`, `exp`, `log`, `sum`, etc.). An in-depth discussion of `numpy`'s functionality is impossible here, but useful resources can be found online, including at <A href=\"https://numpy.org/doc/stable/reference/\">https://numpy.org/doc/stable/reference/</A>.\n",
    "\n",
    "The main package for plotting in Python is `Matplotlib`. It is a comprehensive plotting package that is highly versatile. The <A href=\"https://matplotlib.org/stable/gallery/index.html\"> gallery on the Matplotlib webpage</A> is a great resource to discover  the possibilities to create fantastic plots and animations. \n",
    "\n",
    "`Pandas` is the package that handles dataframes. Dataframes are a bit similar to arrays but they have additional functionalities that make working with large datasets, especially time series data, a lot easier. A good starting point for more information is <A href=\"https://pandas.pydata.org/docs/user_guide/index.html\">https://pandas.pydata.org/docs/user_guide/index.html</A>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays and NumPy\n",
    "\n",
    "Before a package can be used, it needs to be imported. The following line imports the `numpy` package and renames it to `np` (the default short name used by essentially everyone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Once the package is imported this way, all of its functions can be called as `np.function_name()`. For example, the `sqrt` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "np.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating arrays\n",
    "\n",
    "There are multiple ways to create an array. For example, a `list` can be converted to a `numpy` `array` with the `np.array()` command. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The `type` function shows that the array is defined within the `numpy` package as an `ndarray`, which stands for n-dimensional array. All elements within such an array have the same variable type (remember that a `list` can contain items of different variable types).\n",
    "\n",
    "A two-dimensional array can be thought of as a matrix with rows and columns. It can be created by entering a list of rows, where each row is again a list that contains the values for that row. Care must be taken that each of the lists has the same number of elements (equal to the number of columns). When the array is printed to the screen, each row is on a separate line and the columns are separated by a space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "A = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The shape of an array can be obtained by calling the `shape` function. For a two-dimensional array it returns the number of rows and columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "print(np.shape(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2.1***: Use list comprehension to create a one-dimensional array that contains the square of all whole numbers between 1 and 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Functions that work for individual numbers can also be used on arrays, for example `numpy`'s `sqrt` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "print('sqrt(a) gives:', np.sqrt(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Arithmetic operators can also be be used with arrays. The following code defines an array `b` and multiplies the arrays `a` and `b` element by element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "b = np.array([2, 2, 3, 3])\n",
    "print('a * b gives:', a * b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Those working with matrices might have expected a different outcome: The dot product. The dot product of arrays `a` and `b` of length `N` (i.e., $\\sum_{n=1}^N a_nb_n$) is obtained by using the `@` operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a @ b # Or, alternatively: np.dot(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "In addition to converting a list to an array using the `np.array()` function, arrays can be generated with the `np.arange` function (similar to the `range` function used earlier, but now resulting in an array). The `arange(start, end_before, step)` function creates an array starting at `start`, taking steps equal to `step` and stopping (remember again) before it reaches the specified `end_before` value. If only a single value is passed to the function, it is  interpreted to be the `end_before` value (i.e., the default values for `start` and `step` are 0 and 1, respectively). The following examples demonstrate this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "print(np.arange(3)) # so start=0 and step=1\n",
    "print(np.arange(2, 6)) # step=1\n",
    "print(np.arange(2, 10, 2))\n",
    "print(np.arange(10, 0, -2)) # steps can be negative\n",
    "print(np.arange(2, 10, 2.0)) # now returns array of floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Using a negative `step` is possible as long as the `start` argument is larger than the `end_before` argument. Note that the default type of `np.arange` is integers unless one of the arguments is a float. \n",
    "\n",
    "Instead of specifying a `step`, it is also possible to create an array by specifying the number of elements using the `np.linspace(begin, end, num)` function. The following function call returns seven points with values of equal increment from 1 to 4. Note that, somewhat confusingly, and unlike `range` and `np.arange`, the `end` value in `linspace` is included as the last element of the array! The default return value of `np.linspace` is an array of floats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "np.linspace(1, 4, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Arrays can be reshaped as long as the new shape is compatible with the old shape. For example, a one-dimensional array with 12 elements can be reshaped into a two-dimensional array with 3 rows and 4 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a = np.arange(12)\n",
    "print(a)\n",
    "b = np.reshape(a, (3, 4))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "### Slicing arrays\n",
    "Just like for a `list`, the individual elements of an array can be accessed by indexing using square brackets (remember that the first index has number 0). For a one-dimensional array `x ` this  would look like `x[start:end_before]` or `x[start:end_before:step]`. If the `start` or `end_before` isn't specified, 0 will be used. If the `step` isn't specified, 1 will be used. \n",
    "\n",
    "When programming, the index of the end is generally not known as the array size can vary. To find out how long the array is and access the last value of array `x` one could type `x[len(x)-1]`, but that is a bit inconvenient. Luckily, there is a shortcut: `x[-1]` is the same as `x[len(x)-1]` and represents the last value in the array. Typing `x[-2]` returns the second to last value in the array, etc..\n",
    "\n",
    "The following code examples show some of the various array slicing options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "x = np.arange(20, 30)\n",
    "print(x)\n",
    "print(x[0])\n",
    "print(x[0:5])\n",
    "print(x[:5]) # result is the same as for the previous line\n",
    "print(x[-5:]) # returns the last 5 values\n",
    "print(x[3:7])\n",
    "print(x[2:9:2]) # step is 2\n",
    "print(x[-1:4:-2]) # starts at back, stops before reaching index 4 with step -2\n",
    "print(x[[0, 3, 7]]) # passes indices as a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2.2***: The code cell below defines the array `y` which contains five elements. Use array slicing to calculate the difference between each consecutive element. The first number should be the difference between 5 and 1 (= 4), the second number between 3 and 5 (= -2), and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Slicing two-dimensional arrays requires specification of the row and column indices, either explicitly or implicitly as shown in the code below, which illustrates some ways to select single numbers, individual rows or columns and two-dimensional subarrays. Once more: Recall that the first row of a two-dimensional array is row 0, and the first column is column 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "print(A)\n",
    "print(A[1, 2]) # second row, third column\n",
    "print(A[1])  # second row\n",
    "print(A[1, :]) # alternative for the second row\n",
    "print(A[:, 0])  # first column\n",
    "print(A[1:3, 1:3]) # an array with the second and third rows and columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "#### Slicing arrays with conditional operators\n",
    "Parts or values of an array may also be selected based on conditions. This is called advanced slicing. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a = np.arange(5)\n",
    "print(a)\n",
    "print(a < 3) # a < 3 returns a Boolean array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Because `<` is a conditional operator, the statement `a < 3` returns a boolean array. Instead of printing the outcome to the screen as in the above example, a more useful application is to store it as a variable. The variable can then be used to slice the array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "idx = a < 3\n",
    "print('values in array a less than 3:', a[idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The `~` operator swaps the `True` and `False` values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "print('values in array not less than 3:', a[~idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "For more compact and readable code, the conditional statement can  be specified inside the square brackets. It can even be used to assign a different value to selected elements of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a[a < 3] = 10  # Replace all values less than 3 by 10\n",
    "print('new a:', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "Conditions for indices can be compounded with either `&` (and) or `|` (or), when the conditions are put between parentheses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "print('array:', a)\n",
    "print('larger than 3 and less than 7:', a[(a > 3) & (a < 7)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2.3***: Find the numbers in `a` that are less than 2 *or* larger than 8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "## Basic graphs with Matplotlib\n",
    "\n",
    "\n",
    "Most of `matplotlib`'s plotting capabilities are available in the subpackage `pyplot`, which is commonly renamed as `plt` when imported. All figures can be included inline in a notebook (rather than in a separate window) with the IPython magic command `%matplotlib inline`. IPython `magic commands` are preceded with a `%`. They are not standard Python commands and only work within IPython environments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The following two lines of code compute $\\sin(x)$ for 100 values of $x$ between 0 and $\\pi$, and then plot $\\sin(x)$ vs. $x$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, np.pi, 100)\n",
    "plt.plot(x, np.sin(x));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "The plot function has many, many options, as may be seen from the documentation. \n",
    "A more complex graph with multiple lines, labels along the axes, and a legend is shown below. `matplotlib` uses a different color for each line that is plotted. The default colors are called `C0`, `C1`, `C2`, etc. Alternatively, a different color can be specified. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2 * np.pi, 50)\n",
    "y1 = np.sin(x)\n",
    "y2 = np.cos(x)\n",
    "plt.plot(x, y1, '-', label='sin(x)')  # plotted with default color C0\n",
    "plt.plot(x, y2, color='C4', lw=2, label='cos(x)')  # linewidth (lw) is 2\n",
    "plt.xlabel('x-axis')\n",
    "plt.ylabel('y-axis')\n",
    "plt.legend(); # selects best spot for legend unless loc is specified"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2.4***: Change the code block above so that the color of the second line is one of the default Matplotlib colours instead of purple. Also plot the sine function as individual dots instead of a line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataframes and Pandas\n",
    "\n",
    "A `DataFrame` is a 2-dimensional labeled data structure with columns of potentially different types. You can think of it as a spreadsheet table, and it resembles an array, but it has lots of additional functionality. A DataFrame typically has row labels (called an index) and column names. The best way to get familiar with DataFrames is probably by looking at a practical example. Here we will use `Pandas` `read_csv` function to read a file with stream discharge and stage data and we will use `NumPy` to fit a power function to the stage-discharge relationship (also known as a rating curve).\n",
    "\n",
    "The data used are for stream gauging station USGS 09246500 ELKHEAD CREEK NEAR CRAIG, CO, which can be found on https://waterdata.usgs.gov/nwis/measurements/?site_no=09246500.\n",
    "\n",
    "The code cell below shows how the file can be imported. It is a tab-delimited text file with various header lines. The `read_csv` function takes the following arguments:\n",
    "\n",
    " - the file name (09246500_Q-h_data.txt)\n",
    " - the column delimiter, in this case a tab, which is indicated by `\\t`\n",
    " - the number of the column that should become the index (i.e., the row labels)\n",
    " - a boolean that indicates if the values of the index column should be converted to dates\n",
    " - a list with the numbers of the header lines to skip (open the file in a text editor and check if you understand how list comprehension is used in this case to get the lines we need)\n",
    " \n",
    "Before executing the `read_csv` command, `Pandas` must be imported. Once the file has been read, the `DataFrame` is available as `df`. The `head()` function can be used to see the first 5 rows of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/vincentpost/PythonEssentialsIII/main/09246500_Q-h_data.txt\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('09246500_Q-h_data.txt', \n",
    "                 sep='\\t',\n",
    "                 index_col=3,\n",
    "                 parse_dates=True,\n",
    "                 skiprows=[i for i in range(16) if i != 14])\n",
    "\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The column names used by the USGS are a bit cryptic, but the stream stage is under `gage_height_va` and the measured discharge is called `discharge_va`. To get a first idea of the data, we can plot the stage versus time. Remember that the dates were used for the DataFrame's index, so they can be accessed using `df.index`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(df.index, df['gage_height_va'], '.-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The goal is to use these measurements to derive a stage-discharge relationship. In order to do so, we want to select only the most reliable data, which in this case have the qualification 'Good' in the column called `measured_rating_diff`. A DataFrame can be sliced in a similar way as an `array`, the only difference is that the square brackets can't be typed directly after the DataFrame's name. Instead, the `loc` property must be used, as illustrated below. The first line of code creates an array with `True` and `False` values, depending on the values in the column 'measured_rating_diff'. These are used as indices to slice the DataFrame `df`, and the result of the slicing operation is stored in the DataFrame called 'dfsub'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = (df['measured_rating_diff'] == 'Good')\n",
    "dfsub = df.loc[idx]\n",
    "\n",
    "dfsub.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code cell below selects only the columns 'gage_height_va' and 'discharge_va' from `dfsub` and removes all other ones, resulting in a smaller DataFrame without any redundant information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfsub = dfsub[['gage_height_va', 'discharge_va']]\n",
    "dfsub.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The stage-discharge relationship takes the following form\n",
    "\n",
    "$$ Q = a h^b$$\n",
    "\n",
    "where $Q$ is the discharge, $h$ is the stream stage and $a$ and $b$ are curve fitting parameters. With `NumPy` we can fit polynomial equations, but a power relationship like this one can't be fitted directly. To solve this, the relationship can be log-transformed, resulting in a linear equation\n",
    "\n",
    "$$ log(Q) = log(a) + b \\cdot log(h)$$\n",
    "\n",
    "So, the data need to be log-transformed first, which is easy using `NumPy's` `log` function, which also works with DataFrames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log_wl = np.log(dfsub['gage_height_va'])\n",
    "log_Q = np.log(dfsub['discharge_va'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fitting the data to the linearised expression is done using `NumPy's` `polyfit` function. The first two arguments are the dependent and independent variable, respectively.  The third argument is the degree of the polynomial, which is 1 for a linear relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b, log_a = np.polyfit(log_wl, log_Q, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The return values (`b` and `log_a`) are the slope ($b$) and the intercept ($log(a)$). To get $a$, `log_a` must be exponentiated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.exp(log_a)\n",
    "print(b, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result can be visualised alongside with the data in a plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.plot(dfsub['gage_height_va'], dfsub['discharge_va'], 'o')\n",
    "xvalues = np.linspace(1.5, 4.5, 100)\n",
    "Qcalc = a * xvalues ** b\n",
    "plt.plot(xvalues, Qcalc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `polyfit` does not return the goodness of fit ($R^2$). This is possible in Python of course, but one has to use a different function, like `linregress` in the `SciPy` library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2.5***: Add labels to the axes of the graph with the stage-discharge relationship."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Exercise 2.6***: Look up the documentation for the `linregress` funcion (see <A href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.linregress.html\">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.linregress.html</A>). Calculate the values for $a$ and $b$ with this function. What is the value of $R^2$? Check the outcome by creating a plot of the data with the stage-discharge relationship."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type your code here"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "hide_code_all_hidden": 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.8"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "name": "_merged_merged_merged"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}