10-Pandas_solutions (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Pandas\n",
    "In this notebook, we'll encounter a very useful package for scientific computing in Python: Pandas. We can think of Pandas as \"numpy with labels\". This package is especially useful for data science and biology for a few reasons:\n",
    "* Great for real-world, heterogeneous data\n",
    "* Similar to Excel spreadsheets (but way faster!)\n",
    "* Smartly deals with missing data\n",
    "\n",
    "### At the end of this notebook, you'll be able to:\n",
    "* Create & manipulate Pandas dataframes\n",
    "* Load a tabular file of genetic data into a Pandas dataframe\n",
    "* Index and subset Pandas dataframes\n",
    "* Generate descriptive statistics for Pandas dataframes\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Importing packages\n",
    "\n",
    "Before we can pandas, we need to import it. The convention is to import `pandas` as `pd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Import packages\n",
    "import pandas as pd\n",
    "\n",
    "# Use whos 'magic command' to see available modules\n",
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Create and Manipulate Dataframes \n",
    "The two data structures of Pandas are the `Series` and the `DataFrame`. A `Series` is a one-dimensional onject similar to a list. A `DataFrame` can be thought of as a two-dimensional numpy array or a collection of `Series` objects. Series and dataframes can contain multiple different data types such as integers, strings, and floats, similar to an Excel spreadsheet. Pandas also supports `string` lables unlike numpy arrays which only have numeric labels for their rows and columns. For a more in depth explanation, please visit the [Introduction to Data Structures](https://pandas.pydata.org/pandas-docs/stable/user_guide/dsintro.html) section in the Pandas User Guide. \n",
    "\n",
    "You can create a Pandas dataframe by inputting dictionaries into the Pandas function `pd.DataFrame()`, by reading files, or through functions built into the Pandas package. The function [`pd.read_csv()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html) reads a comma- or tab-separated file and returns it as a `dataframe`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a data from a dictionary\n",
    "\n",
    "Below, we'll create a dataframe from a dictionary. Since this is quite a bit to fit into one cell, we're also using a trick where we use a pair of open parentheses to tell Python to *ignore* the line breaks here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the dictionary\n",
    "students = (\n",
    "  {'FIRST_NAME': ['Daniel', 'Ben', 'Kavita', 'Linda',\n",
    "                  'Omar','Jane', 'Felicia', 'Rachel',\n",
    "                  'Bob'],\n",
    "   'LAST_NAME': ['Smith', 'Leibstrom', 'Kanabar', 'Thiel',\n",
    "                 'Reichel', 'OConner', 'Rao', 'Crock',\n",
    "                 'McDonald'],\n",
    "   'YEAR': [1, 1, 1, 4, 2, 2, 3, 1, 1],\n",
    "   'HOME_STATE': ['NY', 'NY', 'PA', 'CA', 'OK', 'HI',\n",
    "                  'NY','FL', 'FL'],\n",
    "   'AGE': [18, 19, 19, 22, 21, 19, 20, 17, 18],\n",
    "   'CALC_101_FINAL': [90, 80, None, 60, 70, None, None,\n",
    "                      None, 98],\n",
    "   'ENGLISH_101_FINAL': [80, None, None, 40, 50, None,\n",
    "                         None, 60, 65]} )\n",
    "\n",
    "# Create the dataframe from our dictionary\n",
    "students_df = pd.DataFrame(students)\n",
    "students_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access a list of all of the students' last names using the following notation: `df['column_name']`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access LAST_NAME column\n",
    "lastnames = students_df['LAST_NAME']\n",
    "lastnames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One column of the dataframe is a **series**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check type of column\n",
    "lastnames_list = list(lastnames)\n",
    "print(lastnames_list)\n",
    "type(lastnames_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading from a file example\n",
    "Below we will create a dataframe by reading the file `brainarea_vs_genes_exp_w_reannotations.tsv` which contains information on gene expression accross multiple brain areas. we'll use the `read_csv` function to import our gene expression data as a DataFrame.\n",
    "\n",
    ">**About this dataset:**\n",
    "This dataset was created by Derek Howard and Abigail Mayes for the purpose of accelerating advances in data mining of open brain transcriptome data for polygenetic brain disorders. The data comes from normalized microarray datasets of gene expression from 6 adult human brains that was released by the Allen Brain Institute and then processed into the dataframe we will see below. For more information on this dataset please visit the <a href = \"https://github.com/derekhoward/HBAsets\"> HBAsets repository</a>. \n",
    "\n",
    "Below, we'll use the `read_csv()` function to import our gene expression data as a **data frame**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Read in the list of lists as a data frame\n",
    "# Note \"delimiter\" from loadtxt is \"sep\" here\n",
    "gene_df = pd.read_csv('Data/brainarea_vs_genes_exp_w_reannotations.tsv',sep='\\t')\n",
    "\n",
    "#Show the first five rows\n",
    "gene_df.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the moment, the first column  of information above, called the **index**, just contains a list of numbers.\n",
    "\n",
    "> **Task**: Reassign the row labels by using the method `set_index()` on our dataframe. We can choose any column in our present dataframe to be the row values -- let's assign the row lables to be the `gene_symbol` and re-assign the dataframe. \n",
    "\n",
    "**Question for consideration**: Does `set_index()` work in place"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_index = 'gene_symbol'\n",
    "gene_df = gene_df.set_index(row_index)\n",
    "gene_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It would help to know what information is in our dataset. In other words, what is across the columns at the top?\n",
    "\n",
    "> **Task** Show a list of columns by accessing the `columns` attribute of our dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access the columns of our dataframe \n",
    "# We can use list to avoid truncation\n",
    "list(gene_df.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing Dataframes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing in Pandas works slightly different than in NumPy. Similar to a dictionary, we can index dataframes by their names. \n",
    "\n",
    "The syntax for indexing **single locations** in a dataframe is `dataframe.loc[row_label,column_label]`.\n",
    "\n",
    "To index an **individual column**, we use the shorthand syntax `dataframe[column_label]`.\n",
    "\n",
    "To index an **individual row**, we use the syntax `dataframe.loc[row_label]`.\n",
    "\n",
    "To index by **index #**, we use the syntax `dataframe.iloc[index_number]`.\n",
    "\n",
    "Below are some examples on how to access rows, columns, and single values in our dataframe. For more information on indexing dataframes, visit the <a href = \"https://pandas.pydata.org/docs/user_guide/indexing.html#indexing\"> \"Indexing and selecting data\"</a> section in the Pandas User Guide.\n",
    "\n",
    "> **Task**: Try each of these forms of indexing below. Can you use this syntax to get multiple values (a slice or subset) of the dataframe as well?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(gene_df.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select a single location\n",
    "gene_df.loc['A2ML1','Crus I, lateral hemisphere']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select a single column\n",
    "gene_df['CA1 field']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Select a single row\n",
    "gene_df.loc['A2M']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select a single index\n",
    "# Hint: You can show all indices using gene_df.index\n",
    "gene_df.iloc[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To select multiple different columns, you can use a `list` of all your columns of interest as so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dataframe w/ only CA field entries \n",
    "CA_field_df = gene_df[['CA1 field', \n",
    "                       'CA2 field', \n",
    "                       'CA3 field', \n",
    "                       'CA4 field']]\n",
    "CA_field_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Subsetting dataframes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like NumPy arrays, we can subset our original dataframe to only include data that meets our criteria. Our dataframe has data on multiple different brain areas with many gene expression values. You can filter this dataframe using the following syntax:\n",
    "```\n",
    "new_df = original_df[original_df['Column of Interest'] == 'Desired Value']\n",
    "```\n",
    "In plain english, what this is saying is: save a dataframe from the original dataframe, where the original dataframe values in my Column of Interest are equal to my Desired Value. For more information on subsetting,  visit the <a href = \"https://pandas.pydata.org/docs/getting_started/intro_tutorials/03_subset_data.html\"> \"How do I select a subset of a DataFrame\"</a> section in the Pandas documentation. \n",
    "\n",
    "Below we will demonstrate how to execute this by taking a look at the `CA1 field` column in `gene_df`. We will create a dataframe from `gene_df` that only contains genes that showed a certain level of gene expression. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_df['CA1 field'] > 1.7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataframe with only genes that have an expression \n",
    "# value greater than 1.7 in 'CA1 field' \n",
    "\n",
    "high_CA1 = gene_df[gene_df['CA1 field'] > 1.7]\n",
    "high_CA1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataFrame Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas has many useful methods that you can use on your data, including `describe`, `mean`, and more. To learn more about all the different methods that can be used to manipulate and analyze dataframes, please visit the <a href = \"https://pandas.pydata.org/docs/user_guide/index.html\"> Pandas User Guide </a>. We will demonstrate some of these methods below. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `describe` method returns descriptive statistics of all the columns in our dataframe. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gene_df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `mean` and `std` method return the mean and standard deviation of each column in the dataframe, respectfully. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try df.mean()\n",
    "gene_df.mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try df.std()\n",
    "gene_df.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merging & joining dataframes\n",
    "\n",
    "Let's say we have two different dataframes and we would like to combine the two into one single dataframe. We can use either the `merge` or `join` Pandas methods in order to pull all of this data into one dataframe. \n",
    "\n",
    "![](http://www.datasciencemadesimple.com/wp-content/uploads/2017/09/join-or-merge-in-python-pandas-1.png)\n",
    "\n",
    "There are different types of joins/merges you can do in Pandas, illustrated <a href=\"http://www.datasciencemadesimple.com/join-merge-data-frames-pandas-python/\">above</a>. Here, we want to do an **inner** merge, where we're only keeping entries with indices that are in both dataframes. We could do this merge based on columns, alternatively.\n",
    "\n",
    "**Inner** is the default kind of join, so we do not need to specify it. And by default, join will use the 'left' dataframe, in other words, the dataframe that is executing the `join` method.\n",
    "\n",
    "If you need more information, look at the <a href=\"https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.join.html\">join</a> and <a href=\"https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.merge.html\">merge</a> documentation: you can use either of these to unite your dataframes, though join will be simpler!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is an example of how to join two separate dataframe into one, unified dataframe. We start with one dataframe with only entries from the *temporal pole* and another dataframe with only entries from the CA fields of the hippocampus. We can then join the two dataframes together using the syntax `unified_df = df_1.join(df_2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dataframe w/ only Temporal Pole entries \n",
    "temporal_pole_df = gene_df[['temporal pole, inferior aspect', \n",
    "                            'temporal pole, medial aspect', \n",
    "                            'temporal pole, superior aspect']]\n",
    "temporal_pole_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Join the two dataframes\n",
    "df_1 = temporal_pole_df\n",
    "df_2 = CA_field_df\n",
    "\n",
    "unified_df = df_1.join(df_2)\n",
    "unified_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Group Task\n",
    "### *Does the number of neurons in the cortex scale with cortex size?*\n",
    "In this final task, we'll look at [this dataset](http://www.suzanaherculanohouzel.com/2015-h-h-et-al-bbe-database/) to figure out whether the number of neurons in the cortex scales with cortex size, and if this scaling is different for primates.  \n",
    "\n",
    "To complete this task, do the following steps in a separate notebook:\n",
    "\n",
    "1. Use `pd.read_csv()` to read in our comma-delimited file 'Data/species_brainmass_neurons.csv' and assign it to a dataframe called `brains_df`.\n",
    "2. Separate the dataframe into two dataframes: one that contains all of the primates (`primate_df`; 'Order' is Primata) and one that contains all of the data that are *not* from primates (`nonprimate_df`). **Hint**: You can subset the dataframe by using the syntax `brains_df[brains_df['Order']=='Primata']`.\n",
    "3. Using two separate, subsequent calls to `plt.scatter()` for primates and then non-primates, create a scatterplot with `cortex_mass` on the x axis and `neurons` on the y axis.\n",
    "6. Label your axes.\n",
    "7. (Optional) log scale your axes using `plt.xscale('log')` and `plt.yscale('log')`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Species</th>\n",
       "      <th>Order</th>\n",
       "      <th>cortex_mass_g</th>\n",
       "      <th>Neurons</th>\n",
       "      <th>Other_cells</th>\n",
       "      <th>Neurons_mg</th>\n",
       "      <th>Other_cells_mg</th>\n",
       "      <th>Source</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Sorex fumeus</td>\n",
       "      <td>Eulipotyphla</td>\n",
       "      <td>0.084</td>\n",
       "      <td>9730000</td>\n",
       "      <td>9290000</td>\n",
       "      <td>116727</td>\n",
       "      <td>111754</td>\n",
       "      <td>Sarko et al., 2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Mus musculus</td>\n",
       "      <td>Glires</td>\n",
       "      <td>0.173</td>\n",
       "      <td>13688162</td>\n",
       "      <td>12061838</td>\n",
       "      <td>78672</td>\n",
       "      <td>68643</td>\n",
       "      <td>Herculano-Houzel et al., 2006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Blarina brevicauda</td>\n",
       "      <td>Eulipotyphla</td>\n",
       "      <td>0.197</td>\n",
       "      <td>11876000</td>\n",
       "      <td>15820000</td>\n",
       "      <td>60214</td>\n",
       "      <td>80729</td>\n",
       "      <td>Sarko et al., 2009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Heterocephalus glaber</td>\n",
       "      <td>Glires</td>\n",
       "      <td>0.184</td>\n",
       "      <td>6151875</td>\n",
       "      <td>8398125</td>\n",
       "      <td>33374</td>\n",
       "      <td>45894</td>\n",
       "      <td>Herculano-Houzel et al., 2011</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Condylura cristata</td>\n",
       "      <td>Eulipotyphla</td>\n",
       "      <td>0.420</td>\n",
       "      <td>17250000</td>\n",
       "      <td>32010000</td>\n",
       "      <td>40777</td>\n",
       "      <td>76995</td>\n",
       "      <td>Sarko et al., 2009</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 Species         Order  cortex_mass_g   Neurons  Other_cells  \\\n",
       "0           Sorex fumeus  Eulipotyphla          0.084   9730000      9290000   \n",
       "1           Mus musculus        Glires          0.173  13688162     12061838   \n",
       "2     Blarina brevicauda  Eulipotyphla          0.197  11876000     15820000   \n",
       "3  Heterocephalus glaber        Glires          0.184   6151875      8398125   \n",
       "4     Condylura cristata  Eulipotyphla          0.420  17250000     32010000   \n",
       "\n",
       "   Neurons_mg  Other_cells_mg                         Source  \n",
       "0      116727          111754             Sarko et al., 2009  \n",
       "1       78672           68643  Herculano-Houzel et al., 2006  \n",
       "2       60214           80729             Sarko et al., 2009  \n",
       "3       33374           45894  Herculano-Houzel et al., 2011  \n",
       "4       40777           76995             Sarko et al., 2009  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "brains_df = pd.read_csv('Data/species_brainmass_neurons.csv',sep=',')\n",
    "brains_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# primate observations:  11\n",
      "# non primate observations:  27\n"
     ]
    }
   ],
   "source": [
    "primate_df = brains_df[brains_df['Order']=='Primata']\n",
    "nonprimate_df = brains_df[brains_df['Order']!='Primata']\n",
    "print('# primate observations: ', len(primate_df))\n",
    "print('# non primate observations: ', len(nonprimate_df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig,ax = plt.subplots(1,1,figsize=(5,5))\n",
    "plt.scatter(primate_df['cortex_mass_g'],primate_df['Neurons'])\n",
    "plt.scatter(nonprimate_df['cortex_mass_g'],nonprimate_df['Neurons'])\n",
    "plt.xlabel('Cortex Mass (g)')\n",
    "plt.ylabel('Neurons')\n",
    "plt.title('Relationship between Cortex Mass & Neurons \\nin Primates & Non-Primates')\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.legend(['Primates','Non-Primates'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "## Additional resources\n",
    "See the [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/03.00-introduction-to-pandas.html) for a more in depth exploration of Pandas, and of course, the [Pandas documentation](https://pandas.pydata.org/docs/user_guide/index.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.5"
  },
  "rise": {
   "theme": "serif"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}