00-Warm-Up-Project-Exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "<a href='https://www.udemy.com/user/joseportilla/'><img src='../Pierian_Data_Logo.png'/></a>\n",
    "___\n",
    "<center><em>Content Copyright by Pierian Data</em></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warm Up Project Exercises\n",
    "\n",
    "It is time to get you to put together all your skills to start building usable projects! Before you jump into our full milestone project, we will go through some warm-up component exercises, to get you comfortable with a few key ideas we use in the milestone project and larger projects in general, specifically:\n",
    "\n",
    "* Getting User Input\n",
    "* Creating Functions that edit variables based on user input\n",
    "* Generating output\n",
    "* Joining User Inputs and Logic Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function to Display Information\n",
    "\n",
    "**Creating a function that displays a list for the user**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def display_list(mylist):\n",
    "    print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "mylist = [0,1,2,3,4,5,6,7,8,9,10]\n",
    "display_list(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accepting User Input\n",
    "\n",
    "**Creating function that takes in an input from user and returns the result in the correct data type. Be careful when using the input() function, running that cell twice without providing an input value will cause python to get hung up waiting for the initial value on the first run. You will notice an In[*\\] next to the cell if it gets stuck, in which case, simply restart the kernel and re-run any necessary cells.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a value: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input('Please enter a value: ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number: 2\n"
     ]
    }
   ],
   "source": [
    "result = input(\"Please enter a number: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number: 2\n"
     ]
    }
   ],
   "source": [
    "result = int(input(\"Please enter a number: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number: two\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'two'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-202dd8101f66>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Example of an error!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Please enter a number: \"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'two'"
     ]
    }
   ],
   "source": [
    "# Example of an error!\n",
    "result = int(input(\"Please enter a number: \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Creating a function to hold this logic: **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def user_choice():\n",
    "    '''\n",
    "    User inputs a number (0-10) and we return this in integer form.\n",
    "    No parameter is passed when calling this function.\n",
    "    '''\n",
    "    choice = input(\"Please input a number (0-10)\")\n",
    "    \n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input a number (0-10)2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_choice()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input a number (0-10)2\n"
     ]
    }
   ],
   "source": [
    "result = user_choice()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validating User Input\n",
    "\n",
    "** Check that input is valid before attempting to convert.** \n",
    "\n",
    "We'll use a simple method here.\n",
    "\n",
    "As you get more advanced, you can start looking at other ways of doing this (these methods will make more sense later on in the course, so don't worry about them for now).\n",
    "\n",
    "* [Various Posts on This](https://www.google.com/search?q=python+check+if+input+is+number)\n",
    "* [StackOverflow Post 1](https://stackoverflow.com/questions/5424716/how-to-check-if-string-input-is-a-number)\n",
    "* [StackOverflow Post 2](https://stackoverflow.com/questions/1265665/how-can-i-check-if-a-string-represents-an-int-without-using-try-except)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "some_input = '10'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lot's of .is methods availble on string\n",
    "some_input.isdigit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Edit the function to confirm against an acceptable value or type **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def user_choice():\n",
    "    \n",
    "    # This original choice value can be anything that isn't an integer\n",
    "    choice = 'wrong'\n",
    "    \n",
    "    # While the choice is not a digit, keep asking for input.\n",
    "    while choice.isdigit() == False:\n",
    "        \n",
    "        # we shouldn't convert here, otherwise we get an error on a wrong input\n",
    "        choice = input(\"Choose a number: \")\n",
    "    \n",
    "    # We can convert once the while loop above has confirmed we have a digit.\n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose a number: hello\n",
      "Choose a number: two\n",
      "Choose a number: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let's try adding an error message within the while loop!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def user_choice():\n",
    "    \n",
    "    # This original choice value can be anything that isn't an integer\n",
    "    choice = 'wrong'\n",
    "    \n",
    "    # While the choice is not a digit, keep asking for input.\n",
    "    while choice.isdigit() == False:\n",
    "        \n",
    "        # we shouldn't convert here, otherwise we get an error on a wrong input\n",
    "        choice = input(\"Choose a number: \")\n",
    "        \n",
    "        # Error Message Check\n",
    "        if choice.isdigit() == False:\n",
    "            print(\"Sorry, but you did not enter an integer. Please try again.\")\n",
    "    \n",
    "    # We can convert once the while loop above has confirmed we have a digit.\n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose a number: two\n",
      "Sorry, but you did not enter an integer. Please try again.\n",
      "Choose a number: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Now let's explore how to \"clear\" the output, that way we don't see the history of the \"Choose a number\" statements.**\n",
    "\n",
    "**NOTE: Jupyter Notebook users will use the IPython method shown here. Other IDE users (PyCharm, VS, etc..) will use **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def user_choice():\n",
    "    \n",
    "    # This original choice value can be anything that isn't an integer\n",
    "    choice = 'wrong'\n",
    "    \n",
    "    # While the choice is not a digit, keep asking for input.\n",
    "    while choice.isdigit() == False:\n",
    "        \n",
    "        # we shouldn't convert here, otherwise we get an error on a wrong input\n",
    "        choice = input(\"Choose a number: \")\n",
    "        \n",
    "        if choice.isdigit() == False:\n",
    "            # THIS CLEARS THE CURRENT OUTPUT BELOW THE CELL\n",
    "            clear_output()\n",
    "            \n",
    "            print(\"Sorry, but you did not enter an integer. Please try again.\")\n",
    "            \n",
    "    \n",
    "    # Optionally you can clear everything after running the function\n",
    "    # clear_output()\n",
    "    \n",
    "    # We can convert once the while loop above has confirmed we have a digit.\n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose a number: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Checking Against Multiple Possible Values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "result = 'wrong value'\n",
    "acceptable_values = ['0','1','2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result in acceptable_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result not in acceptable_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def user_choice():\n",
    "    \n",
    "    # This original choice value can be anything that isn't an integer\n",
    "    choice = 'wrong'\n",
    "    \n",
    "    # While the choice is not a digit, keep asking for input.\n",
    "    while choice not in ['0','1','2']:\n",
    "        \n",
    "        # we shouldn't convert here, otherwise we get an error on a wrong input\n",
    "        choice = input(\"Choose one of these numbers (0,1,2): \")\n",
    "        \n",
    "        if choice not in ['0','1','2']:\n",
    "            # THIS CLEARS THE CURRENT OUTPUT BELOW THE CELL\n",
    "            clear_output()\n",
    "            \n",
    "            print(\"Sorry, but you did not choose a value in the correct range (0,1,2)\")\n",
    "            \n",
    "    \n",
    "    # Optionally you can clear everything after running the function\n",
    "    # clear_output()\n",
    "    \n",
    "    # We can convert once the while loop above has confirmed we have a digit.\n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose one of these numbers (0,1,2): 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More Flexible Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def user_choice():\n",
    "    \n",
    "    choice ='WRONG'\n",
    "    within_range = False\n",
    "    \n",
    "    while choice.isdigit() == False or within_range == False:\n",
    "        \n",
    "    \n",
    "    \n",
    "        choice = input(\"Please enter a number (0-10): \")\n",
    "        \n",
    "        if choice.isdigit() == False:\n",
    "            print(\"Sorry that is not a digit!\")\n",
    "            \n",
    "        if choice.isdigit() == True:\n",
    "            if int(choice) in range(0,10):\n",
    "                within_range = True\n",
    "            else:\n",
    "                within_range = False\n",
    "        \n",
    "    \n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number (0-10): 12\n",
      "Please enter a number (0-10): 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_choice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----\n",
    "## Simple User Interaction\n",
    "\n",
    "**Finally let's combine all of these ideas to create a small game where a user can choose a \"position\" in an existing list and replace it with a value of their choice.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "game_list = [0,1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def display_game(game_list):\n",
    "    print(\"Here is the current list\")\n",
    "    print(game_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the current list\n",
      "['hi', 'no', 2]\n"
     ]
    }
   ],
   "source": [
    "display_game(game_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def position_choice():\n",
    "    \n",
    "    # This original choice value can be anything that isn't an integer\n",
    "    choice = 'wrong'\n",
    "    \n",
    "    # While the choice is not a digit, keep asking for input.\n",
    "    while choice not in ['0','1','2']:\n",
    "        \n",
    "        # we shouldn't convert here, otherwise we get an error on a wrong input\n",
    "        choice = input(\"Pick a position to replace (0,1,2): \")\n",
    "        \n",
    "        if choice not in ['0','1','2']:\n",
    "            # THIS CLEARS THE CURRENT OUTPUT BELOW THE CELL\n",
    "            clear_output()\n",
    "            \n",
    "            print(\"Sorry, but you did not choose a valid position (0,1,2)\")\n",
    "            \n",
    "    \n",
    "    # Optionally you can clear everything after running the function\n",
    "    # clear_output()\n",
    "    \n",
    "    # We can convert once the while loop above has confirmed we have a digit.\n",
    "    return int(choice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def replacement_choice(game_list,position):\n",
    "    \n",
    "    user_placement = input(\"Type a string to place at the position\")\n",
    "    \n",
    "    game_list[position] = user_placement\n",
    "    \n",
    "    return game_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gameon_choice():\n",
    "    \n",
    "    # This original choice value can be anything that isn't a Y or N\n",
    "    choice = 'wrong'\n",
    "    \n",
    "    # While the choice is not a digit, keep asking for input.\n",
    "    while choice not in ['Y','N']:\n",
    "        \n",
    "        # we shouldn't convert here, otherwise we get an error on a wrong input\n",
    "        choice = input(\"Would you like to keep playing? Y or N \")\n",
    "\n",
    "        \n",
    "        if choice not in ['Y','N']:\n",
    "            # THIS CLEARS THE CURRENT OUTPUT BELOW THE CELL\n",
    "            clear_output()\n",
    "            \n",
    "            print(\"Sorry, I didn't understand. Please make sure to choose Y or N.\")\n",
    "            \n",
    "    \n",
    "    # Optionally you can clear everything after running the function\n",
    "    # clear_output()\n",
    "    \n",
    "    if choice == \"Y\":\n",
    "        # Game is still on\n",
    "        return True\n",
    "    else:\n",
    "        # Game is over\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Game Logic All Together**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the current list\n",
      "['34', 1, 'new value']\n",
      "Would you like to keep playing? Y or N N\n"
     ]
    }
   ],
   "source": [
    "# Variable to keep game playing\n",
    "game_on = True\n",
    "\n",
    "# First Game List\n",
    "game_list = [0,1,2]\n",
    "\n",
    "\n",
    "\n",
    "while game_on:\n",
    "    \n",
    "    # Clear any historical output and show the game list\n",
    "    clear_output()\n",
    "    display_game(game_list)\n",
    "    \n",
    "    # Have player choose position\n",
    "    position = position_choice()\n",
    "    \n",
    "    # Rewrite that position and update game_list\n",
    "    game_list = replacement_choice(game_list,position)\n",
    "    \n",
    "    # Clear Screen and show the updated game list\n",
    "    clear_output()\n",
    "    display_game(game_list)\n",
    "    \n",
    "    # Ask if you want to keep playing\n",
    "    game_on = gameon_choice()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Great work! You now have an understanding of bringing functions and loop logics together to build a simple game. This will be expanded upon in the Milestone project!**"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}