03-index-slice-subset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Indexing, Slicing and Subsetting DataFrames in Python\n",
    "\n",
    "### Questions:\n",
    "    - \"How can I access specific data within my data set?\"\n",
    "    - \"How can Python and Pandas help me to analyse my data?\"\n",
    "### Objectives:\n",
    "    - \"Describe what 0-based indexing is.\"\n",
    "    - \"Manipulate and extract data using column headings and index locations.\"\n",
    "    - \"Employ slicing to select sets of data from a DataFrame.\"\n",
    "    - \"Employ label and integer-based indexing to select ranges of data in a dataframe.\"\n",
    "    - \"Reassign values within subsets of a DataFrame.\"\n",
    "    - \"Create a copy of a DataFrame.\"\n",
    "    - \"Query / select a subset of data using a set of criteria using the following operators:\n",
    "       `=`, `!=`, `>`, `<`, `>=`, `<=`.\"\n",
    "    - \"Locate subsets of data using masks.\"\n",
    "    - \"Describe BOOLEAN objects in Python and manipulate data using BOOLEANs.\"\n",
    "\n",
    "### Keypoints:\n",
    "    - \"In Python, portions of data can be accessed using indices, slices, column headings, and\n",
    "       condition-based subsetting.\"\n",
    "    - \"Python uses 0-based indexing, in which the first element in a list, tuple or any other data\n",
    "       structure has an index of 0.\"\n",
    "    - \"Pandas enables common data exploration steps such as data indexing, slicing and conditional\n",
    "       subsetting.\"\n",
    "---\n",
    "\n",
    "In the first episode of this lesson, we read a CSV file into a pandas' DataFrame. We learned how to:\n",
    "\n",
    "- save a DataFrame to a named object,\n",
    "- perform basic math on data,\n",
    "- calculate summary statistics, and\n",
    "- create plots based on the data we loaded into pandas.\n",
    "\n",
    "In this lesson, we will explore ways to access different parts of the data using:\n",
    "\n",
    "- indexing,\n",
    "- slicing, and\n",
    "- subsetting.\n",
    "\n",
    "## Loading our data\n",
    "\n",
    "We will continue to use the surveys dataset that we worked with in the last\n",
    "episode. Let's reopen and read in the data again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make sure pandas is loaded\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read in the survey CSV\n",
    "surveys_df = pd.read_csv(\"data/surveys.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Indexing and Slicing in Python\n",
    "\n",
    "We often want to work with subsets of a **DataFrame** object. There are\n",
    "different ways to accomplish this including: using labels (column headings),\n",
    "numeric ranges, or specific x,y index locations.\n",
    "\n",
    "\n",
    "## Selecting data using Labels (Column Headings)\n",
    "\n",
    "We use square brackets `[]` to select a subset of a Python object. For example,\n",
    "we can select all data from a column named `species_id` from the `surveys_df`\n",
    "DataFrame by name. There are two ways to do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# TIP: use the .head() method we saw earlier to make output shorter\n",
    "# Method 1: select a 'subset' of the data using the column name\n",
    "surveys_df['species_id']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Method 2: use the column name as an 'attribute'; gives the same output\n",
    "surveys_df.species_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We can also create a new object that contains only the data within the\n",
    "`species_id` column as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creates an object, surveys_species, that only contains the `species_id` column\n",
    "surveys_species = surveys_df['species_id']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We can pass a list of column names too, as an index to select columns in that\n",
    "order. This is useful when we need to reorganize our data.\n",
    "\n",
    "**NOTE:** If a column name is not contained in the DataFrame, an exception\n",
    "(error) will be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Select the species and plot columns from the DataFrame\n",
    "surveys_df[['species_id', 'plot_id']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# What happens when you flip the order?\n",
    "surveys_df[['plot_id', 'species_id']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What happens if you ask for a column that doesn't exist?\n",
    "surveys_df['speciess']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Python tells us what type of error it is in the traceback, at the bottom it says\n",
    "`KeyError: 'speciess'` which means that `speciess` is not a valid column name (nor a valid key in\n",
    "the related Python data type dictionary).\n",
    "\n",
    "## Extracting Range based Subsets: Slicing\n",
    "\n",
    "\n",
    "Let's remind ourselves that Python uses 0-based\n",
    "indexing. This means that the first element in an object is located at position\n",
    "0. This is different from other tools like R and Matlab that index elements\n",
    "within objects starting at 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a list of numbers:\n",
    "a = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Challenge - Extracting data\n",
    "1. What value does the code below return?\n",
    "\n",
    "`a[0]`\n",
    "\n",
    "2. How about this:\n",
    "\n",
    "`a[5]`\n",
    "\n",
    "3. In the example above, calling `a[5]` returns an error. Why is that?\n",
    "\n",
    "4. What about?\n",
    "\n",
    "`a[len(a)]`\n",
    "\n",
    "\n",
    "## Slicing Subsets of Rows in Python\n",
    "\n",
    "Slicing using the `[]` operator selects a set of rows and/or columns from a\n",
    "DataFrame. To slice out a set of rows, you use the following syntax:\n",
    "`data[start:stop]`. When slicing in pandas the start bound is included in the\n",
    "output. The stop bound is one step BEYOND the row you want to select. So if you\n",
    "want to select rows 0, 1 and 2 your code would look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select rows 0, 1, 2 (row 3 is not selected)\n",
    "surveys_df[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The stop bound in Python is different from what you might be used to in\n",
    "languages like Matlab and R."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select the first 5 rows (rows 0, 1, 2, 3, 4)\n",
    "surveys_df[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select the last element in the list\n",
    "# (the slice starts at the last element, and ends at the end of the list)\n",
    "surveys_df[-1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We can also reassign values within subsets of our DataFrame.\n",
    "\n",
    "But before we do that, let's look at the difference between the concept of\n",
    "copying objects and the concept of referencing objects in Python.\n",
    "\n",
    "## Copying Objects vs Referencing Objects in Python\n",
    "\n",
    "Let's start with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the 'copy() method'\n",
    "true_copy_surveys_df = surveys_df.copy()\n",
    "\n",
    "# Using the '=' operator\n",
    "ref_surveys_df = surveys_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "You might think that the code `ref_surveys_df = surveys_df` creates a fresh\n",
    "distinct copy of the `surveys_df` DataFrame object. However, using the `=`\n",
    "operator in the simple statement `y = x` does **not** create a copy of our\n",
    "DataFrame. Instead, `y = x` creates a new variable `y` that references the\n",
    "**same** object that `x` refers to. To state this another way, there is only\n",
    "**one** object (the DataFrame), and both `x` and `y` refer to it.\n",
    "\n",
    "In contrast, the `copy()` method for a DataFrame creates a true copy of the\n",
    "DataFrame.\n",
    "\n",
    "Let's look at what happens when we reassign the values within a subset of the\n",
    "DataFrame that references another DataFrame object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign the value `0` to the first three rows of data in the DataFrame\n",
    "ref_surveys_df[0:3] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Let's try the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ref_surveys_df was created using the '=' operator\n",
    "ref_surveys_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# surveys_df is the original dataframe\n",
    "surveys_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "What is the difference between these two dataframes?\n",
    "\n",
    "When we assigned the first 3 columns the value of `0` using the\n",
    "`ref_surveys_df` DataFrame, the `surveys_df` DataFrame is modified too.\n",
    "Remember we created the reference `ref_survey_df` object above when we did\n",
    "`ref_survey_df = surveys_df`. Remember `surveys_df` and `ref_surveys_df`\n",
    "refer to the same exact DataFrame object. If either one changes the object,\n",
    "the other will see the same changes to the reference object.\n",
    "\n",
    "Let's create a brand new clean dataframe from\n",
    "the original data CSV file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys_df = pd.read_csv(\"data/surveys.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Slicing Subsets of Rows and Columns in Python\n",
    "\n",
    "We can select specific ranges of our data in both the row and column directions\n",
    "using either label or integer-based indexing.\n",
    "\n",
    "- `loc` is primarily *label* based indexing. *Integers* may be used but\n",
    "  they are interpreted as a *label*.\n",
    "- `iloc` is primarily *integer* based indexing\n",
    "\n",
    "To select a subset of rows **and** columns from our DataFrame, we can use the\n",
    "`iloc` method. For example, we can select month, day and year (columns 2, 3\n",
    "and 4 if we start counting at 1), like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iloc[row slicing, column slicing]\n",
    "surveys_df.iloc[0:3, 1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys_df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Notice that we asked for a slice from 0:3. This yielded 3 rows of data. When you\n",
    "ask for 0:3, you are actually telling Python to start at index 0 and select rows\n",
    "0, 1, 2 **up to but not including 3**.\n",
    "\n",
    "Let's explore some other ways to index and select subsets of data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select all columns for rows of index values 0 and 10\n",
    "surveys_df.loc[[0, 10], :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# What does this do?\n",
    "surveys_df.loc[0, ['species_id', 'plot_id', 'weight']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# What happens when you type the code below?\n",
    "surveys_df.loc[[0, 10, 35549], :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**NOTE**: Labels must be found in the DataFrame or you will get a `KeyError`.\n",
    "\n",
    "Indexing by labels `loc` differs from indexing by integers `iloc`.\n",
    "With `loc`, the both start bound and the stop bound are **inclusive**. When using\n",
    "`loc`, integers *can* be used, but the integers refer to the\n",
    "index label and not the position. For example, using `loc` and select 1:4\n",
    "will get a different result than using `iloc` to select rows 1:4.\n",
    "\n",
    "We can also select a specific data value using a row and\n",
    "column location within the DataFrame and `iloc` indexing:\n",
    "\n",
    "`dat.iloc[row, column]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys_df.iloc[2, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Remember that Python indexing begins at 0. So, the index location [2, 6]\n",
    "selects the element that is 3 rows down and 7 columns over in the DataFrame."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Challenge - Range\n",
    "\n",
    "1. What happens when you execute:\n",
    "\n",
    "    - `surveys_df[0:1]`\n",
    "    - `surveys_df[:4]`\n",
    "    - `surveys_df[:-1]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Validate your answers here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "2. What happens when you call:\n",
    "\n",
    "    - `surveys_df.iloc[0:4, 1:4]`\n",
    "    - `surveys_df.loc[0:4, 1:4]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Validate your answers here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Subsetting Data using Criteria\n",
    "\n",
    "We can also select a subset of our data using criteria. For example, we can\n",
    "select all rows that have a year value of 2002:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "surveys_df[surveys_df.year == 2002]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Or we can select all rows that do not contain the year 2002:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "surveys_df[surveys_df.year != 2002]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We can define sets of criteria too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "surveys_df[(surveys_df.year >= 1980) & (surveys_df.year <= 1985)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "surveys_df[surveys_df.species_id == \"DM\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Python Syntax Cheat Sheet\n",
    "\n",
    "We can use the syntax below when querying data by criteria from a DataFrame.\n",
    "Experiment with selecting various subsets of the \"surveys\" data.\n",
    "\n",
    "* Equals: `==`\n",
    "* Not equals: `!=`\n",
    "* Greater than, less than: `>` or `<`\n",
    "* Greater than or equal to `>=`\n",
    "* Less than or equal to `<=`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Challenge - Queries\n",
    "\n",
    "1. Select a subset of rows in the `surveys_df` DataFrame that contain data from\n",
    "   the year 1999 and that contain weight values less than or equal to 8. How\n",
    "   many rows did you end up with? What did your neighbor get?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "2. You can use the `isin` command in Python to query a DataFrame based upon a\n",
    "   list of values as follows:\n",
    "\n",
    "`surveys_df[surveys_df['species_id'].isin([listGoesHere])]`\n",
    "\n",
    "Use the `isin` function to find all plots that contain particular species\n",
    "in the \"surveys\" DataFrame. How many records contain these values?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "3. Experiment with other queries. Create a query that finds all rows with a\n",
    "   weight value > or equal to 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "4. The `~` symbol in Python can be used to return the OPPOSITE of the\n",
    "   selection that you specify in Python. It is equivalent to **is not in**.\n",
    "   Write a query that selects all rows with sex NOT equal to 'M' or 'F' in\n",
    "   the \"surveys\" data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Using masks to identify a specific condition\n",
    "\n",
    "A **mask** can be useful to locate where a particular subset of values exist or\n",
    "don't exist - for example,  NaN, or \"Not a Number\" values. To understand masks,\n",
    "we also need to understand `BOOLEAN` objects in Python.\n",
    "\n",
    "Boolean values include `True` or `False`. For example,\n",
    "\n",
    "```\n",
    "# Set x to 5\n",
    "x = 5\n",
    "\n",
    "# What does the code below return?\n",
    "x > 5\n",
    "\n",
    "# How about this?\n",
    "x == 5\n",
    "```\n",
    "\n",
    "\n",
    "When we ask Python whether `x` is greater than 5, it returns `False`.\n",
    "This is Python's way to say \"No\". Indeed, the value of `x` is 5,\n",
    "and 5 is not greater than 5.\n",
    "\n",
    "To create a boolean mask:\n",
    "\n",
    "- Set the True / False criteria (e.g. `values > 5 = True`)\n",
    "- Python will then assess each value in the object to determine whether the\n",
    "  value meets the criteria (True) or not (False).\n",
    "- Python creates an output object that is the same shape as the original\n",
    "  object, but with a `True` or `False` value for each index location.\n",
    "\n",
    "Let's try this out. Let's identify all locations in the survey data that have\n",
    "null (missing or NaN) data values. We can use the `isnull` method to do this.\n",
    "The `isnull` method will compare each cell with a null value. If an element\n",
    "has a null value, it will be assigned a value of  `True` in the output object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pd.isnull(surveys_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "To select the rows where there are null values, we can use\n",
    "the mask as an index to subset our data as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To select just the rows with NaN values, we can use the 'any()' method\n",
    "surveys_df[pd.isnull(surveys_df).any(axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Note that the `weight` column of our DataFrame contains many `null` or `NaN`\n",
    "values. We will explore ways of dealing with this in Lesson 03.\n",
    "\n",
    "We can run `isnull` on a particular column too. What does the code below do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "surveys_df['weight']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pd.isnull(surveys_df['weight'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# What does this do?\n",
    "empty_weights = surveys_df[pd.isnull(surveys_df['weight'])]['weight']\n",
    "print(empty_weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Let's take a minute to look at the statement above. We are using the Boolean\n",
    "object `pd.isnull(surveys_df['weight'])` as an index to `surveys_df`. We are\n",
    "asking Python to select rows that have a `NaN` value of weight."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Challenge - Putting it all together\n",
    "\n",
    "1. Create a new DataFrame that only contains observations with sex values that\n",
    "   are **not** female or male. Assign each sex value in the new DataFrame to a\n",
    "   new value of 'x'. Determine the number of null values in the subset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    " 2. Create a new DataFrame that contains only observations that are of sex male\n",
    "   or female and where weight values are greater than 0. Create a stacked bar\n",
    "   plot of average weight by plot with male vs female values stacked for each\n",
    "   plot."
   ]
  },
  {
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}