ansible/files/materials/4-Selections (Solutions).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Selections\n",
    "\n",
    "Often when we're working with numpy we're only interested in a portion of the data in our arrays. The `[]` on `ndarray` allows us select portions of the data in the array in a variety of interesting ways.\n",
    "\n",
    "The exercises in this notebook will teach you how to select elements out of arrays in a variety of ways."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "rand = np.random.RandomState(42)  # Use a deterministic seed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: 1-dimensional selection\n",
    "\n",
    "Write expressions to select the following elements from the array:\n",
    "\n",
    "1. first element\n",
    "1. second element\n",
    "1. last element\n",
    "1. second to last element\n",
    "1. first 5 elements\n",
    "1. last 5 elements\n",
    "1. elements at indices 1, 4, 7, and 13\n",
    "1. elements with even indices\n",
    "1. the entire array, in reverse order\n",
    "1. every other element, starting at index 3 (inclusive) ending at index 17 (exclusive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = np.arange(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[0]  # first element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[1]  # second element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[-1]  # last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[-2]  # second to last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:5]  # first 5 elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15, 16, 17, 18, 19])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[-5:] # last 5 elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  4,  7, 13])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[[1, 4, 7, 13]]  # Elements at indices [1, 4, 7, 13]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[::2]  # Elements with even indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,\n",
       "        2,  1,  0])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[::-1]  # the entire array, in reverse order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  5,  7,  9, 11, 13, 15])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# every other element, starting at index 3 (inclusive) \n",
    "# ending at index 17 (exclusive)\n",
    "array[3:17:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: 2-dimensional selection\n",
    "\n",
    "Write expressions to select the following elements from the array.\n",
    "\n",
    "1. scalar value at coordinates `[3, 6]`\n",
    "1. top-left scalar value\n",
    "1. first row\n",
    "1. first column\n",
    "1. second column\n",
    "1. last column\n",
    "1. first 5 columns\n",
    "1. last 5 columns\n",
    "1. top-left 2 x 2 square\n",
    "1. top-right 2 x 2 square\n",
    "1. last 5 rows from every other column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = np.arange(20 * 20).reshape(20, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[3, 6]  # scalar value at coordinates [3, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[0, 0]  # top left scalar value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[0]  # first row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,  20,  40,  60,  80, 100, 120, 140, 160, 180, 200, 220, 240,\n",
       "       260, 280, 300, 320, 340, 360, 380])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:, 0]  # first column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,  21,  41,  61,  81, 101, 121, 141, 161, 181, 201, 221, 241,\n",
       "       261, 281, 301, 321, 341, 361, 381])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:, 1]  # second column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 19,  39,  59,  79,  99, 119, 139, 159, 179, 199, 219, 239, 259,\n",
       "       279, 299, 319, 339, 359, 379, 399])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:, -1]  # last column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2,   3,   4],\n",
       "       [ 20,  21,  22,  23,  24],\n",
       "       [ 40,  41,  42,  43,  44],\n",
       "       [ 60,  61,  62,  63,  64],\n",
       "       [ 80,  81,  82,  83,  84],\n",
       "       [100, 101, 102, 103, 104],\n",
       "       [120, 121, 122, 123, 124],\n",
       "       [140, 141, 142, 143, 144],\n",
       "       [160, 161, 162, 163, 164],\n",
       "       [180, 181, 182, 183, 184],\n",
       "       [200, 201, 202, 203, 204],\n",
       "       [220, 221, 222, 223, 224],\n",
       "       [240, 241, 242, 243, 244],\n",
       "       [260, 261, 262, 263, 264],\n",
       "       [280, 281, 282, 283, 284],\n",
       "       [300, 301, 302, 303, 304],\n",
       "       [320, 321, 322, 323, 324],\n",
       "       [340, 341, 342, 343, 344],\n",
       "       [360, 361, 362, 363, 364],\n",
       "       [380, 381, 382, 383, 384]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:, :5]  # first 5 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 15,  16,  17,  18,  19],\n",
       "       [ 35,  36,  37,  38,  39],\n",
       "       [ 55,  56,  57,  58,  59],\n",
       "       [ 75,  76,  77,  78,  79],\n",
       "       [ 95,  96,  97,  98,  99],\n",
       "       [115, 116, 117, 118, 119],\n",
       "       [135, 136, 137, 138, 139],\n",
       "       [155, 156, 157, 158, 159],\n",
       "       [175, 176, 177, 178, 179],\n",
       "       [195, 196, 197, 198, 199],\n",
       "       [215, 216, 217, 218, 219],\n",
       "       [235, 236, 237, 238, 239],\n",
       "       [255, 256, 257, 258, 259],\n",
       "       [275, 276, 277, 278, 279],\n",
       "       [295, 296, 297, 298, 299],\n",
       "       [315, 316, 317, 318, 319],\n",
       "       [335, 336, 337, 338, 339],\n",
       "       [355, 356, 357, 358, 359],\n",
       "       [375, 376, 377, 378, 379],\n",
       "       [395, 396, 397, 398, 399]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:, -5:]  # last 5 columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1],\n",
       "       [20, 21]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:2, :2]  # top left 2 x 2 square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[18, 19],\n",
       "       [38, 39]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[:2, -2:]  # top right 2 x 2 square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[300, 302, 304, 306, 308, 310, 312, 314, 316, 318],\n",
       "       [320, 322, 324, 326, 328, 330, 332, 334, 336, 338],\n",
       "       [340, 342, 344, 346, 348, 350, 352, 354, 356, 358],\n",
       "       [360, 362, 364, 366, 368, 370, 372, 374, 376, 378],\n",
       "       [380, 382, 384, 386, 388, 390, 392, 394, 396, 398]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[-5:, ::2]  # last 5 rows from every other column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: N-dimensional selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Selections with boolean arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = rand.normal(0, 1, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write an expression to select the positive values from the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.49671415, 0.64768854, 1.52302986, 1.57921282, 0.76743473,\n",
       "       0.54256004, 0.24196227, 0.31424733, 1.46564877, 0.0675282 ,\n",
       "       0.11092259, 0.37569802, 1.85227818, 0.82254491, 0.2088636 ,\n",
       "       0.19686124, 0.73846658, 0.17136828, 1.05712223, 0.34361829])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array[array > 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write an expression to select the values less than -1 **or** greater than 1.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = rand.normal(0, 1, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.10633497, -1.19620662,  1.53803657,  1.56464366, -2.6197451 ,\n",
       "       -1.98756891, -1.46351495])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NOTE: The parentheses are required here because of the \n",
    "# precedence rules for | and <.\n",
    "array[(array < -1) | ( array > 1.5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = np.arange(-5, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write an expression that produces the value from `array` if the value is positive, and produces the **square** of the value if it's negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([25, 16,  9,  4,  1,  0,  1,  2,  3,  4])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(array > 0, array, array ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: \"FizzBuzz\"\n",
    "\n",
    "Write an expression that converts `array` into a new array of the same shape according to the following rules:\n",
    "\n",
    "At each index `[i]`\n",
    "\n",
    "- if `array[i]` is divisible by 3: `result[i]` should hold -1\n",
    "- if `array[i]` is divisible by 5: `result[i]` should hold -2\n",
    "- if `array[i]` is divisible by 15, `result[i]` should hold -3\n",
    "- otherwise:`result[i]` should hold `array[i]`\n",
    "\n",
    "(**Hint:** `np.select` works like `np.where`, but it can select from more than two arrays.)\n",
    "\n",
    "(**Solution Note:** There are two natural solutions to this question: one using `np.select`, and the other using `np.choose`.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solution using `np.select`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2, -1,  4, -2, -1,  7,  8, -1, -2, 11, -1, 13, 14, -3, 16, 17,\n",
       "       -1, 19, -2, -1, 22, 23, -1, -2, 26, -1, 28, 29, -3, 31, 32, -1, 34,\n",
       "       -2, -1, 37, 38, -1, -2, 41, -1, 43, 44, -3, 46, 47, -1, 49, -2, -1,\n",
       "       52, 53, -1, -2, 56, -1, 58, 59, -3, 61, 62, -1, 64, -2, -1, 67, 68,\n",
       "       -1, -2, 71, -1, 73, 74, -3, 76, 77, -1, 79, -2, -1, 82, 83, -1, -2,\n",
       "       86, -1, 88, 89, -3, 91, 92, -1, 94, -2, -1, 97, 98, -1])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.arange(1, 100)\n",
    "\n",
    "def select_fizzbuzz(a):\n",
    "    by3 = (a % 3) == 0\n",
    "    by5 = (a % 5) == 0\n",
    "    by15 = by3 & by5\n",
    "\n",
    "    return np.select([by15, by5, by3], [-3, -2, -1], a)\n",
    "\n",
    "select_fizzbuzz(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solution using `np.choose`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2, -1,  4, -1, -1,  7,  8, -1, -1, 11, -1, 13, 14, -2, 16, 17,\n",
       "       -1, 19, -1, -1, 22, 23, -1, -1, 26, -1, 28, 29, -2, 31, 32, -1, 34,\n",
       "       -1, -1, 37, 38, -1, -1, 41, -1, 43, 44, -2, 46, 47, -1, 49, -1, -1,\n",
       "       52, 53, -1, -1, 56, -1, 58, 59, -2, 61, 62, -1, 64, -1, -1, 67, 68,\n",
       "       -1, -1, 71, -1, 73, 74, -2, 76, 77, -1, 79, -1, -1, 82, 83, -1, -1,\n",
       "       86, -1, 88, 89, -2, 91, 92, -1, 94, -1, -1, 97, 98, -1])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array = np.arange(1, 100)\n",
    "\n",
    "def choose_fizzbuzz(a):\n",
    "    by3 = (a % 3) == 0\n",
    "    by5 = (a % 5) == 0\n",
    "    selector = by3.astype(int) + by5.astype(int)\n",
    "\n",
    "    return np.choose(selector, [a, -1, -2, -3])\n",
    "\n",
    "choose_fizzbuzz(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: N-dimensional FizzBuzz\n",
    "\n",
    "Same rules as above, but on a 3-dimensional array. (HINT: It's possible to write a solution that works for this exercise and the previous one.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "array = np.arange(1, 100).reshape(3, 11, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2, -1],\n",
       "        [ 4, -2, -1],\n",
       "        [ 7,  8, -1],\n",
       "        [-2, 11, -1],\n",
       "        [13, 14, -3],\n",
       "        [16, 17, -1],\n",
       "        [19, -2, -1],\n",
       "        [22, 23, -1],\n",
       "        [-2, 26, -1],\n",
       "        [28, 29, -3],\n",
       "        [31, 32, -1]],\n",
       "\n",
       "       [[34, -2, -1],\n",
       "        [37, 38, -1],\n",
       "        [-2, 41, -1],\n",
       "        [43, 44, -3],\n",
       "        [46, 47, -1],\n",
       "        [49, -2, -1],\n",
       "        [52, 53, -1],\n",
       "        [-2, 56, -1],\n",
       "        [58, 59, -3],\n",
       "        [61, 62, -1],\n",
       "        [64, -2, -1]],\n",
       "\n",
       "       [[67, 68, -1],\n",
       "        [-2, 71, -1],\n",
       "        [73, 74, -3],\n",
       "        [76, 77, -1],\n",
       "        [79, -2, -1],\n",
       "        [82, 83, -1],\n",
       "        [-2, 86, -1],\n",
       "        [88, 89, -3],\n",
       "        [91, 92, -1],\n",
       "        [94, -2, -1],\n",
       "        [97, 98, -1]]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "select_fizzbuzz(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2, -1],\n",
       "        [ 4, -1, -1],\n",
       "        [ 7,  8, -1],\n",
       "        [-1, 11, -1],\n",
       "        [13, 14, -2],\n",
       "        [16, 17, -1],\n",
       "        [19, -1, -1],\n",
       "        [22, 23, -1],\n",
       "        [-1, 26, -1],\n",
       "        [28, 29, -2],\n",
       "        [31, 32, -1]],\n",
       "\n",
       "       [[34, -1, -1],\n",
       "        [37, 38, -1],\n",
       "        [-1, 41, -1],\n",
       "        [43, 44, -2],\n",
       "        [46, 47, -1],\n",
       "        [49, -1, -1],\n",
       "        [52, 53, -1],\n",
       "        [-1, 56, -1],\n",
       "        [58, 59, -2],\n",
       "        [61, 62, -1],\n",
       "        [64, -1, -1]],\n",
       "\n",
       "       [[67, 68, -1],\n",
       "        [-1, 71, -1],\n",
       "        [73, 74, -2],\n",
       "        [76, 77, -1],\n",
       "        [79, -1, -1],\n",
       "        [82, 83, -1],\n",
       "        [-1, 86, -1],\n",
       "        [88, 89, -2],\n",
       "        [91, 92, -1],\n",
       "        [94, -1, -1],\n",
       "        [97, 98, -1]]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "choose_fizzbuzz(array)"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}