9.5 Module 2 Project .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tic Tac Toe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [ ] This project is an implementation a Tic Tac Toe game. \n",
    "# The logic of the game is in the `main` function, read it before writing any code.\n",
    "\n",
    "# Use the description and examples under each of the following functions to implement them:\n",
    "# 1) draw(board)\n",
    "# 2) available(location, board)\n",
    "# 3) mark(player, location, board)\n",
    "# 4) check_win(board)\n",
    "# 5) check_tie(board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "from random import randint "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw(board): ###### Complete\n",
    "    clear_output\n",
    "    \n",
    "    \"\"\"\n",
    "    Draw the `board` table.\n",
    "    \n",
    "    The board reflects the current state of the game, a number indicates an available location.\n",
    "      \n",
    "    args:\n",
    "        board: 3x3 table (list of lists) containing the current state of the game\n",
    "        \n",
    "    returns:\n",
    "        None\n",
    "        \n",
    "    examples:\n",
    "        At the beginning of the game: board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]\n",
    "        The printout should look like:\n",
    "\n",
    "         7 | 8 | 9 \n",
    "        -----------\n",
    "         4 | 5 | 6 \n",
    "        -----------\n",
    "         1 | 2 | 3 \n",
    "\n",
    "         After a few marks: board = [['7', '8', 'X'], ['O', 'O', '6'], ['1', 'X', '3']]\n",
    "         The printout should look like:\n",
    "         7 | 8 | X \n",
    "        -----------\n",
    "         O | O | 6 \n",
    "        -----------\n",
    "         1 | X | 3 \n",
    "    \"\"\"\n",
    "    #TODO\n",
    "    \n",
    "    print(board[0][0],'|',board[0][1],'|',board[0][2])\n",
    "    print('--|---|---')\n",
    "    print(board[1][0],'|',board[1][1],'|',board[1][2])\n",
    "    print('--|---|---')\n",
    "    print(board[2][0],'|',board[2][1],'|',board[2][2])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 | 8 | 9\n",
      "--|---|---\n",
      "4 | 5 | 6\n",
      "--|---|---\n",
      "1 | 2 | 3\n"
     ]
    }
   ],
   "source": [
    "test_board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]\n",
    "\n",
    "draw(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_2 = [['X','O','X'],['O','O','X'],['X','X','X']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X | O | X\n",
      "--|---|---\n",
      "O | O | X\n",
      "--|---|---\n",
      "X | X | X\n"
     ]
    }
   ],
   "source": [
    "draw(test_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "def available(location, board): ###### Complete\n",
    "    \"\"\"\n",
    "    Check the availability of a `location` on the current `board`\n",
    "    \n",
    "    An available location on the board contains a number between 1 and 9 stored as a string.\n",
    "    If the location contains 'X' or 'O', the location is not available and the function should return False;\n",
    "    otherwise, the function should return True indicating the location is available\n",
    "    \n",
    "    args:\n",
    "        location: a number between 1 and 9 stored as a string\n",
    "        board: 3x3 table (list of lists) containing the current state of the game\n",
    "    \n",
    "    returns:\n",
    "        True if the location is available. False if the location is not available\n",
    "        \n",
    "    examples:\n",
    "        At the beginning of the game: board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]\n",
    "        The printout should look like:\n",
    "\n",
    "         7 | 8 | 9 \n",
    "        -----------\n",
    "         4 | 5 | 6 \n",
    "        -----------\n",
    "         1 | 2 | 3 \n",
    "         \n",
    "         available(\"1\", board) --> returns True\n",
    "         available(\"9\", board) --> returns True\n",
    "\n",
    "\n",
    "         After a few marks: board = [['7', '8', 'X'], ['O', 'O', '6'], ['1', 'X', '3']]\n",
    "         The printout should look like:\n",
    "         7 | 8 | X \n",
    "        -----------\n",
    "         O | O | 6 \n",
    "        -----------\n",
    "         1 | X | 3 \n",
    "        \n",
    "         available(\"1\", board) --> returns True, because there is a number\n",
    "         available(\"5\", board) --> returns False, because there is 'O'\n",
    "         available(\"9\", board) --> returns False, because there is 'X'\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "    \n",
    "    for row in board:\n",
    "        for location in row:\n",
    "            if location == 'X' or location == 'O':\n",
    "                return 'Location not available!'\n",
    "            \n",
    "            else:\n",
    "                return 'Location Available!'                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 | O | 9\n",
      "--|---|---\n",
      "4 | X | 6\n",
      "--|---|---\n",
      "1 | X | 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Location Available!'"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "draw(test_board)\n",
    "\n",
    "available('2',test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mark(player, location, board):  \n",
    "    \"\"\"\n",
    "    Mark `location` on the `board` with the `player` symbol.\n",
    "    \n",
    "    Should replace the `location` number on the board with `X` or `O`\n",
    "    \n",
    "    args:\n",
    "        player: player's symbol, either 'X' or 'O'\n",
    "        location: a number between 1 and 9 stored as a string\n",
    "        board: 3x3 table (list of lists) containing the current state of the game\n",
    "    \n",
    "    returns:\n",
    "        None\n",
    "        \n",
    "    examples:\n",
    "        At the beginning of the game: board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]\n",
    "        The printout should look like:\n",
    "\n",
    "         7 | 8 | 9 \n",
    "        -----------\n",
    "         4 | 5 | 6 \n",
    "        -----------\n",
    "         1 | 2 | 3 \n",
    "         \n",
    "         After mark('O', '4', board)\n",
    "         The printout should look like:\n",
    "         7 | 8 | 9 \n",
    "        -----------\n",
    "         O | 5 | 6 \n",
    "        -----------\n",
    "         1 | 2 | 3 \n",
    "        \n",
    "         After mark('X', '3', board)\n",
    "         The printout should look like:\n",
    "         7 | 8 | 9 \n",
    "        -----------\n",
    "         O | 5 | 6 \n",
    "        -----------\n",
    "         1 | 2 | X \n",
    "         \n",
    "         After mark('O', '9', board)\n",
    "         The printout should look like:\n",
    "         7 | 8 | O \n",
    "        -----------\n",
    "         O | 5 | 6 \n",
    "        -----------\n",
    "         1 | 2 | X \n",
    "    \"\"\"\n",
    "    #TODO\n",
    "    \n",
    "    \n",
    "    \n",
    "    for items in board:\n",
    "        for i in range(len(items)):\n",
    "            if location == items[i]:\n",
    "                items[i] = player\n",
    "                \n",
    "    return(board)    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    #for row in board:\n",
    "        #for col in row:\n",
    "            #if location in col:\n",
    "                #col = player "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 | O | 9\n",
      "--|---|---\n",
      "4 | X | 6\n",
      "--|---|---\n",
      "1 | X | 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[['7', 'O', '9'], ['4', 'X', '6'], ['1', 'X', '3']]"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "draw(test_board)\n",
    "\n",
    "mark('X','2',test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['7', 'O', '9'], ['4', 'X', '6'], ['1', 'X', '3']]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mark('X','5',test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['7', 'O', '9'], ['4', 'X', '6'], ['1', 'X', '3']]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mark('X','8',test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 | O | 9\n",
      "--|---|---\n",
      "4 | X | 6\n",
      "--|---|---\n",
      "1 | X | 3\n"
     ]
    }
   ],
   "source": [
    "draw(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_win(board): ###### Done\n",
    "    \"\"\"\n",
    "    Check if there is a winner.\n",
    "    \n",
    "    A win happens if the either of the players was able to place 3 symbols ('X' or 'O') in:\n",
    "    a horizontal, vertical, diagonal, or anti-diagonal placement.\n",
    "    \n",
    "    args:\n",
    "        board: 3x3 table (list of lists) containing the current state of the game\n",
    "        \n",
    "    returns:\n",
    "        True if there is a winner. False if there is no winner yet\n",
    "        \n",
    "    examples:\n",
    "        Horizontal win:\n",
    "        ================\n",
    "\n",
    "         7 | O | 9 \n",
    "        -----------\n",
    "         X | X | X \n",
    "        -----------\n",
    "         1 | O | 3 \n",
    "        check_win(board) --> returns True, because 'X' won\n",
    "        \n",
    "\n",
    "         O | O | O \n",
    "        -----------\n",
    "         X | X | 6 \n",
    "        -----------\n",
    "         X | O | 3 \n",
    "        check_win(board) --> returns True, because 'O' won\n",
    "    \n",
    "    \n",
    "        Vertical win:\n",
    "        ================\n",
    "\n",
    "         7 | 8 | X \n",
    "        -----------\n",
    "         X | O | X \n",
    "        -----------\n",
    "         O | O | X \n",
    "        check_win(board) --> returns True, because 'X' won\n",
    "         \n",
    "\n",
    "         X | O | O \n",
    "        -----------\n",
    "         4 | O | 6 \n",
    "        -----------\n",
    "         X | O | X \n",
    "        check_win(board) --> returns True, because 'O' won\n",
    "        \n",
    "        \n",
    "        Diagonal win:\n",
    "        ================\n",
    "\n",
    "         X | 8 | O \n",
    "        -----------\n",
    "         4 | X | X \n",
    "        -----------\n",
    "         O | O | X \n",
    "        check_win(board) --> returns True, because 'X' won\n",
    "         \n",
    "\n",
    "         O | X | O \n",
    "        -----------\n",
    "         X | O | X \n",
    "        -----------\n",
    "         1 | 2 | O \n",
    "        check_win(board) --> returns True, because 'O' won\n",
    "        \n",
    "        \n",
    "        Anti-Diagonal win:\n",
    "        ================\n",
    "\n",
    "         O | 8 | X \n",
    "        -----------\n",
    "         4 | X | X \n",
    "        -----------\n",
    "         X | O | O \n",
    "        check_win(board) --> returns True, because 'X' won\n",
    "         \n",
    "\n",
    "         7 | 8 | O \n",
    "        -----------\n",
    "         X | O | X \n",
    "        -----------\n",
    "         O | O | X \n",
    "        check_win(board) --> returns True, because 'O' won\n",
    "        \n",
    "        \n",
    "        No winners yet:\n",
    "        ================\n",
    "\n",
    "         O | 8 | 9 \n",
    "        -----------\n",
    "         4 | X | X \n",
    "        -----------\n",
    "         X | O | O \n",
    "        check_win(board) --> returns False\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "\n",
    "    \n",
    "    return (board[0][0] == board[0][1] == board[0][2] == 'X' or board[0][0] == board[0][1] == board[0][2] == 'O' or\n",
    "            board[1][0] == board[1][1] == board[1][2] == 'X' or board[1][0] == board[1][1] == board[1][2] == 'O' or\n",
    "           board[2][0] == board[2][1] == board[2][2] == 'X' or board[2][0] == board[2][1] == board[2][2] == 'O' or \n",
    "            board[0][0] == board[1][0] == board[2][0] == 'X' or board[0][0] == board[1][0] == board[2][0] == 'O' or \n",
    "           board[0][1] == board[1][1] == board[2][1] == 'X' or board[0][1] == board[1][1] == board[2][1] == 'O' or \n",
    "           board[0][2] == board[1][2] == board[2][2] == 'X' or board[0][2] == board[1][2] == board[2][2] == 'O' or \n",
    "           board[0][0] == board[1][1] == board[2][2] == 'X' or board[0][0] == board[1][1] == board[2][2] == 'O' or \n",
    "           board[0][2] == board[1][1] == board[2][0] == 'X' or board[0][2] == board[1][1] == board[2][0] == 'O')\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 | O | 9\n",
      "--|---|---\n",
      "4 | X | 6\n",
      "--|---|---\n",
      "1 | X | 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "draw(test_board)\n",
    "\n",
    "check_win(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_tie(board): ##### Needs work \n",
    "    \"\"\"\n",
    "    Check the game for a tie, no available locations and no winners.\n",
    "    \n",
    "    args:\n",
    "        board: 3x3 table (list of lists) containing the current state of the game\n",
    "        \n",
    "    returns:\n",
    "        True if there is a tie. False the board is not full yet or there is a winner\n",
    "        \n",
    "    examples:\n",
    "\n",
    "         O | O | X \n",
    "        -----------\n",
    "         X | X | O \n",
    "        -----------\n",
    "         O | O | X \n",
    "         \n",
    "        check_tie(board) --> returns True\n",
    "         \n",
    "\n",
    "\n",
    "         O | O | 9 \n",
    "        -----------\n",
    "         X | X | 6 \n",
    "        -----------\n",
    "         X | O | 3 \n",
    "         \n",
    "        check_tie(board) --> returns False, because there are still available location\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "    \n",
    "    for location in board:\n",
    "        if available(location, board) == False:\n",
    "            return ('Tie Game!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 | O | 9\n",
      "--|---|---\n",
      "4 | X | 6\n",
      "--|---|---\n",
      "1 | X | 3\n"
     ]
    }
   ],
   "source": [
    "draw(test_board)\n",
    "\n",
    "check_tie(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_tie(test_board)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dashes():\n",
    "    \"\"\"Print a fancy line of dashes\"\"\"\n",
    "    print(\"o\" + 35 *'-' + \"o\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o-----------------------------------o\n"
     ]
    }
   ],
   "source": [
    "dashes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display(message):\n",
    "    \"\"\"\n",
    "    Print `message` in the center of a 35 characters string\n",
    "    \n",
    "    args:\n",
    "        message: string to display\n",
    "    \n",
    "    returns:\n",
    "        None\n",
    "    \"\"\"\n",
    "    print(\"|{:^35s}|\".format(message))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o-----------------------------------o\n",
      "|            TIC TAC TOE            |\n",
      "o-----------------------------------o\n",
      "\n",
      "O | X | X\n",
      "--|---|---\n",
      "4 | X | O\n",
      "--|---|---\n",
      "X | 2 | 3\n",
      "\n",
      "o-----------------------------------o\n",
      "|            Game Over!             |\n",
      "|              Winner:              |\n",
      "|                 X                 |\n",
      "o-----------------------------------o\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    # initializing game\n",
    "    board = [['7', '8', '9'], ['4', '5', '6'], ['1', '2', '3']]\n",
    "    # select the first player randomly\n",
    "    player = ['X', 'O']\n",
    "    turn = randint(0, 1)\n",
    "\n",
    "    win = False\n",
    "    tie = False\n",
    "    while(not win and not tie):\n",
    "        # switch players\n",
    "        turn = (turn + 1) % 2\n",
    "        current_player = player[turn] # contains 'X' or 'O'\n",
    "\n",
    "        clear_output()\n",
    "        \n",
    "        # display header\n",
    "        dashes()\n",
    "        display(\"TIC TAC TOE\")\n",
    "        dashes()\n",
    "\n",
    "        # display game board\n",
    "        print()\n",
    "        draw(board)\n",
    "        print()\n",
    "\n",
    "        # display footer\n",
    "        dashes()\n",
    "        # player select a location to mark\n",
    "        while True:\n",
    "            location = input(\"|{:s} Turn, select a number (1, 9): \".format(current_player))\n",
    "            if available(location, board):\n",
    "                break # Only the user input loop, main loop does NOT break\n",
    "            else:\n",
    "                print(\"Selection not available!\")\n",
    "        dashes()\n",
    "\n",
    "        # mark selected location with player symbol ('X' or 'O')\n",
    "        mark(current_player, location, board)\n",
    "        \n",
    "        # check for win\n",
    "        win = check_win(board)\n",
    "        \n",
    "        # check for tie\n",
    "        tie = check_tie(board)\n",
    "        \n",
    "\n",
    "    # Display game over message after a win or a tie\n",
    "    clear_output()\n",
    "    \n",
    "    # display header\n",
    "    dashes()\n",
    "    display(\"TIC TAC TOE\")\n",
    "    dashes()\n",
    "\n",
    "    # display game board (Necessary to draw the latest selection)\n",
    "    print()\n",
    "    draw(board)\n",
    "    print()\n",
    "\n",
    "    # display footer\n",
    "    dashes()\n",
    "    display(\"Game Over!\")\n",
    "    if(tie):\n",
    "        display(\"Tie!\")\n",
    "    elif(win):\n",
    "        display(\"Winner:\")\n",
    "        display(current_player)\n",
    "    dashes()\n",
    "  \n",
    "\n",
    "# Run the game\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}