chapters/Chapter 18 - Import, Read&Write, CSV.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 18: import, read/write, .txt and .csv\n",
    "\n",
    "In this brief chapter, we'll discuss the bare-bones basics of Python import statements, as well as the basic syntax for reading and writing files. We'll also look at opening / writing plain text files and Comma Separated Value (CSV) files. \n",
    "\n",
    "**Questions? Drop em in the Slack!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import\n",
    "\n",
    "For the fullest explanation of import statements, as well as syntax not covered in this overview, **see the [Python documentation](https://docs.python.org/3/reference/import.html)**\n",
    "\n",
    "One of the things that makes Python such an attractive option for scientific research (\"scientific\" including the human sciences!) is its rich open source library of packages that can be imported. We've already worked with `Pandas`, which is one example of such a package. A package is simply a set of Python files, or [modules](https://docs.python.org/3/tutorial/modules.html), that together provide functions or objects that can be used when imported into a Python script. The files contain Python functions or [classes](https://docs.python.org/3/tutorial/classes.html) and can import or call each other. When we import a module, though, we don't need to see any of this. \n",
    "\n",
    "Some packages come standard with a Python installation. For instance, one of the most useful packages is the `collections` packages. The standard import statement is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that collections itself is a kind of object, a `module`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(collections)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like other objects, modules have methods (i.e. functions) that we can call:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ChainMap',\n",
       " 'Counter',\n",
       " 'OrderedDict',\n",
       " 'UserDict',\n",
       " 'UserList',\n",
       " 'UserString',\n",
       " '_Link',\n",
       " '_OrderedDictItemsView',\n",
       " '_OrderedDictKeysView',\n",
       " '_OrderedDictValuesView',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__getattr__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '_chain',\n",
       " '_collections_abc',\n",
       " '_count_elements',\n",
       " '_eq',\n",
       " '_heapq',\n",
       " '_iskeyword',\n",
       " '_itemgetter',\n",
       " '_proxy',\n",
       " '_recursive_repr',\n",
       " '_repeat',\n",
       " '_starmap',\n",
       " '_sys',\n",
       " '_tuplegetter',\n",
       " 'abc',\n",
       " 'defaultdict',\n",
       " 'deque',\n",
       " 'namedtuple']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(collections)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also assign a short-hand name to packages when we import them, with the `as` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the package `numpy` is stored under a variable, `np`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "module"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as with other variables assigned to objects with methods/functions, we can do things with `np`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### There are other details about import statements not dealt with here that you can find out more about in the [Python documentation](https://docs.python.org/3/reference/import.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `pip` installing packages\n",
    "\n",
    "The packages we've been importing here have probably already been installed by your Anaconda setup. But some packages you probably do not have. In Python, packages are stored in the [Python Package Index](https://pypi.org), which can be accessed by doing a \"pip install\". \n",
    "\n",
    "To do this, we need to supply a shell command to the `terminal` of our computer. On a Mac, you can do this by launching the `terminal` app and writing the command directly; on a PC, you can launch it in the `conda shell` via Anaconda.\n",
    "\n",
    "One convient way to run shell commands is from Jupyter notebooks. By adding an exclamation mark to the front of a cell, we can run such commands. For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri 24 Apr 2020 14:33:39 BST\r\n"
     ]
    }
   ],
   "source": [
    "! date"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The command `date` is executed as a shell command. We can do something similar when install python packages. The syntax for installing modules is, with an Anaconda installation: \n",
    "\n",
    "`pip install [module name]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That command needs to be executed as a shell command, so we do so by prepending the necessary exclamation mark. Below we'll install a really useful corpus analysis package called [Text-Fabric](https://annotation.github.io/text-fabric/), which we will use later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: text-fabric in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (7.11.1)\n",
      "Requirement already satisfied: rpyc in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from text-fabric) (4.1.2)\n",
      "Requirement already satisfied: flask in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from text-fabric) (1.1.1)\n",
      "Requirement already satisfied: psutil in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from text-fabric) (5.6.3)\n",
      "Requirement already satisfied: markdown in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from text-fabric) (3.1.1)\n",
      "Requirement already satisfied: ipython in /Users/cody/Library/Python/3.8/lib/python/site-packages (from text-fabric) (7.9.0)\n",
      "Requirement already satisfied: requests in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from text-fabric) (2.22.0)\n",
      "Requirement already satisfied: pygithub>=1.47 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from text-fabric) (1.47)\n",
      "Requirement already satisfied: plumbum in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from rpyc->text-fabric) (1.6.8)\n",
      "Requirement already satisfied: Jinja2>=2.10.1 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from flask->text-fabric) (2.10.3)\n",
      "Requirement already satisfied: click>=5.1 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from flask->text-fabric) (7.0)\n",
      "Requirement already satisfied: Werkzeug>=0.15 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from flask->text-fabric) (0.16.0)\n",
      "Requirement already satisfied: itsdangerous>=0.24 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from flask->text-fabric) (1.1.0)\n",
      "Requirement already satisfied: setuptools>=36 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from markdown->text-fabric) (41.2.0)\n",
      "Requirement already satisfied: backcall in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (0.1.0)\n",
      "Requirement already satisfied: pickleshare in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (0.7.5)\n",
      "Requirement already satisfied: appnope; sys_platform == \"darwin\" in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (0.1.0)\n",
      "Requirement already satisfied: prompt-toolkit<2.1.0,>=2.0.0 in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (2.0.10)\n",
      "Requirement already satisfied: pexpect; sys_platform != \"win32\" in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (4.7.0)\n",
      "Requirement already satisfied: decorator in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (4.4.1)\n",
      "Requirement already satisfied: pygments in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (2.4.2)\n",
      "Requirement already satisfied: traitlets>=4.2 in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (4.3.3)\n",
      "Requirement already satisfied: jedi>=0.10 in /Users/cody/Library/Python/3.8/lib/python/site-packages (from ipython->text-fabric) (0.15.1)\n",
      "Requirement already satisfied: idna<2.9,>=2.5 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from requests->text-fabric) (2.8)\n",
      "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from requests->text-fabric) (1.25.6)\n",
      "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from requests->text-fabric) (3.0.4)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from requests->text-fabric) (2019.9.11)\n",
      "Requirement already satisfied: pyjwt in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from pygithub>=1.47->text-fabric) (1.7.1)\n",
      "Requirement already satisfied: deprecated in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from pygithub>=1.47->text-fabric) (1.2.6)\n",
      "Requirement already satisfied: MarkupSafe>=0.23 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from Jinja2>=2.10.1->flask->text-fabric) (1.1.1)\n",
      "Requirement already satisfied: wcwidth in /Users/cody/Library/Python/3.8/lib/python/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython->text-fabric) (0.1.7)\n",
      "Requirement already satisfied: six>=1.9.0 in /Users/cody/Library/Python/3.8/lib/python/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython->text-fabric) (1.12.0)\n",
      "Requirement already satisfied: ptyprocess>=0.5 in /Users/cody/Library/Python/3.8/lib/python/site-packages (from pexpect; sys_platform != \"win32\"->ipython->text-fabric) (0.6.0)\n",
      "Requirement already satisfied: ipython-genutils in /Users/cody/Library/Python/3.8/lib/python/site-packages (from traitlets>=4.2->ipython->text-fabric) (0.2.0)\n",
      "Requirement already satisfied: parso>=0.5.0 in /Users/cody/Library/Python/3.8/lib/python/site-packages (from jedi>=0.10->ipython->text-fabric) (0.5.1)\n",
      "Requirement already satisfied: wrapt<2,>=1.10 in /Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages (from deprecated->pygithub>=1.47->text-fabric) (1.11.2)\n"
     ]
    }
   ],
   "source": [
    "! pip install text-fabric"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### After this runs, you need to restart the kernel of the notebook to make the installation importable\n",
    "\n",
    "Note that if you do not have an Anaconda installation of Python active, the syntax may be different. Some people may need to say `pip3 install`. See more at:\n",
    "### [PIP Installing tutorials](https://packaging.python.org/tutorials/installing-packages/)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read/Write Files\n",
    "\n",
    "### [Have a look at the Python documentation on read/write](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files)\n",
    "\n",
    "Let's look at how to open basic plain text files. We will open the readme for the course. We will need to think about the file path to do that. A file path points to a location on your machine where a file is. A relative import allows us to import relative to this notebook's current position. \n",
    "\n",
    "By default, two dots indicates to move up one folder or directory. \n",
    "\n",
    "###  [Please read about the syntax of file paths](https://automatetheboringstuff.com/chapter8/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "readme_file = '../README.md'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can open the file. To do so, I will show you the simplest, but not only, method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(readme_file, 'r', encoding='utf8') as infile:\n",
    "    readme = infile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have loaded the readme file for the course. Note the important function `open`, which takes obligatory argument, a file path. We also supply it a second argument `'r'`. This stands for \"read\". \n",
    "\n",
    "**Important: for reading files, suply `'r'`, for writing files supply `'w'`**.\n",
    "\n",
    "We also supply an optional argument, `encoding` to make sure that our computer imports the file with [`utf8` encoding](https://www.w3schools.com/charsets/ref_html_utf8.asp).\n",
    "\n",
    "When we open the file, we assign it a variable, `infile`. We read in that text of that file as a string with `infile.read()`.\n",
    "\n",
    "We can see that the result is a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(readme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can treat it like any other string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "# Python for Linguists and Humanists \n",
      "\n",
      "**Cody Kingham, `cak47[put \"at-sign\" here].cam.ac.uk`**\n",
      "\n",
      "**NOTE: this course will be updated regularly throughout the next few weeks. -12/04/2020**\n",
      "\n",
      "Much of this course material is directly adapted from the [Python for Text Analysis Course](https://github.com/cltl/python-for-text-analysis) at the Vrije Universiteit Amsterdam. I take care to indicate those materials which are directly copied from that course. A special thanks to [Chantal van Son](https://github.com/ChantalvanSon), [Evan Miltenburg](https://github.com/evanmiltenburg), [Marten Postma](https://github.com/MartenPostma), [Filip Ilievski](https://github.com/filievski), Pia Sommerauer, and the [Computational Lexicology & Terminology Lab](http://www.cltl.nl) at the VU.\n",
      "\n",
      "Pandas chapters are from [Joris Van den Bossche's Pandas Tutorial](https://github.com/jorisvandenbossche/pandas-tutorial)\n",
      "\n",
      "## Contents\n",
      "\n",
      "* [Intro](#Intro) - description of the course \n",
      "* [Course Schedule](#Course-Schedule) \n"
     ]
    }
   ],
   "source": [
    "print(readme[:1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can write a file in a similar way. Let's create a blank file and save it in this same folder. We're going to put the contents of the following string in the file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "shakespeare = \"\"\"\n",
    "\n",
    "SCENE I. Rousillon. The COUNT's palace.\n",
    "\n",
    "Enter BERTRAM, the COUNTESS of Rousillon, HELENA, and LAFEU, all in black\n",
    "COUNTESS\n",
    "In delivering my son from me, I bury a second husband.\n",
    "BERTRAM\n",
    "And I in going, madam, weep o'er my father's death\n",
    "anew: but I must attend his majesty's command, to\n",
    "whom I am now in ward, evermore in subjection.\n",
    "LAFEU\n",
    "You shall find of the king a husband, madam; you,\n",
    "sir, a father: he that so generally is at all times\n",
    "good must of necessity hold his virtue to you; whose\n",
    "worthiness would stir it up where it wanted rather\n",
    "than lack it where there is such abundance.\n",
    "COUNTESS\n",
    "What hope is there of his majesty's amendment?\n",
    "LAFEU\n",
    "He hath abandoned his physicians, madam; under whose\n",
    "practises he hath persecuted time with hope, and\n",
    "finds no other advantage in the process but only the\n",
    "losing of hope by time.\n",
    "COUNTESS\n",
    "This young gentlewoman had a father,--O, that\n",
    "'had'! how sad a passage 'tis!--whose skill was\n",
    "almost as great as his honesty; had it stretched so\n",
    "far, would have made nature immortal, and death\n",
    "should have play for lack of work. Would, for the\n",
    "king's sake, he were living! I think it would be\n",
    "the death of the king's disease.\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the string we will write. Here is how we will write it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_file = 'shakespeare.txt'\n",
    "\n",
    "with open(new_file, 'w', encoding='utf8') as outfile:\n",
    "    outfile.write(shakespeare)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new file has now been placed in the same folder as this notebook. \n",
    "\n",
    "If it worked, you should be able to click on this link and open it in the browser:\n",
    "\n",
    "[shakespeare.txt](shakespeare.txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing CSV files\n",
    "\n",
    "CSV is a very useful kind of file which contains tabular data. CSV's can be read and written by most popular spreadsheet software programs like Excel or Google Spreadsheets. We can use the `csv` module to access csv files. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several ways to import / write csv files with the `csv` module. So\n",
    "\n",
    "### [please refer to the csv module documentation](https://docs.python.org/3/library/csv.html)\n",
    "\n",
    "We have a .csv for the course already stored in data. The file path is the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "titanic = '../data/titanic.csv'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way to open this csv file is very similar with opening text files. Except now we will make use of the csv module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(titanic, 'r', encoding='utf8') as infile:\n",
    "    reader = csv.reader(infile)\n",
    "    titanic_data = list(reader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have imported all of the csv rows as a list. Let's peak at the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['PassengerId',\n",
       "  'Survived',\n",
       "  'Pclass',\n",
       "  'Name',\n",
       "  'Sex',\n",
       "  'Age',\n",
       "  'SibSp',\n",
       "  'Parch',\n",
       "  'Ticket',\n",
       "  'Fare',\n",
       "  'Cabin',\n",
       "  'Embarked'],\n",
       " ['1',\n",
       "  '0',\n",
       "  '3',\n",
       "  'Braund, Mr. Owen Harris',\n",
       "  'male',\n",
       "  '22',\n",
       "  '1',\n",
       "  '0',\n",
       "  'A/5 21171',\n",
       "  '7.25',\n",
       "  '',\n",
       "  'S']]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "titanic_data[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can write csv files using similar syntax. Here is an example where we have a list of lists, and each list represents a row in the dataset we want to export."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "rows = [\n",
    "    [1, 'some data1', 'True'],\n",
    "    [2, 'some data2', 'False'],\n",
    "    [3, 'some data3', 'True'],\n",
    "    [4, 'some data4', 'False'],\n",
    "    [5, 'some data5', 'True'],\n",
    "    [6, 'some data6', 'True']\n",
    "]\n",
    "\n",
    "with open('some_data.csv', 'w', encoding='utf8') as outfile:\n",
    "    writer = csv.writer(outfile)\n",
    "    writer.writerows(rows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are other ways to also add header information. To do that...\n",
    "\n",
    "### [Please read over the .csv documentation](https://docs.python.org/3/library/csv.html)"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}