notebooks/week1_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Week 1 - Recap of basic Python and Jupyter concepts\n",
    "\n",
    "### Aims\n",
    "\n",
    "- To introduce Jupyter Notebook that we will be using, to write Python scripts, in this course\n",
    "- To recapitulate Python basic functionality\n",
    "\n",
    "### Learning objectives\n",
    "\n",
    "- Learn about the functions in the various toolbars in Jupyter\n",
    "- Become familiar with creating and modifying cells in Jupyter to write code and text\n",
    "- Review data types and data structures in Python\n",
    "- Present ways of writing if/while conditions and comparisons in Python\n",
    "- Show ways to read and write files in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running Python within a Jupyter Notebook\n",
    "\n",
    "\n",
    "### Starting Jupyter Notebook\n",
    "\n",
    "For details about installing Python3 and Jupyter, please refer to the [Week 0 - Getting ready - Introduction and installations](https://github.com/semacu/data-science-python/blob/master/notebooks/week0_materials.ipynb). If you happen to have issues with the installation, Sam and Dan will be available to help after today's session.\n",
    "\n",
    "Once you have Python3 and Jupyter installed, start Jupyter Notebook from the icon in Windows start menu:\n",
    "\n",
    "<img src=\"../img/windows_start_menu.png\" width=\"400\">\n",
    "\n",
    "You should now see Jupyter Notebook home page loading in your default web browser e.g. Chrome, Firefox ...\n",
    "\n",
    "\n",
    "### Downloading today's notebook\n",
    "\n",
    "All the materials that we will use throughout the course will be made available in this GitHub repository:\n",
    "\n",
    "https://github.com/semacu/data-science-python\n",
    "\n",
    "To download today's notebook, go to your web browser and paste the url above:\n",
    "\n",
    "1. Click on the `notebooks` folder and then click on the notebook `week1_lecture.ipynb`. It may take a few seconds to load, then click on `Raw`.\n",
    "2. Press `Ctrl+S` or right-click on `Download as ...` or `Save as ...` to save it as `week1_lecture.ipynb`\n",
    "3. Go to the Jupyter Notebook that you started earlier and navigate to the location where you saved `week1_lecture.ipynb`\n",
    "4. Open the file. You will now see the code.\n",
    "\n",
    "\n",
    "### Navigating notebooks\n",
    "\n",
    "#### The dashboard of notebooks\n",
    "\n",
    "This is the default page when you open Jupyter notebook a.k.a. the dashboard. Its main purpose is to display the directories and notebooks present in the current directory, e.g.:\n",
    "\n",
    "<img src=\"../img/notebook_dashboard.png\">\n",
    "\n",
    "By clicking on the directories or files in the list, you can navigate your file system.\n",
    "\n",
    "To create a new notebook, click on the \"New\" button at the top right of the list and select `Python 3` from the dropdown menu (as seen below). The versions of Python listed depends on what's installed on your machine.\n",
    "\n",
    "<img src=\"../img/new_notebook.png\">\n",
    "\n",
    "Notebooks and files created locally can be uploaded to the current directory by dragging them onto the list.\n",
    "\n",
    "The notebooks are highlighted in green if they are currently \"Running\". Notebooks remain running until you explicitly shut them down; closing the notebook's page is not sufficient.\n",
    "\n",
    "<img src=\"../img/notebook_dashboard_green.png\">\n",
    "\n",
    "To shutdown, delete, duplicate, or rename a notebook check the checkbox next to it and an array of controls will appear at the top of the notebook list.\n",
    "\n",
    "To see all of your running notebooks along with their directories, click on the \"Running\" tab:\n",
    "\n",
    "<img src=\"../img/running_tab.png\">\n",
    "\n",
    "This view provides a convenient way to track notebooks that you start as you navigate the file system.\n",
    "\n",
    "\n",
    "#### The notebook user interface\n",
    "\n",
    "If you create a new notebook or open an existing one, you will be taken to the notebook user interface. This user interface allows you to run code and author notebook documents interactively. The user interface has the following main areas:\n",
    "\n",
    "- Menubar\n",
    "- Toolbar\n",
    "- Notebook area and cells\n",
    "\n",
    "<img src=\"../img/notebook_ui.png\">\n",
    "\n",
    "The notebook has an interactive tour of these elements that can be started in the \"Help:User Interface Tour\" menu item - please follow the tour:\n",
    "\n",
    "<img src=\"../img/help_ui_tour.png\">\n",
    "\n",
    "##### Modes\n",
    "\n",
    "The keyboard does different things depending on which mode the notebook is in. There are two modes: \n",
    "\n",
    "- Edit mode: indicated by a green cell border and a prompt showing in the editor area. When a cell is in edit mode, you can type into the cell, like a normal text editor. Enter the edit mode by clicking on a cell's area or press `Enter`.\n",
    "\n",
    "<img src=\"../img/edit_mode.png\">\n",
    "\n",
    "- Command mode: indicated by a grey cell border with a blue left margin. You are able to edit the cells as a whole, but not type into individual cells. Enter the command mode by clicking *outside* a cell's editor area or press `Esc`.\n",
    "\n",
    "<img src=\"../img/command_mode.png\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basic Python\n",
    "\n",
    "### Printing\n",
    "\n",
    "You can include a comment in python by prefixing some text with a `#` character. All text following the `#` will then be ignored by the interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello from python!') # to print some text, enclose it between single quotation marks\n",
    "print(\"I'm here today!\")    # or double quotation marks\n",
    "print(34)                   # print an integer\n",
    "print(2 + 4)                # print the result of an arithmetic operation\n",
    "print(\"The answer is\", 42)  # print multiple expressions, separated by comma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "A variable can be assigned to a simple value or the outcome of a more complex expression. The `=` operator is used to assign a value to a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3     # assignment of a simple value\n",
    "print(x)\n",
    "y = x + 5 # assignment of a more complex expression\n",
    "print(y)\n",
    "i = 12\n",
    "print(i)\n",
    "i = i + 1 # assigment of the current value of a variable incremented by 1 to itself\n",
    "print(i)\n",
    "i += 1    # shorter version with the special += operator\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple data types\n",
    "\n",
    "Python has four main data types: integer, float, string and boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2           # integer\n",
    "b = 5.0         # float\n",
    "c = 'word'      # string\n",
    "d = 4 > 5       # boolean (True or False)\n",
    "e = None        # special built-in value to create a variable that has not been set to anything specific\n",
    "print(a, b, c, d, e)\n",
    "print(a, 'is of type', type(a)) # to check the type of a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic operations\n",
    "\n",
    "Using Python as a calculator to do simple mathematical operations in integer and float numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2             # assignment\n",
    "a += 1            # change and assign (*=, /=)\n",
    "3 + 2             # addition\n",
    "3 - 2             # subtraction\n",
    "3 * 2             # multiplication\n",
    "3 / 2             # integer (python2) or float (python3) division\n",
    "\n",
    "3 // 2            # integer division\n",
    "3 % 2             # remainder\n",
    "3 ** 2            # exponent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data structures\n",
    "\n",
    "There are also different types of data structures in Python to store the main basic data types shown above:\n",
    "\n",
    "- Lists\n",
    "- Sets\n",
    "- Tuples\n",
    "- Dictionaries\n",
    "\n",
    "##### Lists\n",
    "\n",
    "A list is an ordered collection of mutable elements e.g. the elements inside a list can be modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['red', 'blue', 'green']       # manual initialisation\n",
    "copy_of_a = a[:]                   # copy of a \n",
    "another_a = a                      # same as a\n",
    "b = list(range(5))                 # initialise from iteratable\n",
    "c = [1, 2, 3, 4, 5, 6]             # manual initialisation\n",
    "len(c)                             # length of the list\n",
    "d = c[0]                           # access first element at index 0\n",
    "e = c[1:3]                         # access a slice of the list, \n",
    "                                   # including element at index 1 up to but not including element at index 3\n",
    "f = c[-1]                          # access last element\n",
    "c[1] = 8                           # assign new value at index position 1\n",
    "g = ['re', 'bl'] + ['gr']          # list concatenation\n",
    "['re', 'bl'].index('re')           # returns index of 're'\n",
    "a.append('yellow')                 # add new element to end of list\n",
    "a.extend(b)                        # add elements from list `b` to end of list `a`\n",
    "a.insert(1, 'yellow')              # insert element in specified position\n",
    "'re' in ['re', 'bl']               # true if 're' in list\n",
    "'fi' not in ['re', 'bl']           # true if 'fi' not in list\n",
    "c.sort()                           # sort list in place\n",
    "h = sorted([3, 2, 1])              # returns sorted list\n",
    "i = a.pop(2)                       # remove and return item at index (default last)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)\n",
    "print(f)\n",
    "print(g)\n",
    "print(h)\n",
    "print(i)\n",
    "print(\"------------\")\n",
    "print(a)\n",
    "print(copy_of_a)\n",
    "print(another_a)\n",
    "a[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Sets\n",
    "\n",
    "A set is an unordered collection of unique elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {1, 2, 3}                                # initialise manually\n",
    "b = set(range(5))                            # initialise from iteratable\n",
    "c = set([1,2,2,2,2,4,5,6,6,6])               # initialise from list\n",
    "a.add(13)                                    # add new element to set\n",
    "a.remove(13)                                 # remove element from set\n",
    "2 in {1, 2, 3}                               # true if 2 in set\n",
    "5 not in {1, 2, 3}                           # true if 5 not in set\n",
    "d = a.union(b)                               # return the union of sets as a new set\n",
    "e = a.intersection(b)                        # return the intersection of sets as a new set\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Tuples\n",
    "\n",
    "A tuple is an ordered collection of immutable elements e.g. tuples are similar to lists, but the elements inside a tuple cannot be modified. Most of the list operations shown above can be used on tuples as well, with the exception of the assignment of new value at a certain index position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (123, 54, 92)              # initialise manually\n",
    "b = ()                         # empty tuple\n",
    "c = (\"Ala\",)                   # tuple of a single string (note the trailing \",\")\n",
    "d = (2, 3, False, \"Arg\", None) # a tuple of mixed types\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "t = a, c, d                    # tuple packing\n",
    "x, y, z = t                    # tuple unpacking\n",
    "print(t)\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dictionaries\n",
    "\n",
    "A dictionary is an unordered collection of key-value pairs where keys must be unique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {'A': 'Adenine', 'C': 'Cytosine'}        # dictionary\n",
    "b = a['A']                                   # translate item\n",
    "c = a.get('N', 'no value found')             # return default value\n",
    "'A' in a                                     # true if dictionary a contains key 'A'\n",
    "a['G'] = 'Guanine'                           # assign new key, value pair to dictonary a\n",
    "a['T'] = 'Thymine'                           # assign new key, value pair to dictonary a\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "d = a.keys()                                 # get list of keys\n",
    "e = a.values()                               # get list of values\n",
    "f = a.items()                                # get list of key-value pairs\n",
    "print(d)\n",
    "print(e)\n",
    "print(f)\n",
    "del a['A']                                   # delete key and associated value\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Working with strings\n",
    "\n",
    "A string is an ordered collection of immutable characters or tuple of characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'red'                          # assignment\n",
    "char = a[2]                        # access individual characters\n",
    "b = 'red' + 'blue'                 # string concatenation\n",
    "c = '1, 2, three'.split(',')       # split string into list\n",
    "d = '.'.join(['1', '2', 'three'])  # concatenate list into string\n",
    "print(a)\n",
    "print(char)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "dna = 'ATGTCACCGTTT'               # assignment\n",
    "seq = list(dna)                    # convert string into list of character\n",
    "e = len(dna)                       # return string length\n",
    "f = dna[2:5]                       # slice string\n",
    "g = dna.find('TGA')                # substring location, return -1 when not found\n",
    "print(dna)\n",
    "print(seq)\n",
    "print(e)\n",
    "print(f)\n",
    "print(g)\n",
    "text = '   chrom start end    '    # assignment\n",
    "print('>', text, '<')\n",
    "print('>', text.strip(), '<')      # remove unwanted whitespace at both end of the string\n",
    "print('{:.2f}'.format(0.4567))     # formating string\n",
    "print('{gene:s}\\t{exp:+.2f}'.format(gene='Beta-Actin', exp=1.7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions\n",
    "\n",
    "A conditional `if` or `elif` statement is used to specify that some block of code should only be executed if a conditional expression is **True**. Often the final `else` statement works when all the conditions before are **False**. \n",
    "\n",
    "Python uses indentation to represent which statements are inside a block of code e.g. the line after the `if` statement is indented (tab)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 1, 2           # assign different values to a and b, and execute the cell to test\n",
    "if a + b == 3:\n",
    "    print('Three')\n",
    "elif a + b == 1:\n",
    "    print('One')\n",
    "else:\n",
    "    print('?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparisons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 == 1            # equal\n",
    "1 != 2            # not equal\n",
    "2 > 1             # greater than\n",
    "2 < 1             # smaller than\n",
    "\n",
    "1 != 2 and 2 < 3  # logical AND\n",
    "1 != 2 or 2 < 3   # logical OR\n",
    "not 1 == 2        # logical NOT\n",
    "\n",
    "a = list('ATGTCACCGTTT')\n",
    "b = a             # same as a\n",
    "c = a[:]          # copy of a\n",
    "'N' in a          # test if character 'N' is in a\n",
    "\n",
    "print('a', a)      # print a\n",
    "print('b', b)      # print b\n",
    "print('c', c)      # print c\n",
    "print('Is N in a?', 'N' in a)\n",
    "print('Are objects b and a point to the same memory address?', b is a)\n",
    "print('Are objects c and a point to the same memory address?', c is a)\n",
    "print('Are values of b and a identical?', b == a)\n",
    "print('Are values of c and a identical?', c == a)\n",
    "a[0] = 'N'         # modify a  \n",
    "print('a', a)      # print a\n",
    "print('b', b)      # print b\n",
    "print('c', c)      # print c\n",
    "print('Is N in a?', 'N' in a)\n",
    "print('Are objects b and a point to the same memory address?', b is a)\n",
    "print('Are objects c and a point to the same memory address?', c is a)\n",
    "print('Are values of b and a identical?', b == a)\n",
    "print('Are values of c and a identical?', c == a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "There are two ways of creating loops in Python using `for` or `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['red', 'blue', 'green']\n",
    "for color in a:\n",
    "    print(color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 1\n",
    "while number < 10:\n",
    "    print(number)\n",
    "    number += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has two ways of affecting the flow of a `for` or `while` loop:\n",
    "\n",
    "- The `break` statement immediately causes all looping to finish, and execution is resumed at the next statement after the loop. \n",
    "- The `continue` statement means that the rest of the code in the block is skipped for this particular item in the collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break\n",
    "sequence = ['CAG','TAC','CAA','TAG','TAC','CAG','CAA']\n",
    "for codon in sequence:\n",
    "    if codon == 'TAG':\n",
    "        break            # Quit the looping at this point (the TAG stop codon)\n",
    "    else:\n",
    "        print(codon)\n",
    "\n",
    "        \n",
    "# continue\n",
    "values = [10, -5, 3, -1, 7]\n",
    "total = 0\n",
    "for v in values:\n",
    "    if v < 0:\n",
    "        continue         # Don't quit the loop but skip the iterations where the integer is negative   \n",
    "    total += v\n",
    "\n",
    "print(values, 'sum:', sum(values), 'total:', total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading and writing files\n",
    "\n",
    "To read from a file, your program needs to `open` the file and then read the contents of the file. You can read the entire contents of the file at once, or read the file line by line. The `with` statement makes sure the file is closed properly when the program has finished accessing the file.\n",
    "\n",
    "We will use one of the files containing clinical and genomic data from anonymized patients published as part of the METABRIC consortium, a large-scale collaborative study of breast cancer worldwide (PMID: 22522925).\n",
    "\n",
    "**Note:** you can download the data file `metabric_clinical_and_expression_data.csv` from the `data` folder in: https://github.com/semacu/data-science-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reading from file\n",
    "with open(\"../data/metabric_clinical_and_expression_data.csv\") as f:\n",
    "    for line in f:\n",
    "        print(line.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Passing the `w` argument in `open()` tells Python that you want to create and write to a new file. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# writing to a file\n",
    "with open('programming.txt', 'w') as f:\n",
    "    f.write(\"I love programming in Python!\\n\")\n",
    "    f.write(\"I love making scripts.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Keep in mind** this will erase the contents of the file if it already exists. \n",
    "\n",
    "Passing the `a` argument instead tells Python you want to append to the end of an existing file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# appending to a file \n",
    "with open('programming.txt', 'a') as f:\n",
    "    f.write(\"I love working with data.\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting help\n",
    "\n",
    "The Python [Standard Library](https://docs.python.org/3/library/index.html) is the reference documentation of all libraries included in Python as well as built-in functions and data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(len)          # help on built-in function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(list.extend)  # help on list function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For help within the Jupyter Notebook, try the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment\n",
    "\n",
    "1. Create a new Jupyter Notebook with one Markdown cell and one Code cell and name it as you wish e.g. `week1_exercise1`\n",
    "    - Print out the names of the amino acids that would be produced by the DNA sequence \"GTT GCA CCA CAA CCG\" - see the DNA codon table [here](https://en.wikipedia.org/wiki/DNA_codon_table). Note: split the string into the individual codons and then create and use a dictionary to map between codon sequences and the amino acids they encode\n",
    "    - Print each codon and its corresponding amino acid\n",
    "    - Why couldn't we build a dictionary where the keys are names of amino acids and the values are the DNA codons?\n",
    "    - Download the python file associated with the notebook you have created\n",
    "\n",
    "\n",
    "2. You are going to look at the METABRIC data file `metabric_clinical_and_expression_data.csv` on breast cancer referred above\n",
    "    - Write a script that reads the file and counts how many unique patients we have data available\n",
    "    - How many patients were older than 75 when diagnosed with breast cancer? \n",
    "    - What were the earliest and oldest ages of diagnosis?\n",
    "    - Count how many patients were treated with Chemotherapy and Radiotherapy\n",
    "    - Count how many patients had less than three mutations in the genes investigated\n",
    "    \n",
    "\n",
    "3. `Bonus exercise` \n",
    "    - Starting with an empty dictionary, count the abundance of different residue types present in the 1-letter lysozyme protein [sequence](http://www.uniprot.org/uniprot/B2R4C5.fasta) and print the results to the screen in alphabetical key order.\n",
    "    - Write the results to an output file"
   ]
  }
 ],
 "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}