A-Basic-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Title: Quick Start With Python\n",
    "Author: John Fay for ENV872\n",
    "Date: Spring 2023\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Quick start with Python\n",
    "\n",
    "Instructor: John Fay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why learn Python?\n",
    "\n",
    "- High-level, interpreted language - simple programs can be written and tested quickly.\n",
    "- Extensions like NumPy and SciPy support high-performance scientific  computing.\n",
    "- Used in a wide range of domains, both in academia and industry.\n",
    "- Large user community: it’s easy to get help and to find free,  open-source packages for specialized problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data types and variables\n",
    "\n",
    "As most programming languages, Python supports basic data types for integers (`int`), real numbers (`float`), character strings (`str`) and logical True/False values (`bool`).\n",
    "\n",
    "The type of a variable is automatically set when a value is assigned to it,  using the `=` operator. It can be queried with the built-in `type()`  function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 3\n",
    "type(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports the usual arithmetic operators:  `+`, `-`, `*`, `/`, `**` (exponent)\n",
    " and comparison operators:   `==` (equal), `!=` (non-equal), `<`, `>`, `<=`, `>=` .\n",
    "\n",
    "Both `int` and `float` values can be mixed within an expression; the result is a `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = i + 1.5\n",
    "print (r, 'is of', type(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code above, we introduced the `print` statement, which prints the output of multiple Python expressions on the same line, separated by spaces.  Note that quoted character strings (here, ‘is of’) are printed as is.\n",
    "\n",
    "Let’s define a new string variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'three'\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, the same operator can perform different functions based on the data types of the operands. See what happens if you “add” two character strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s + 'four'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='blue'>♦ Exercises </font>\n",
    "<details>\n",
    "    <summary>\n",
    "► Create a variable called `b` and set it to the value `False`. What is the type of the `b` variable? What happens if you set its value to `FALSE` or `false` instead of `False`? What if you enclose `False` in quotes?\n",
    "    </summary>\n",
    "    <code>b = False<br>type(b)</code>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "    <summary>► Convert the variable `b` to an integer using `int(b)` function. What does its value become? Convert it to a string? What is its value now?\n",
    "    </summary>\n",
    "    <code>int(b)</code>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details>\n",
    "    <summary>► Finally, create a variable `q` to an empty string. Then examine the value of that string if converted to a Boolean (`bool(q)`). Also, what is the value of `0` if converted to a Boolean? `1`? `10`? `-1`?\n",
    "    </summary>\n",
    "   1.  <code>q=''<br>bool(q))</code><br>\n",
    "   2.  <code>q=0<br>bool(q))</code>\n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "Python offers different types of objects to represent collections of values, the most common being a *list*. It is created by listing multiple values or variables, separated by commas and enclosed by square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [r, s, 'another string']\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List subsetting\n",
    "\n",
    "You can retrieve individual elements of a list by their index; note that in  Python, the first element has an index of 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indices are also possible: -1 is the last item in the list,  -2 the second-to-last item, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax `list[i:j]` selects a sub-list starting with the element at index `i` and ending with the element at index `j - 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A blank space before or after the “:” indicates the start or end of the list, respectively. For example, the previous example could have been written  `lst[:2]`.\n",
    "\n",
    "A potentially useful trick to remember the list subsetting rules in Python is to picture the indices as “dividers” between list elements.\n",
    "\n",
    "```\n",
    " 0     1         2                  3 \n",
    " | 4.5 | 'three' | 'another string' |\n",
    "-3    -2        -1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Positive indices are written at the top and negative indices at the bottom.  `list[i]` returns the element to the right of `i` whereas `list[i:j]` returns elements between `i` and `j`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Positive indices are written at the top and negative indices at the bottom.  `list[i]` returns the element to the right of `i` whereas `list[i:j]` returns elements between `i` and `j`.\n",
    "\n",
    "**<font color='blue'>►Question**: Given any Python list, how can you retrieve its last two elements?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:**\n",
    ">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can be nested within other lists: in this case, multiple sets of brackets might be necessary to access individual elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list = [1, 2, 3, [11, 12, 13]]\n",
    "nested_list[3][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List methods\n",
    "\n",
    "The Python language includes multiple functions that work with lists.  Here are a few examples. Note that code lines starting with `#` are comments, which serve to document the code but are ignored by the Python interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns the length of a list\n",
    "len(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns the position of an element in a list\n",
    "lst.index(4.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Appends an element to the end of a list\n",
    "lst.append(100)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse the order of a list's elements\n",
    "lst.reverse()\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last three examples feature a special type of functions called *methods*. In object-oriented programming, methods belong to a specific object; in Python, they are called with the `object.method()` syntax. In general, methods and  functions operate in a similar manner; for example, `len()` could have been a list method.\n",
    "\n",
    "Note that the `append` and `reverse` methods modify the `lst` object, and return no value. A common mistake – especially for those used to program in R – would be to write `lst = lst.append(100)`, which overwrites `lst` with a null value!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<font color='blue'>►Question**: What is the output of `len(lst[2])`? What does it mean? (Like the `+` operator, this is another case of a function that behaves differently depending of the type of data it’s applied to.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:**\n",
    ">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "Lists are useful when you need to access elements by their position in a sequence. In contrast, *dictionaries* make it easy to find values based on unique identifiers called *keys*.\n",
    "\n",
    "A dictionary is defined as a list of `key:value` pairs enclosed by curly brackets. Individual values are accessed using square brackets, as for lists, except that keys are used as the indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = {'Snowy':'dog', 'Garfield':'cat', 'Bugs':'rabbit'}\n",
    "animals['Bugs']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To add an element to the dictionary, we “select” a new key and assign  it a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals['Lassie'] = 'dog'\n",
    "animals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the keys of a dictionary must be unique. Assigning a value to an  existing key would overwrite its previously associated value. As you can also see from the example above, the order in which Python returns dictionary elements is arbitrary.\n",
    "\n",
    "**<font color='blue'>►Question**: Based on what we have learned so far, how could you represent a contact list in Python, i.e. a list of individuals with their names, phone  numbers, email addresses, etc.?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer**:\n",
    ">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops and conditionals\n",
    "\n",
    "A `for` loop takes a list and executes a block of code once for each element of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 5):\n",
    "    j = i * 2\n",
    "    print (j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `range(i, j)` function creates a list of integers from `i` to `j - 1`; just like in the case of list slices, the upper bound is excluded.\n",
    "\n",
    "Note the pattern of the block above: the `for` statement is followed by a colon, each line in the following block is indented at the same level, and there is no delimiter or statement indicating the end of the block. Compared with other programming languages where code indentation only serves to enhance readability,  code blocks in Python are defined by changes in indentation.\n",
    "\n",
    "A `for` loop can be used to iterate over the elements of any list. In the following example, we create a contact list (as a list of dictionaries), then perform a loop over all contacts. Within the loop, we use a conditional  statement (`if`) to check if the name is ‘Ann’. If so, we print the phone  number; if not (`else` block), we print the name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contacts = [ {'name': 'Ann', 'phone': '555-111-2222'},\n",
    "             {'name': 'Bob', 'phone': '555-333-4444'} ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in contacts:\n",
    "    if c['name'] == 'Ann':\n",
    "        print (c['phone'])\n",
    "    else: \n",
    "        print (c['name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='blue'>♦ Exercise </font>\n",
    "* Write a loop that prints all even numbers between 1 and 9.<br>_Note:_  if `i` is even, `i % 2 == 0`, where `%` is the modulo (or division remainder) operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a function\n",
    "\n",
    "We already saw examples of a few built-in functions, such as `type()` or `len()`. You can define your own Python functions as a block of code starting with a `def` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_2(num):\n",
    "    result = num + 2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_2(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `def` keyword is followed by the function name, its arguments enclosed in parentheses (separated by commas if there are more than one), and a colon. The `return` statement passes the specified result as the output of the function.  A simple `return` line with no output value just exits the function.\n",
    "\n",
    "After it is defined, the function is invoked using its name and specifying the arguments in parentheses, in the same order as in its definition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<font color='blue'>►Exercise**: Create a function that takes a list as an argument and returns its first and last elements as a new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Run the function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Python packages for scientific computing\n",
    "\n",
    "So far we have only covered elements of the base Python language. However, most of Python’s useful tools for scientific programming can be found in packages that extend its base functionalities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy\n",
    "\n",
    "Because Python lists are meant to contain elements of any data type, they are not so useful as numeric vectors. In particular, the `+` and `*` operations do not perform numerical calculations when applied to lists, rather, they respectively  concatenate and duplicate list elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add_list = [1, 2] + [3, 4]\n",
    "mult_list = [5, 6] * 2\n",
    "print (add_list, mult_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **NumPy** package and its `array` type provide a solution to define vectors, matrices and higher-dimension arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "vect = np.array([5, 20, 12])\n",
    "vect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line of this code, `import numpy as np`, gives Python access to functions from the `numpy` package, using the `package.function` syntax. To save time typing  package names, Python programmers often define short aliases for them, such as `np`  here. This allows us to write `np.array` instead of `numpy.array` on the following  line.\n",
    "\n",
    "The definition of the array itself looks much like a Python list, and array subsetting follows the same conventions as list subsetting. The main difference is for multidimensional arrays, where the indices in each dimensions can be  separated by commas within one set of brackets. As an example, we create a 2 x 3 matrix and selected the first two columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "mat[:, 0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initial “:” (with no indices) is interpreted as “select all rows”.\n",
    "\n",
    "Arithmetic operators and basic mathematical functions (e.g. exp, sqrt) are applied element-wise to NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect + np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat * vect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the last example, `vect` was multipled element-wise to each row of `mat`.To  multiply a matrix and a vector (or two matrices, or two vectors in a dot-product),  use the `dot` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat.dot(vect)   # Alternate syntax is np.dot(mat, vect)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pandas\n",
    "\n",
    "If you have used the statistical programming language R, you are familiar with *data frames*, two-dimensional data structures where each column can hold a  different type of data, as in a spreadsheet.\n",
    "\n",
    "The data analysis library **pandas** provides a data frame object type for Python, along with functions to subset, filter reshape and aggregate data stored in data frames.\n",
    "\n",
    "After importing pandas, we call its `read_csv` function to load the Portal  surveys data from the file *surveys.csv*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "surveys = pd.read_csv(\"../Data/Raw/surveys.csv\")\n",
    "surveys.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the `head` method of a data frame shows its first five rows. To select a subset of rows and columns from the data frame, we can use the `loc` method, specifying a range of row indices and a list of  column names. Note that unlike the usual way we specify number ranges in Python, the end of the range (row 3) is *included* here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys.loc[1:3, ['plot_id', 'species_id']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also select a whole column by writing its name in square brackets. Here, we select the *weight* column and call the `describe` method to get summary statistics for that column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys['weight'].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `loc` method can also filter rows, if we specify a logical condition in place of the row indices. For example, here is how we could get the subset of *surveys* where the species is “DM”, and save it in a new data frame. Note  that when we don’t specify any column names after the comma, all columns are kept."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys_dm = surveys.loc[surveys['species_id'] == 'DM', ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful feature of pandas is the `groupby` method, which defines groups of rows based on their values for a given variable. After grouping a data frame, we can use statistical methods (like `mean`) to get summary statistics by group."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys_group = surveys_dm.groupby('sex')\n",
    "surveys_group['hindfoot_length', 'weight'].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<font color='blue'>► Exercise**: Knowing that the `count` method (e.g. `surveys.count()`) returns the number of rows in a data frame, find which month had the most observations recorded in *surveys*.<br>*Hint:* you'll want to group your data by month, and then display values by count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### matplotlib / pyplot\n",
    "\n",
    "To complete this lesson, we will draw plots of our data using the  **matplotlib** package and more specifically its **pyplot** subpackage. The pandas package works particularly well with pyplot, since it defines plotting methods that work specifically for data frames.\n",
    "\n",
    "In the following, we import pyplot, then call the `plot` method to create a scatterplot of *weight* against *hindfoot_length* from the *surveys_dm* data. The `plt.show()` function opens a new window showing the active plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "surveys_dm.plot('hindfoot_length', 'weight', kind = 'scatter')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides `scatter`, the `plot` method supports other kinds of plots such as bar and line graphs. To create the histogram of one variable from the data frame, you may use a different method, `hist`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close() # close the current plot to start a new one\n",
    "surveys_dm.hist('weight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Additional resources\n",
    "\n",
    "The material in this lesson is partly based on  [Data Carpentry: Python for Ecologists](http://www.datacarpentry.org/python-ecology-lesson/) and the  [Data Carpentry for Biologists](http://www.datacarpentry.org/semester-biology/) course.  These are good resources for a more detailed overview of data analysis and scientific computing in Python."
   ]
  }
 ],
 "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.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}