Tutorial_02/Numpy-Solved.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In [Tutorial 1](../Tutorial_01), you have seen list, tuple and dictionaries (and we hinted at sets). However, these are not particularly useful when you want to do numerical calculations, or matrix operations. You could try to write a for loop that would iterate through each element, however Python is very slow with operations like that. \n",
    "\n",
    "A better (more Pythonic) way is to use the package known as `numpy`. Numpy arrays are similar to lists and tuples etc. in that they hold multiple values. However, all elements in a numpy array must be of the same data type. \n",
    "\n",
    "Disregarding that small setback, however, we now have a lot more functionality in numpy arrays. It is convenient to think of the behaviour of numpy arrays as similar to a row vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # This is how you can import packages in python. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above line imports the package numpy (which includes all the functions we will be using). The part `as np` renames it to `np` (just for this program, don't worry), which is slightly more convenient. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us assign a numpy array to a variable x. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "x=np.array([1,2,3,4]) # np.array converts any array-like object to a numpy array\n",
    "#x=[1,2,3,4]\n",
    "y=2*x\n",
    "print(\"{}\\n{}\".format(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try the above code with a normal list. Now, hopefully it is clear why `numpy` is powerful. But that is just the beginning!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(0,100, 1) # This is similar to the range function from earlier, except that it returns a numpy array\n",
    "print(x[[4,5,6,7,8,9,10]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying a similar trick with a list instead: (this should give an error!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "list indices must be integers or slices, not list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-982d1529a30a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: list indices must be integers or slices, not list"
     ]
    }
   ],
   "source": [
    "x = [1,2,3,4,5,6,7,8,9,10]\n",
    "print(x[[0,1,2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So `numpy` also supports indexing with lists, instead of only integers or slices, whereas lists don't. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to the `len` function, numpy also has several functions to describe an array. These are also available as methods, which can be used as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "x=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(3, 3)\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(x.ndim) # number of dimensions. This is a 2D array\n",
    "print(x.shape) # Shape of array\n",
    "print(x.size) # Total number of elements in array (product of elements in shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplication, like addition is element wise. If matrix multiplication is required, we can either convert it into a numpy matrix or use `np.dot()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  9],\n",
       "       [16, 25, 36],\n",
       "       [49, 64, 81]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30,  36,  42],\n",
       "        [ 66,  81,  96],\n",
       "        [102, 126, 150]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matrix(x)*np.matrix(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 30,  36,  42],\n",
       "       [ 66,  81,  96],\n",
       "       [102, 126, 150]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparisons on numpy arrays are easier now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x>5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use conditional expressions like indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 0],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y=np.copy(x) # Simply typing y=x doesnot make a new array, it just adds a reference to the old one.\n",
    "             # Changes in y will then be reflected in x\n",
    "y[y>5]=0\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we just want the indices where a certain condition is satisified, we can use `np.where()`. This is one of the more **important** functions, as we can use it to filter out data according to conditions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 1. , 2. , 3. , 4. , 0.5, 0.6])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=np.array([0,1,2,3,4,5,6,7,0.5,0.6])\n",
    "indices=np.where(x<5)\n",
    "x[indices]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also delete elements using `numpy.delete`. \n",
    "\n",
    "Note the array slicing. x is 2 dimensional, and requires 2 indices. `x[:, 0]` returns `np.array[1,4,7]`. Play around with different combinations to become comfortable with using indices, as well as `np.where`. \n",
    "\n",
    "Also note the argument of the function called `axis`. For a 2D array, `axis=0` is along the rows, and `axis=1` is along the columns. `np.where` assigns the index to be `(np.array([2]))`. Removing index 2 along the columns results in y. If you wanted to remove the row instead, then use `axis=0`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [4 5]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "x=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "index=np.where(x[:,0]>5)\n",
    "y=np.delete(x,index,axis=1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Make sure you understand the part about indexing, slicing, and using `np.where` and `np.delete`, and are comfortable using it. Try out different arrays that you define yourself, of different dimensions and shapes, and experiment!!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other useful functions in numpy like `numpy.arange`, `numpy.linspace` often come in handy. We have already seen `arange`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0,1,0.1) # start(inclusive):stop(exclusive):step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,1,5) #start:stop(inclusive):number of elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is not even it. Several mathematical functions are also available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = np.arange(-np.pi, np.pi, 0.1)\n",
    "y = np.sin(x)\n",
    "x_abs = np.abs(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y2 = np.exp(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you thought `numpy` has revealed all its cards, it hasn't yet! <br>\n",
    "You can also find the mean, standard deviation, maximum, minimum of an array, sort an array, do matrix computations and so much more. \n",
    "\n",
    "If you feel right now that NumPy is vast, remember we have barely scratched the surface. In this module and the next is where your Googling skills will be put to the test. \n",
    "\n",
    "If you want to find the official docstrings for any function, an easy way to get it from Jupyter is to use `?`. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that this is a very useful function, since we can use it to filter out data. \n",
    "np.where?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a final note, we will end the tutorial part of this notebook by introducing `np.loadtxt`, a function that can be used to load a txt file into a numpy array. (If you remember how difficult it was to import a text file using `open` and `.split()`, then you will appreciate this one!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "beehive_data = np.loadtxt('Beehive_data.csv', delimiter=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes, that's it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your assignment ...\n",
    "... should you choose to accept it, will be the following:\n",
    "1. Re-do Tutorial 1 assignment with numpy. (This should be fairly easy, but use only numpy functions to reproduce your results)\n",
    "2. Use the data from `Beehive_data.csv` to find the distance to the Beehive Cluster. Read on ahead to find out more about the concepts in astronomy you will need to solve this\n",
    "\n",
    "Data downloaded from [VizieR](https://cdsarc.unistra.fr/viz-bin/cat/V/19), from data used in [Piskunov 1980](https://ui.adsabs.harvard.edu/?#abs/1980BICDS..19...67P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Magnitudes in Astronomy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Magnitudes are a way to describe how bright an object (in our case, a star) is. It is similar to the decibel system for sound in that magnitudes are logarithmic. They can be calculated according to the formula\n",
    "$$\\rm m = -2.5 \\log\\left(\\frac{F}{F_0}\\right)$$\n",
    "where F is the flux from the star (measured in W m$^2$), and F$_0$ is a reference flux.\n",
    "\n",
    "To read up more about magnitudes, hit up the [Wikipedia article on it](https://en.wikipedia.org/wiki/Magnitude_(astronomy)#History)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can calculate the flux of a star at some distance d away as \n",
    "$$ F = \\frac{L}{4\\pi d^2} $$\n",
    "where L is the Luminosity of the star (measured in W). \n",
    "\n",
    "There are a lot of details we have skimmed over (for example, the use of filters) which we will visit again in more detail in `Tutorial 8: Image Reduction`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a final note on the data you have been given in `Beehive_data.csv`, the columns are respectively the apparent magnitude of the stars as seen from Earth, the logarithm of the Luminosity(in units of Luminosity of the Sun) of the stars (i.e. $\\log(L/L_\\odot)$, where $L_\\odot$ is the luminosity of the sun), and the probability that the star belongs to the Beehive Cluster.\n",
    "\n",
    "You must find the distance to the cluster (you are given that the absolute magnitude of the Sun is +4.83). You can do this in two ways:\n",
    "1. Exclude all the stars with low probability of belonging to the cluster, and then calculate distance for each star, and find the mean.\n",
    "2. Find the distance for all stars (including the low probability ones) and find the weighted average of the distances, where the weights are the probability."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Good Luck!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solutions to Day 2, NumPy assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "beehive_data = np.loadtxt('Beehive_data.csv', delimiter=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Part 1: Finding distance considering only high probability stars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do this, as a first step one must filter out the low probabilty stars. We saw in the tutorial that `np.where()` can be used to return certain indices based on some comparison.\n",
    "\n",
    "There is no fixed rule to decide what threshold should be chosen to select high probabitlity stars (the dataset is too small to come up with a precise value). For this particular example let us choose a probabilty above 90.0 as a criterion for selecting stars.\n",
    "\n",
    "Note that your answer may differ depending on the threshold you choose; the method is what counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = np.where(beehive_data[:, 2]>90) #The third column of the 2D array contains the probabilities\n",
    "high_prob = beehive_data[indices] #This now selects only the high probability stars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now find distance for these stars. \n",
    "\n",
    "We have been given that the absolute magnitude of the sun is 4.83 as well as the formula : \n",
    "$$m = -2.5\\log\\left(\\frac{F}{F_0}\\right)$$\n",
    "where the variables and the flux $F$ are as defined in the last part of the tutorial.\n",
    "\n",
    "If you search for information about Absolute Magnitude, you would find that it is the magnitude of the star at a distance of 10 pc, and is related to the apparent magnitude by (and try to see if you can derive this):\n",
    "$$m-M=5(\\log(d)-1)$$\n",
    "where $M$ is the absolute magnitude and $d$ the distance of the star from us in parsecs(pc).\n",
    "\n",
    "Now let $m_\\odot$ denote the apparent magnetude of the sun and $d_\\odot$ the distance of the sun from us. We can then write the following formula assuming $m$ to be the apparent magnitude of the star considered and $d$ its distance:\n",
    "$$m = -2.5log\\left(\\frac{L/4\\pi d^2}{F_0}\\right)$$\n",
    "$$m_\\odot = -2.5\\log\\left(\\frac{L_\\odot/4\\pi d_\\odot^2}{F_0}\\right)$$\n",
    "Subtracting the two we get, \n",
    "$$m_\\odot-m = -2.5\\log\\left(\\frac{L}{L_\\odot}\\right) + 5\\log\\left(\\frac{d}{d_\\odot}\\right)$$ \n",
    "\n",
    "Now using\n",
    "$$m_\\odot - 4.83 = 5(\\log(d) - 1)$$\n",
    "and substituting in the above equation we get after some rearrangement:\n",
    "$$5 \\log(d) = m + 2.5\\log\\left(\\frac{L}{L_\\odot}\\right) + 0.17$$\n",
    "$$\\implies \\log(d) = \\left[m + 2.5\\log\\left(\\frac{L}{L_\\odot}\\right) + 0.17\\right]/5$$\n",
    "\n",
    "Let us code this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd = (high_prob[:,0] + 2.5*high_prob[:,1] + 0.17)/5 #First column contains apparent maginitudes\n",
    "                                                            #and the second the required log values\n",
    "d = 10**logd #We now have the distances of high probability stars in a 1D array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All we need to do is find the sum of the elements of the distance array and divide by its number of elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "159.9814397624894\n"
     ]
    }
   ],
   "source": [
    "sum_of_dist = 0\n",
    "for i in d: #Here we take the sum of all elements in the array\n",
    "    sum_of_dist = sum_of_dist + i\n",
    "dist_of_cluster= sum_of_dist/d.size #Answer is the average\n",
    "print(dist_of_cluster)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we have the answer to part 1!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Finding distance by taking average weighted by probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this part, we need not select any particular elements, we can work with the entire array `beehive_data`. We need to however, take the weighted average, where the weights are the probabilites. Weighted average of a list of quantities is given by:\n",
    "$$\\frac{\\sum quantity\\times weight\\_of\\_this\\_quantity}{\\sum weight\\_of\\_quantity} $$\n",
    "\n",
    "The first step is agian to find the distance similar to the previous part, but this time with whole of `beehive_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "logd_full = (beehive_data[:,0] + 2.5*beehive_data[:,1] + 0.17)/5 \n",
    "d_full = 10**logd_full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we must find the weighted average as per the above formula. Weights are the probabilites of each star and the quantities are the elements of the distance array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "159.5464083490186\n"
     ]
    }
   ],
   "source": [
    "weighted_dist = d_full * beehive_data[:,2] #Using the elementwise multiplication property\n",
    "weighted_sum = 0\n",
    "sum_of_weights = 0\n",
    "for i in range(0, weighted_dist.size):\n",
    "    weighted_sum = weighted_sum + weighted_dist[i] #Numerator in the weighted average formula\n",
    "    sum_of_weights = sum_of_weights + beehive_data[i,2] #Denominator in the weighted average formula\n",
    "weighted_dist_of_cluster = weighted_sum/sum_of_weights #Answer is Numerator/Denominator\n",
    "print(weighted_dist_of_cluster)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, `numpy` provides a function to calculate this weighted average, which would reduce the above block to one line!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}