notebooks/01_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Quick Start\n",
    "\n",
    "This notebook is the first of a series of four notebooks giving an introduction to programming and Python.\n",
    "\n",
    "## Jupyter & Executing Code\n",
    "The Jupyter notebooks are made of *cells* that contain either text (like this present cell), or code (like the cell below). You can execute code cells by selecting them and clicking the \"Run\" button at the top of the notebook, or simply by typing SHIFT+ENTER. Let's try this right away :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print('Hello, World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it! You just executed your first Python program, congratulations :)\n",
    "\n",
    "### Exercise\n",
    "Write another Python program in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Files\n",
    "There are other ways to execute Python code without using notebooks. You can also write your code in a `.py` file (such as `my_program.py`), and then launch it in the command line with `python my_program.py`. In this class we will write all of our code in notebooks, though.\n",
    "\n",
    "## Instructions\n",
    "When executing the code in the cell above, we asked Python to interprete the code in the cell. The code was a single instruction to `print` the string `\"Hello, World!\"`. We can write more instructions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n",
      "def\n",
      "I love Python\n"
     ]
    }
   ],
   "source": [
    "print('abc')\n",
    "print('def')\n",
    "print('I love Python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python interpretes the instructions in order.\n",
    "\n",
    "## Variables\n",
    "Assume we have the following text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice collects stamps. Alice has 2000 stamps.\n"
     ]
    }
   ],
   "source": [
    "print('Alice collects stamps. Alice has 2000 stamps.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *variable* is a container for a value. We can for instance define a variable to store the name \"Alice\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice collects stamps. Alice has 2000 stamps.\n"
     ]
    }
   ],
   "source": [
    "name = 'Alice'\n",
    "print(name + ' collects stamps. ' + name + ' has 2000 stamps.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `'Alice'` is a *value* and `name` is a *variable*.\n",
    "\n",
    "Using variables allows us to make our program dynamic - for instance we can change what is printed by just changing the content of this variable!\n",
    "\n",
    "### Exercise\n",
    "Use a variable to store the number of stamps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Alice'\n",
    "\n",
    "print(name + ' collects stamps. ' + name + ' has ' + nr_stamps + ' stamps.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Convention:** variable names in Python are written in \"snake_case\" fashion; in lower case, not starting with a number, and using underscore(s) to separate the \"components\".\n",
    "\n",
    "Variable names can be re-assigned to new values over the course of the program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Alice\n",
      "I am Bob\n"
     ]
    }
   ],
   "source": [
    "name = 'Alice'\n",
    "print('I am ' + name)\n",
    "name = 'Bob'\n",
    "print('I am ' + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types\n",
    "Different *types* are used to represent different kinds of data. \n",
    "\n",
    "#### Strings\n",
    "Until now, we have only used *strings* (`str`), which represent strings (or sequences) of characters. They are expressed using quotation marks (either `'` or `\"`; we'll use mostly `'` in this class):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "a_string = 'Hello, '\n",
    "another_string = \"World!\"\n",
    "print(a_string + another_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numbers\n",
    "There are essentially two types of numbers in Python: \n",
    "* *integers* (`int`) that represent integer numbers, \n",
    "* *floats* (`float`) that represent decimal numbers. \n",
    "\n",
    "We do not use quotation marks when writing number values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "42.3476\n",
      "42.0\n"
     ]
    }
   ],
   "source": [
    "an_integer = 42\n",
    "a_float = 42.3476\n",
    "another_float = 42.0\n",
    "\n",
    "print(an_integer)\n",
    "print(a_float)\n",
    "print(another_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Booleans\n",
    "*Booleans* (`bool`) can take only two values: `True` or `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a_bool = True\n",
    "another_bool = False\n",
    "\n",
    "print(a_bool)\n",
    "print(another_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other types\n",
    "Strings, integers, floats and booleans are the most important basic types in Python, but there are several other important types that we will encounter in the rest of the class - such as lists, tuples, sets, functions and types defined by user-defined classes.\n",
    "\n",
    "### Inspecting and Converting Types\n",
    "Python is a *dynamically typed* language - meaning that it will determine for you the type of variables during the program execution (not beforehand). For example, when we typed `an_integer = 42`, Python determined that `an_integer` would be of type `int`. This can be convenient, but also sometimes challenging for the programmer to keep track of the types of all the variables.\n",
    "\n",
    "For inspecting types, we can use `type()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a_str = 'abc'\n",
    "an_integer = 42\n",
    "a_float = 42.3476\n",
    "another_float = 42.0\n",
    "a_bool = False\n",
    "\n",
    "print(type(a_str))\n",
    "print(type(an_integer))\n",
    "print(type(a_float))\n",
    "print(type(another_float))\n",
    "print(type(a_bool))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some cases, it is possible to translate one type into another. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "a_float = 42.99\n",
    "another_float = 42.0\n",
    "\n",
    "a_converted_int = int(a_float)\n",
    "another_converted_int = int(another_float)\n",
    "\n",
    "print(a_converted_int)\n",
    "print(another_converted_int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "Write some examples of the following conversions, and print the results:\n",
    "* `float` --> `int`\n",
    "* `int` --> `float`\n",
    "* `int` --> `str`\n",
    "* `bool` --> `int`\n",
    "* (bonus): `str` --> `float`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "an_int = 42\n",
    "a_float = 42.3476\n",
    "a_str = 'abc'\n",
    "another_str = '17.14'\n",
    "a_bool = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators\n",
    "Above, we have already used the operator `+` in order to concatenate strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "a_string = 'Hello, '\n",
    "another_string = \"World!\"\n",
    "print(a_string + another_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use operators on numbers and booleans, and usually operators have different meanings depending on the types on which they operate. Here are the most common operators and their meaning when used on numbers:\n",
    "* `+` (addition for numbers, concatenation for strings)\n",
    "* `-` (subtraction)\n",
    "* `*` (multiplication)\n",
    "* `/` (division)\n",
    "* `**` (exponentiation)\n",
    "* `%` (modulo)\n",
    "* `==` (equality test)\n",
    "* `>` and `>=` (is greater test)\n",
    "* `<` and `<=` (is smaller test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "1\n",
      "6\n",
      "0.6666666666666666\n",
      "8\n",
      "1\n",
      "\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(2 + 2)\n",
    "print(2 - 1)\n",
    "print(2 * 3)\n",
    "print(2 / 3)\n",
    "print(2 ** 3)\n",
    "print(3 % 2)\n",
    "\n",
    "print()\n",
    "\n",
    "print(1 == 2)\n",
    "print(2 == 2)\n",
    "print(3 >= 2)\n",
    "print(2 == 2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean operators:\n",
    "* `not` returns `True` if its unique operand is 0 or `False`\n",
    "* `and` returns `True` if and only if its two operands are `True`\n",
    "* `or` returns `True` if at least one of its operands is `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "\n",
      "False\n",
      "True\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(not False)\n",
    "print(not 1)\n",
    "\n",
    "print()\n",
    "print(1 > 2 and 1 < 3)\n",
    "print(1 < 2 and 1 < 3)\n",
    "\n",
    "print()\n",
    "print(1 > 2 or 1 < 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result of applying operators also has a well-defined type, which can depend on the operands types. For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'bool'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2 + 2))\n",
    "print(type(1 == 2))\n",
    "print(type(2 / 3))\n",
    "print(type(4 / 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(2 ** 3))\n",
    "print(type(2 ** 3.0))\n",
    "print(type(2.0 ** 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not all operations are allowed. For instance `+` cannot be used to add a number to a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-4c4d3d29ec6c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mstring\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'abc'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mnumber\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstring\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mnumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "string = 'abc'\n",
    "number = 10\n",
    "print(string + number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "Compute the result of\n",
    "$$\n",
    "\\sqrt{\\frac{(6 + 4)^5}{10^3}}\n",
    "$$\n",
    "and store it in a variable `result`.\n",
    "\n",
    "*Hint:* you might want to use variables to store intermediate results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Functions\n",
    "*Functions* represent a piece of logic, which can perform certain kinds of computation given some *parameters*. We actually already have used functions at this point; for instance:\n",
    "* `print` is a function that prints whatever it receives as argument\n",
    "* `int` is a function that, when possible, *returns* an integer version of its argument\n",
    "\n",
    "In the instruction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n"
     ]
    }
   ],
   "source": [
    "print('abc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print` is the function and `'abc'` is the *argument* or *parameter*. The function is called using the function name followed by parentheses `()` that optionally contain the arguments. Some functions can receive several arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc 123\n"
     ]
    }
   ],
   "source": [
    "print('abc', 123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Return Values\n",
    "In the statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "integer_version = int(42.42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the function `int` is different from `print` because it *returns* something - in this case the integer version of its argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "print(integer_version)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arguments can be seen as the *inputs* of the function, and the returned value(s) can be seen as its *ouptuts*.\n",
    "\n",
    "### Built-in Functions\n",
    "Functions like `print` and `int` can be called anytime in the code - they are so-called *built-in* functions. This is  the case for all the functions we used until now:\n",
    "* `print`: prints its arguments (does not return anything)\n",
    "* `type`: returns the type of its argument\n",
    "* `int`: returns an integer version of its argument\n",
    "* `float`: returns a float version of its argument\n",
    "* `str`: returns a string version of its argument\n",
    "\n",
    "Built-in functions are documented here: https://docs.python.org/3/library/functions.html.\n",
    "\n",
    "For instance, the function `len` returns the length of its argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26\n"
     ]
    }
   ],
   "source": [
    "print(len('abcdefghijklmnopqrstuvwxyz'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "Compute the absolute value of a number using a built-in function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = -42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another Example - Asking Inputs from Users:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's your age? 36\n",
      "46\n"
     ]
    }
   ],
   "source": [
    "age = int(input(\"What's your age? \"))\n",
    "print(age + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "Print the result of $x + y$, where $x$ and $y$ are user defined numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyword Arguments and Default Values\n",
    "Some functions accept different kinds of arguments. Here's the top of the `print` function documentation:\n",
    "<img src=\"images/keyword_args.png\" />\n",
    "\n",
    "We have a couple of things to note:\n",
    "* The function has several arguments: `*objects`, `sep`, `end`, `file` and `flush`.\n",
    "* `*objects` is a way to write *all non keyword arguments* (what's that??)\n",
    "\n",
    "Keyword arguments are arguments given to the function using keywords when calling it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string.     And this is another string.\n"
     ]
    }
   ],
   "source": [
    "print('This is a string.', 'And this is another string.', sep='     ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, `sep` is given by writing `sep=`; which means here that it's a keyword argument. The documentation shows *default values* for these arguments (e.g.: `sep=' '`). When arguments have default values, they are optional."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n",
    "Python is an *object-oriented* language, which means that pretty much everything (such as strings, numbers and much more) are *objects*. One property of objects is that they can have their own functions, which are called *methods*. For example, strings have a method to make them uppercase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string\n",
      "THIS IS A STRING\n"
     ]
    }
   ],
   "source": [
    "my_string = 'This is a string'\n",
    "print(my_string)\n",
    "print(my_string.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `upper` is a function that receives no explicit argument, but one \"implicit\" argument (the string on which it is called, here `my_string`). It returns a new string that is the upper case version of this original string.\n",
    "\n",
    "`upper` is really a method of string objects. For example, we cannot call `upper()` on a number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'int' object has no attribute 'upper'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-93d4dfa1be63>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mmy_number\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_number\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'upper'"
     ]
    }
   ],
   "source": [
    "my_number = 1\n",
    "print(my_number.upper())"
   ]
  }
 ],
 "metadata": {
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}